A project in several files

-- three small files, written here so that the example runs anywhere
fs.write("/shop/lib/money", 'print("loading money")\nreturn {format = function(n) return n .. " coins" end}')
fs.write("/shop/lib/prices", 'local money = import "money"\nreturn {iron = money.format(4)}')
fs.write("/shop/main", 'local prices = import "lib/prices"\nlocal money = import "lib/money"\nprint("iron: " .. prices.iron)\nprint(money.format(12))')
import "/shop/main"
local r = pcall(import, "shop/gold")
print(r.error)

loading money
iron: 4 coins
12 coins
snippet:6: cannot import 'shop/gold': no such file

-- startup: runs at boot. The whole program lives in the panel folder.
import "panel/main"

-- panel/main: a control panel. Each side named in /panel.cfg gets a button
-- that switches its redstone output. Started by /startup.
local config = import "lib/config"
local ui = import "lib/ui"
local log = import "lib/log"
local update = import "lib/update"

local VERSION = 3

local settings = config.load("/panel.cfg", {
  title = "CONTROL PANEL",
  log_file = "/panel.log",
  log_size = 4000,
})
log.setup(settings.log_file, settings.log_size)

-- One button per side that has a name in the settings: left = Furnaces
local buttons = {}
for _, side in ipairs(rs.sides()) do
  if type(settings[side]) == "string" then
    table.insert(buttons, {x = 3, y = 3 + #buttons * 2, w = 26, label = settings[side], side = side, on = false})
  end
end

local function draw()
  ui.clear()
  ui.header(settings.title .. "   v" .. VERSION)
  for _, b in ipairs(buttons) do ui.button(b) end
  if #buttons == 0 then
    ui.status("No outputs yet: add 'left = Lamps' to /panel.cfg", term.colors.orange)
  else
    ui.status("Click a button. Log: " .. settings.log_file)
  end
end

log.info("panel v" .. VERSION .. " started")
draw()
while true do
  local e = os.pull_event()
  if e.name == "click" then
    for _, b in ipairs(buttons) do
      if ui.hit(b, e) then
        b.on = not b.on
        rs.set(b.side, b.on)
        ui.button(b)
        log.info(b.label .. (b.on and " on" or " off"))
      end
    end
  elseif e.name == "message" then
    update.handle(e)
  end
end

-- panel/lib/config: reads a settings file of "key = value" lines.
-- Lines starting with # are comments; numbers and true/false are converted.
local M = {}

-- "12" gives 12, "true" gives true, anything else stays text
local function convert(text)
  if text == "true" then return true end
  if text == "false" then return false end
  local n = tonumber(text)
  if n then return n end
  return text
end

-- The settings written in a text, as a table
function M.parse(text)
  local settings = {}
  for _, raw in ipairs(string.split(text, "\n")) do
    local line = string.trim(raw)
    local eq = string.find(line, "=")
    if eq and not string.starts(line, "#") then
      local key = string.trim(string.sub(line, 1, eq - 1))
      settings[key] = convert(string.trim(string.sub(line, eq + 1)))
    end
  end
  return settings
end

-- Writes settings as a file the player can edit
function M.save(path, settings)
  local lines = {"# Settings: one 'key = value' per line"}
  for k, v in pairs(settings) do
    table.insert(lines, k .. " = " .. tostring(v))
  end
  fs.write(path, table.concat(lines, "\n") .. "\n")
end

-- The settings of path, completed with defaults. A missing file is created
-- from the defaults, so there is something to edit.
function M.load(path, defaults)
  local text = fs.read(path)
  if text == nil then
    M.save(path, defaults)
    text = ""
  end
  local settings = M.parse(text)
  for k, v in pairs(defaults) do
    if settings[k] == nil then settings[k] = v end
  end
  return settings
end

return M

-- panel/lib/ui: drawing helpers for text screens.
local M = {}
local colors = term.colors

function M.clear()
  term.set_bg(colors.black)
  term.clear()
end

-- A blue bar across the top of the screen
function M.header(title)
  term.set_cursor(1, 1)
  term.set_bg(colors.blue)
  term.set_fg(colors.white)
  term.write(" " .. title .. string.rep(" ", term.get_size().w))   -- cut at the edge
  term.set_bg(colors.black)
end

-- A button is a table {x =, y =, w =, label =, on =}: green when on, red when off
function M.button(b)
  local state = b.on and "ON" or "OFF"
  local text = " " .. b.label
  term.set_cursor(b.x, b.y)
  term.set_bg(b.on and colors.green or colors.red)
  term.set_fg(colors.white)
  term.write(text .. string.rep(" ", b.w - #text - #state - 1) .. state .. " ")
  term.set_bg(colors.black)
end

-- Did the click event e land on the button?
function M.hit(b, e)
  return e.y == b.y and e.x >= b.x and e.x < b.x + b.w
end

-- A line of text at the bottom of the screen
function M.status(text, color)
  term.set_cursor(1, term.get_size().h)
  term.set_bg(colors.black)
  term.clear_line()
  term.set_fg(color or colors.light_gray)
  term.write(text)
end

return M

-- panel/lib/log: a log file of dated lines that never grows too big.
local M = {}
local path = "/program.log"   -- changed by M.setup
local max_bytes = 4000

function M.setup(file, size)
  path, max_bytes = file, size
end

local function clock()
  local t = (os.day_time() + 6000) % 24000
  return string.format("%02d:%02d", t // 1000, t % 1000 * 60 // 1000)
end

local function append(line)
  local size = fs.size(path)
  if size and size > max_bytes then
    fs.move(path, path .. ".old")   -- replaces the previous old log
  end
  fs.append(path, line .. "\n")
end

-- A full disk must not stop the program: the line is lost, that is all
function M.write(level, text)
  pcall(append, clock() .. " " .. level .. " " .. text)
end

function M.info(text)
  M.write("INFO", text)
end

function M.warn(text)
  M.write("WARN", text)
end

return M

-- panel/lib/update: installs a new version of the program sent by "push".
local log = import "log"   -- panel/lib/log: the same module as main's

local M = {}
local SECRET = "brass-workshop-7"
local CHANNEL = "update"

local function install(files)
  for path, text in pairs(files) do
    fs.write("/" .. path, text)
  end
end

-- Called by main for each "message" event: true when it was a new version
function M.handle(e)
  local d = e.data
  if e.channel ~= CHANNEL or type(d) ~= "table" or d.secret ~= SECRET or type(d.files) ~= "table" then
    return false
  end
  local r = pcall(install, d.files)
  if not r.ok then
    log.warn("update " .. tostring(d.version) .. " failed: " .. r.error)
    net.send(e.sender, {secret = SECRET, version = d.version, ok = false, error = r.error}, CHANNEL)
    return true
  end
  log.info("updated to version " .. tostring(d.version) .. " by #" .. e.sender)
  net.send(e.sender, {secret = SECRET, version = d.version, ok = true}, CHANNEL)
  os.reboot()   -- the new files run from the start
  return true
end

return M

local M = {}
local colors = term.colors
function M.clear()
  term.set_bg(colors.black)
  term.clear()
end
function M.header(title)
  term.set_cursor(1, 1)
  term.set_bg(colors.blue)
  term.set_fg(colors.white)
  term.write(" " .. title .. string.rep(" ", term.get_size().w))
  term.set_bg(colors.black)
end
function M.button(b)
  local state = b.on and "ON" or "OFF"
  local text = " " .. b.label
  term.set_cursor(b.x, b.y)
  term.set_bg(b.on and colors.green or colors.red)
  term.set_fg(colors.white)
  term.write(text .. string.rep(" ", b.w - #text - #state - 1) .. state .. " ")
  term.set_bg(colors.black)
end
function M.status(text, color)
  term.set_cursor(1, term.get_size().h)
  term.set_bg(colors.black)
  term.clear_line()
  term.set_fg(color or colors.light_gray)
  term.write(text)
end

local ui = M
ui.clear()
ui.header("SMELTING HALL   v3")
ui.button({x = 3, y = 3, w = 26, label = "Furnaces", on = true})
ui.button({x = 3, y = 5, w = 26, label = "Conveyor", on = false})
ui.button({x = 3, y = 7, w = 26, label = "Hall lights", on = true})
ui.status("Click a button. Log: /panel.log")

Screen

-- clone: copies files and folders onto other disks.
-- Usage, from the root: clone startup panel   then swap the disks when asked.
if #arg == 0 then
  print("Usage: clone <file or folder> ...")
  return
end

-- 1. Everything is read into memory, while the original disk is in the drive
local files = {}
local count, bytes = 0, 0
local function collect(path)
  if fs.is_dir(path) then
    for _, name in ipairs(fs.list(path)) do
      collect(path .. "/" .. name)
    end
  else
    local text = fs.read(path)
    if text == nil then error("no file '" .. path .. "'") end
    files[path] = text
    count, bytes = count + 1, bytes + #text
  end
end
for _, name in ipairs(arg) do
  collect(name)
end
print(count .. " files read, " .. bytes .. " bytes.")

local function write_all()
  for path, text in pairs(files) do
    fs.write(path, text)
  end
end

-- 2. A "disk" event comes when a disk leaves the drive and when one comes in
while true do
  print("Eject the disk (sneak + right-click with an empty hand) and insert a new one. Ctrl+T to stop.")
  repeat
    local e = os.pull_event("disk")
  until e.inserted
  local r = pcall(write_all)
  if r.ok then
    print("Copied. " .. fs.free() .. " bytes left on this disk.")
  else
    print("Failed: " .. r.error)
  end
end

-- push: sends the program to every computer whose label starts with "panel",
-- and waits for each one to answer. Usage: push 4   (the version number)
local SECRET = "brass-workshop-7"
local CHANNEL = "update"
local PREFIX = "panel"     -- the labels of the computers to update
local TIMEOUT = 3          -- seconds to wait for the answers
local TRIES = 3

local version = tonumber(arg[1])
if version == nil then
  print("Usage: push <version number>")
  return
end

-- Every file of a folder and of its folders: files["panel/lib/ui"] = "..."
local function collect(dir, files)
  for _, name in ipairs(fs.list("/" .. dir)) do
    local path = dir .. "/" .. name
    if fs.is_dir("/" .. path) then
      collect(path, files)
    else
      files[path] = fs.read("/" .. path)
    end
  end
end

local files = {startup = fs.read("/startup")}
collect("panel", files)
local size = 0
for _, text in pairs(files) do size = size + #text end
if size > 30000 then error("the program is too big for one message: " .. size .. " characters") end

-- The computers to update, found by their labels
local targets = {}
local count = 0
for _, c in ipairs(net.computers()) do
  if c.label and string.starts(c.label, PREFIX) then
    targets[c.id] = {label = c.label, tries = 0, done = false}
    count = count + 1
  end
end
print("Version " .. version .. ", " .. size .. " characters, to " .. count .. " computer(s)")

local message = {secret = SECRET, version = version, files = files}

-- Sends to those that have not answered; returns how many were sent
local function send_round()
  local sent = 0
  for id, t in pairs(targets) do
    if not t.done and t.tries < TRIES then
      t.tries = t.tries + 1
      net.send(id, message, CHANNEL)
      sent = sent + 1
    end
  end
  return sent
end

local function all_done()
  for _, t in pairs(targets) do
    if not t.done then return false end
  end
  return true
end

-- An answer: {secret =, version =, ok =, error =} from one of the targets
local function on_answer(e)
  local d = e.data
  if e.name ~= "message" or e.channel ~= CHANNEL or targets[e.sender] == nil then return end
  if type(d) ~= "table" or d.secret ~= SECRET or d.version ~= version then return end
  local t = targets[e.sender]
  t.done = true
  if d.ok then
    print("#" .. e.sender .. " " .. t.label .. ": updated")
  else
    print("#" .. e.sender .. " " .. t.label .. ": failed, " .. tostring(d.error))
  end
end

while send_round() > 0 do
  local timer = os.start_timer(TIMEOUT)
  while not all_done() do
    local e = os.pull_event()
    if e.name == "timer" and e.id == timer then break end
    on_answer(e)
  end
end

for id, t in pairs(targets) do
  if not t.done then print("#" .. id .. " " .. t.label .. ": no answer") end
end

-- receive: type this once on a new computer, give it a label (label panel-4),
-- then run push in the workshop. It installs the program and reboots.
local SECRET = "brass-workshop-7"
print("Waiting for the program, I am #" .. net.id())
while true do
  local m = net.receive()
  local d = m.data
  if m.channel == "update" and type(d) == "table" and d.secret == SECRET and type(d.files) == "table" then
    for path, text in pairs(d.files) do
      fs.write("/" .. path, text)
    end
    net.send(m.sender, {secret = SECRET, version = d.version, ok = true}, "update")
    os.reboot()
  end
end