-- CeetOS signed release. Generated; do not edit.
-- CEETOS_RELEASE_MANIFEST:{channel="release",profile="router-server",version="0.17.0",size=266650,digest="eb895608360a522bef0f2465ad7d6626db625daff23552f067b73feaea32b6c2",key_id="router-server-release-0.16.9",next_key_id="router-server-release-0.17.0",next_public="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"}
-- CEETOS_RELEASE_SIGNATURE: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
-- CEETOS_RELEASE_PAYLOAD_BEGIN
-- CeetOS installer. Generated; do not edit.
local files = {
  ["startup.lua"] = "local pendingPath,releasePath=\"/ceetos-updates/pending.lua\",\"/ceetos-updates/release.lua\"local pending if fs.exists(pendingPath)then local loader=loadfile(pendingPath)if loader then local ok,value=pcall(loader)if ok and type(value)==\"table\"then pending=value end end end if pending and pending.state==\"apply\"and fs.exists(releasePath)then shell.run(releasePath,\"--ceetos-apply\")elseif fs.exists(\"/ceetos/startup.lua\")then shell.run(\"/ceetos/startup.lua\")else shell.run(\"shell\")end",
  ["ceetos/startup.lua"] = "local root=\"/ceetos\"local profile={id=\"desktop\"}if fs.exists(root..\"/profile.lua\")then local loader=loadfile(root..\"/profile.lua\")if loader then local ok,value=pcall(loader);if ok and type(value)==\"table\"then profile=value end end end if profile.id~=\"desktop\"and fs.exists(root..\"/server.lua\")then shell.run(root..\"/server.lua\")elseif fs.exists(root..\"/ceet.lua\")then shell.run(root..\"/ceet.lua\")else printError(\"CeetOS is incomplete; starting CraftOS shell.\")shell.run(\"shell\")end",
  ["ceetos/profile.lua"] = "return {schema=1,id=\"router-server\"}",
  ["ceetos/lib/store.lua"] = "local M={}local cache={}local function internalPath(path)return type(path)~=\"string\"or path:sub(-4)==\".new\"or path:sub(-4)==\".bak\"end local function call(fn,...)local result={pcall(fn,...)}if not result[1]then return false,tostring(result[2])end if result[2]==false then return false,tostring(result[3]or\"operation failed\")end return true,result[2],result[3]end local function exists(path)local ok,value=call(fs.exists,path)return ok and value==true end local function remove(path)if not exists(path)then return true end local ok,err=call(fs.delete,path)return ok,err end local function ensureDirectory(path)local dir=fs.getDir(path)if dir==\"\"or exists(dir)then return true end local ok,err=call(fs.makeDir,dir)return ok,err end local function readRaw(path)local ok,handleOrErr=call(fs.open,path,\"r\")if not ok or not handleOrErr then return false,nil,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local readOk,content=call(handle.readAll)local closeOk,closeErr=call(handle.close)if not readOk then return false,nil,content end if not closeOk then return false,nil,closeErr end return true,content end local function writeRaw(path,content)local ok,handleOrErr=call(fs.open,path,\"w\")if not ok or not handleOrErr then return false,tostring(handleOrErr or\"could not open file\")end local handle=handleOrErr local writeOk,writeErr=call(handle.write,content)local closeOk,closeErr=call(handle.close)if not writeOk then return false,writeErr end if not closeOk then return false,closeErr end return true end local function move(source,destination)local ok,err=call(fs.move,source,destination)return ok,err end local function decode(raw)local ok,value=pcall(textutils.unserialise,raw)if not ok or value==nil then return false,nil,\"invalid serialised value\"end return true,value end local function readValue(path)local ok,raw,err=readRaw(path)if not ok then return false,nil,err end return decode(raw)end local function recoverValue(path)local activeOk,activeValue=false,nil if exists(path)then activeOk,activeValue=readValue(path)end if activeOk then remove(path..\".new\")remove(path..\".bak\")return true,activeValue end local backupOk,backupValue=false,nil if exists(path..\".bak\")then backupOk,backupValue=readValue(path..\".bak\")end if backupOk then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,backupValue end remove(path..\".new\")return false,nil end local function validLines(raw)for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local ok,value=pcall(textutils.unserialise,line)if not ok or value==nil then return false,\"invalid appended value\"end end end return true end local function recoverAppend(path)if exists(path)then local activeOk,raw=readRaw(path)if activeOk then local valid=validLines(raw)if valid then remove(path..\".new\")remove(path..\".bak\")return true,raw end end end if exists(path..\".bak\")then local backupOk,raw=readRaw(path..\".bak\")if backupOk and validLines(raw)then if exists(path)then remove(path)end if not exists(path)then move(path..\".bak\",path)end remove(path..\".new\")return true,raw end end remove(path..\".new\")return false,\"no valid appended value\"end local function commitRaw(path,raw,validator)local dirOk,dirErr=ensureDirectory(path)if not dirOk then return false,dirErr end local temporary,backup=path..\".new\",path..\".bak\"local removeOk,removeErr=remove(temporary)if not removeOk then return false,removeErr end local writeOk,writeErr=writeRaw(temporary,raw)if not writeOk then remove(temporary);return false,writeErr end local checkOk,checkedRaw,checkErr=readRaw(temporary)if not checkOk then remove(temporary);return false,checkErr end local valid,validErr=validator(checkedRaw)if not valid then remove(temporary);return false,validErr or\"temporary validation failed\"end local backupRemoveOk,backupRemoveErr=remove(backup)if not backupRemoveOk then remove(temporary);return false,backupRemoveErr end if exists(path)then local backupOk,backupErr=move(path,backup)if not backupOk then remove(temporary);return false,backupErr end local activateOk,activateErr=move(temporary,path)if not activateOk then if not exists(path)then move(backup,path)end remove(temporary)return false,activateErr end else local activateOk,activateErr=move(temporary,path)if not activateOk then remove(temporary);return false,activateErr end end return true end function M.readCached(path,fallback)if internalPath(path)then return fallback end local entry=cache[path]if entry~=nil then return entry.value end return M.readFresh(path,fallback)end function M.readFresh(path,fallback)if internalPath(path)then return fallback end local ok,value=recoverValue(path)if not ok then value=fallback end cache[path]={value=value}return value end function M.read(path,fallback)return M.readCached(path,fallback)end function M.writeAtomic(path,value)if internalPath(path)then return false,\"cannot write store temporary or backup path\"end if value==nil then return false,\"cannot store nil\"end local serialisedOk,raw=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(raw)~=\"string\"then return false,tostring(raw or\"could not serialise value\")end local valid=decode(raw)if not valid then return false,\"could not validate serialised value\"end recoverValue(path)local ok,err=commitRaw(path,raw,decode)if ok then cache[path]={value=value}end return ok,err end function M.write(path,value)return M.writeAtomic(path,value)end function M.append(path,value,limits)if internalPath(path)then return false,\"cannot append to store temporary or backup path\"end if value==nil then return false,\"cannot append nil\"end local serialisedOk,line=pcall(textutils.serialise,value,{compact=true})if not serialisedOk or type(line)~=\"string\"then return false,tostring(line or\"could not serialise value\")end local valid=validLines(line..\"\\n\")if not valid then return false,\"could not validate appended value\"end local recovered,current=recoverAppend(path)if not recovered then if exists(path)or exists(path..\".bak\")then return false,current end current=\"\"end local lines={}for existing in(current..\"\\n\"):gmatch(\"(.-)\\n\")do if existing~=\"\"then lines[#lines+1]=existing end end lines[#lines+1]=line local maxEntries=limits and tonumber(limits.maxEntries)local maxBytes=limits and tonumber(limits.maxBytes)if maxEntries then maxEntries=math.max(1,math.floor(maxEntries))end if maxBytes then maxBytes=math.max(1,math.floor(maxBytes))end while maxEntries and#lines>maxEntries do table.remove(lines,1)end local raw=table.concat(lines,\"\\n\")if#raw>0 then raw=raw..\"\\n\"end while maxBytes and#raw>maxBytes and#lines>1 do table.remove(lines,1)raw=table.concat(lines,\"\\n\")..\"\\n\"end if maxBytes and#raw>maxBytes then return false,\"appended value exceeds byte limit\"end local ok,err=commitRaw(path,raw,validLines)if ok then cache[path]=nil end return ok,err end function M.readAppend(path)if internalPath(path)then return\"\"end local ok,raw=recoverAppend(path)return ok and raw or\"\"end function M.invalidate(path)cache[path]=nil end return M",
  ["ceetos/lib/profile.lua"] = "local store=require(\"ceetos.lib.store\")local M={}M.PATH=\"/ceetos/profile.lua\"M.IDS={desktop=true,[\"recipe-server\"]=true,[\"router-server\"]=true,[\"auth-server\"]=true}local cache local function normalise(value)if type(value)~=\"table\"then value={}end local id=tostring(value.id or value.profile or\"desktop\")if not M.IDS[id]then id=\"desktop\"end return{schema=1,id=id,installedAt=tonumber(value.installedAt)or 0}end function M.current()if not cache then cache=normalise(store.read(M.PATH,{id=\"desktop\"}))end return cache end function M.id()return M.current().id end function M.is(id)return M.id()==id end function M.isServer()return M.id()~=\"desktop\"end function M.set(id)assert(M.IDS[id],\"invalid CeetOS profile\")cache={schema=1,id=id,installedAt=os.epoch(\"utc\")}return store.write(M.PATH,cache)end function M.capability(name)local id=M.id()local tableFor={desktop={desktop=true,craftingClient=true,orders=true},[\"recipe-server\"]={server=true,recipes=true,recipeImport=true,recipePlan=true},[\"router-server\"]={server=true,routing=true},[\"auth-server\"]={server=true,authAuthority=true},}return tableFor[id][name]==true end return M",
  ["ceetos/lib/auth.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local audit=require(\"ceetos.lib.audit\")local M={current=nil}local USERS=\"/ceetos/data/users.lua\"local SESSION=\"/ceetos/data/session.lua\"local TOMBSTONES=\"/ceetos/data/user-tombstones.lua\"local THROTTLE=\"/ceetos/data/login-throttle.lua\"local RECOVERY=\"/ceetos/data/recovery.lua\"local AUTHORITY=\"/ceetos/data/auth-authority.lua\"local CENTRAL_SESSION=\"/ceetos/data/auth-session.lua\"local DIRECTORY=\"/ceetos/data/auth-directory.lua\"local rank={viewer=1,operator=2,admin=3}M.SESSION_TTL_MS=8*60*60*1000 M.LOGIN_THROTTLE={failures=5,windowMs=5*60*1000,lockMs=60*1000,maxEntries=64}local configuredWorkFactor=password.DEFAULT_WORK_FACTOR local sessionPathDelete local function now()return os.epoch(\"utc\")end local function accountName(name)return type(name)==\"string\"and name:match(\"^[%w_%-]+$\")and#name<=32 end local function users()store.invalidate(USERS);return store.read(USERS,{})end local function save(value)return store.write(USERS,value)end local function tombstones()store.invalidate(TOMBSTONES);return store.read(TOMBSTONES,{})end local function saveTombstones(value)return store.write(TOMBSTONES,value)end local function authority()store.invalidate(AUTHORITY)local value=store.read(AUTHORITY,nil)return type(value)==\"table\"and value.active==true and type(value.id)==\"string\"and value or nil end function M.authority()return authority()end function M.centralActive()return authority()~=nil end local function centralDirectory()store.invalidate(DIRECTORY)local value=store.read(DIRECTORY,{})return type(value)==\"table\"and type(value.users)==\"table\"and value or{users={}}end function M.acceptAuthority(record)assert(type(record)==\"table\"and type(record.id)==\"string\"and#record.id<=64,\"invalid auth authority\")local public={schema=1,active=true,id=record.id,term=math.max(0,math.floor(tonumber(record.term)or 0)),revision=math.max(0,math.floor(tonumber(record.revision)or 0)),seen=now()}assert(store.write(AUTHORITY,public),\"could not save auth authority\")if type(record.directory)==\"table\"then assert(store.write(DIRECTORY,{schema=1,revision=public.revision,users=record.directory}),\"could not save account directory\")end local loaded,profile=pcall(require,\"ceetos.lib.profile\")if not loaded or not profile.is(\"auth-server\")then if fs.exists(USERS)then fs.delete(USERS)end if fs.exists(TOMBSTONES)then fs.delete(TOMBSTONES)end sessionPathDelete()end return public end function M.updateDirectory(directory,revision)if type(directory)~=\"table\"then return false,\"invalid account directory\"end return store.write(DIRECTORY,{schema=1,revision=math.max(0,math.floor(tonumber(revision)or 0)),users=directory})end function M.saveCentralSession(value)if type(value)~=\"table\"or not accountName(value.name)or type(value.role)~=\"string\"then return false,\"invalid central session\"end local session={sessionVersion=3,name=value.name,role=value.role,token=value.token,issued=value.issued,expires=value.expires,accountRevision=value.accountRevision,authority=value.authority}if type(session.token)~=\"string\"or#session.token<16 then return false,\"invalid central session token\"end store.write(CENTRAL_SESSION,session)M.current=nil return true end local function safeAudit(action,detail)pcall(audit.log,\"auth\",action,detail or{})end local function stamp(account)account.updated=now()account.origin=tostring(os.getComputerID())account.revision=math.max(0,math.floor(tonumber(account.revision)or 0))+1 return account end local function makeAccount(role,plainPassword,context)local record,err=password.record(plainPassword,password.newSalt(context),configuredWorkFactor)assert(record,err)record.role=role return stamp(record)end sessionPathDelete=function()if fs.exists(SESSION)then fs.delete(SESSION)end store.invalidate(SESSION)end local function saveSession()if M.current==nil then sessionPathDelete();return end local durable={sessionVersion=2,name=M.current.name,nonce=M.current.nonce,issued=M.current.issued,expires=M.current.expires,accountRevision=M.current.accountRevision,}store.write(SESSION,durable)end local function makeSession(name,account)local issued=now()M.current={name=name,role=account.role,nonce=password.newSalt(\"session:\"..name),issued=issued,expires=issued+M.SESSION_TTL_MS,accountRevision=tonumber(account.revision)or 0,}saveSession()return M.current end local function liveAccount(name)local all=users()return all[name],all end local function normaliseSession(saved,account)if type(saved)~=\"table\"or not account or account.disabled then return nil end if saved.sessionVersion==2 then local issued,expires,revision=tonumber(saved.issued),tonumber(saved.expires),tonumber(saved.accountRevision)if type(saved.nonce)~=\"string\"or#saved.nonce<16 or not issued or not expires or not revision then return nil end if expires<=now()or revision~=(tonumber(account.revision)or 0)then return nil end return{name=saved.name,role=account.role,nonce=saved.nonce,issued=issued,expires=expires,accountRevision=revision}end if saved.sessionVersion==nil and type(saved.role)==\"string\"then return\"legacy\"end return nil end function M.refreshSession()local central=authority()if central then store.invalidate(CENTRAL_SESSION)local saved=store.read(CENTRAL_SESSION,nil)local entry=type(saved)==\"table\"and centralDirectory().users[saved.name]or nil if type(saved)~=\"table\"or saved.sessionVersion~=3 or saved.authority~=central.id or type(saved.token)~=\"string\"or(tonumber(saved.expires)or 0)<=now()or type(entry)~=\"table\"or entry.disabled==true or saved.accountRevision~=entry.revision then M.current=nil if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end return nil end M.current={name=saved.name,role=entry.role,nonce=saved.token,issued=saved.issued,expires=saved.expires,accountRevision=saved.accountRevision,authority=central.id,central=true}return M.current end store.invalidate(SESSION)local saved=store.read(SESSION,nil)if type(saved)~=\"table\"or not accountName(saved.name)then M.current=nil;return nil end local account=liveAccount(saved.name)local session=normaliseSession(saved,account)if session==\"legacy\"then return makeSession(saved.name,account)end if not session then M.current=nil sessionPathDelete()return nil end M.current=session return M.current end local function throttleState()store.invalidate(THROTTLE)local data=store.read(THROTTLE,{})return type(data)==\"table\"and data or{}end local function saveThrottle(data)local entries={}for name,entry in pairs(data)do if accountName(name)and type(entry)==\"table\"and type(entry.last)==\"number\"then entries[#entries+1]={name=name,last=entry.last}end end table.sort(entries,function(a,b)return a.last>b.last end)local kept={}for index,entry in ipairs(entries)do if index<=M.LOGIN_THROTTLE.maxEntries then kept[entry.name]=data[entry.name]end end store.write(THROTTLE,kept)end local function locked(name)if not accountName(name)then return false end local entry=throttleState()[name]return entry and(tonumber(entry.lockedUntil)or 0)>now()or false end local function noteFailure(name,reason)if not accountName(name)then return end local data,entry,time=throttleState(),nil,now()entry=data[name]or{failures=0,first=time}if time-(tonumber(entry.first)or 0)>M.LOGIN_THROTTLE.windowMs then entry.failures,entry.first=0,time end entry.failures=math.max(0,math.floor(tonumber(entry.failures)or 0))+1 entry.last=time if entry.failures>=M.LOGIN_THROTTLE.failures then entry.lockedUntil=time+M.LOGIN_THROTTLE.lockMs end data[name]=entry saveThrottle(data)safeAudit(\"login.failure\",{account=name,reason=reason or\"invalid\",throttled=(entry.lockedUntil or 0)>time})end local function clearFailures(name)local data=throttleState()if data[name]~=nil then data[name]=nil;saveThrottle(data)end end function M.throttleStatus(name)local entry=accountName(name)and throttleState()[name]or nil if not entry then return{failures=0,lockedUntil=0}end return{failures=tonumber(entry.failures)or 0,lockedUntil=tonumber(entry.lockedUntil)or 0}end function M.setPasswordWorkFactor(value)local work,err=password.normaliseWorkFactor(value)assert(work,err)configuredWorkFactor=work return work end function M.passwordWorkFactor()return configuredWorkFactor end function M.bootstrap(initialPassword)if authority()then return false end local all=users()if next(all)then return false end local plainPassword=initialPassword if plainPassword==nil then term.write(\"Create CeetOS admin password: \");plainPassword=read(\"*\")end local account=makeAccount(\"admin\",plainPassword,\"admin\")all.admin=account assert(save(all),\"could not save administrator account\")makeSession(\"admin\",account)safeAudit(\"bootstrap\",{account=\"admin\"})return true end function M.login(name,plainPassword)if authority()then local client=require((\"ceetos.lib.auth_client\"))return client.login(name,plainPassword)end if not accountName(name)or type(plainPassword)~=\"string\"then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if locked(name)then safeAudit(\"login.failure\",{account=name,reason=\"throttled\",throttled=true})return false,\"too many failed attempts; try again later\"end local account,all=liveAccount(name)if not account or account.disabled then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end local valid,state=password.verify(account,plainPassword)if not valid then noteFailure(name,\"invalid\")return false,\"invalid credentials\"end if state==\"legacy\"then local upgraded=makeAccount(account.role,plainPassword,\"upgrade:\"..name)upgraded.updated=account.updated or upgraded.updated upgraded.origin=account.origin or upgraded.origin upgraded.revision=math.max(tonumber(account.revision)or 0,upgraded.revision)stamp(upgraded)all[name]=upgraded assert(save(all),\"could not upgrade password record\")account=upgraded safeAudit(\"password.upgraded\",{account=name})end clearFailures(name)makeSession(name,account)safeAudit(\"login.success\",{account=name})return true end function M.logout()M.current=nil sessionPathDelete()if fs.exists(CENTRAL_SESSION)then fs.delete(CENTRAL_SESSION)end end function M.add(name,role,plainPassword)if authority()then assert(rank[role]and accountName(name),\"invalid user or role\")local record,err=makeAccount(role,plainPassword,\"central:\"..name)assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"add\",{name=name,role=role,record=record})end M.require(\"operator\")assert(rank[role],\"invalid role\")if role==\"admin\"then M.require(\"admin\")end assert(accountName(name),\"invalid user name\")local all=users()assert(not all[name],\"user exists\")all[name]=makeAccount(role,plainPassword,name)assert(save(all),\"could not save user\")safeAudit(\"user.add\",{account=name,role=role})end local function adminCount(all)local count=0 for _,account in pairs(all)do if account.role==\"admin\"and not account.disabled then count=count+1 end end return count end function M.setRole(name,role)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"role\",{name=name,role=role})end M.require(\"operator\")assert(accountName(name)and rank[role],\"invalid user or role\")local all,account=users(),users()[name]assert(account,\"unknown user\")if role==\"admin\"or account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot change the active account role\")assert(not(account.role==\"admin\"and role~=\"admin\"and adminCount(all)<=1),\"cannot remove the last administrator\")account.role=role stamp(account)all[name]=account assert(save(all),\"could not save account role\")safeAudit(\"user.role\",{account=name,role=role})end function M.setDisabled(name,disabled)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"disable\",{name=name,disabled=disabled==true})end M.require(\"admin\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")assert(not(M.current and M.current.name==name),\"cannot disable the active account\")if disabled then assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot disable the last administrator\")end account.disabled=disabled==true stamp(account)all[name]=account assert(save(all),\"could not save account state\")safeAudit(\"user.disabled\",{account=name,disabled=account.disabled})end function M.remove(name)if authority()then return require((\"ceetos.lib.auth_client\")).mutate(\"remove\",{name=name})end M.require(\"operator\")assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end assert(not(M.current and M.current.name==name),\"cannot delete the active account\")assert(not(account.role==\"admin\"and adminCount(all)<=1),\"cannot delete the last administrator\")all[name]=nil local removed=tombstones()removed[name]=now()assert(saveTombstones(removed),\"could not save account tombstone\")assert(save(all),\"could not remove account\")safeAudit(\"user.remove\",{account=name})end local function recoveryActive()store.invalidate(RECOVERY)local recovery=store.read(RECOVERY,{})return type(recovery)==\"table\"and(tonumber(recovery.until_ts)or 0)>now()end local function setPassword(name,plainPassword)assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]assert(account,\"unknown user\")local replacement=makeAccount(account.role,plainPassword,\"reset:\"..name)replacement.updated=account.updated or replacement.updated replacement.origin=account.origin or replacement.origin replacement.revision=math.max(tonumber(account.revision)or 0,replacement.revision)replacement.disabled=account.disabled==true stamp(replacement)all[name]=replacement assert(save(all),\"could not save password\")if M.current and M.current.name==name then M.current=nil;sessionPathDelete()end safeAudit(\"password.reset\",{account=name})return true end function M.resetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end if not M.allowed(\"admin\")and not recoveryActive()then error(\"permission denied (requires admin or active recovery window)\",2)end return setPassword(name,plainPassword)end function M.adminResetPassword(name,plainPassword)if authority()then local account=centralDirectory().users[name];assert(account,\"unknown user\")local record,err=makeAccount(account.role,plainPassword,\"central-reset:\"..name);assert(record,err)return require((\"ceetos.lib.auth_client\")).mutate(\"reset\",{name=name,record=record})end M.require(\"operator\")local account=users()[name]assert(account,\"unknown user\")if account.role==\"admin\"then M.require(\"admin\")end return setPassword(name,plainPassword)end function M.allowed(role)if not rank[role]then return false end local current=M.refreshSession()return current~=nil and rank[current.role]>=rank[role]end function M.require(role)if not M.allowed(role)then error(\"permission denied (requires \"..tostring(role)..\")\",2)end end function M.list()local out={}local source=authority()and centralDirectory().users or users()for name,account in pairs(source)do out[#out+1]={name=name,role=account.role,disabled=account.disabled==true,revision=account.revision}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.snapshot()if authority()then return{users={},tombstones={},source=tostring(os.getComputerID()),schema=3,central=true}end return M.authoritySnapshot()end function M.authoritySnapshot()local copy={users={},tombstones={},source=tostring(os.getComputerID()),schema=2}for name,account in pairs(users())do copy.users[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=tonumber(account.revision)or 0,disabled=account.disabled==true,updated=account.updated or 0,origin=account.origin or copy.source,}end for name,removed in pairs(tombstones())do copy.tombstones[name]=removed end return copy end local function validIncomingPassword(account)if password.isModern(account)then local work=password.normaliseWorkFactor(account.workFactor)return work~=nil and type(account.verifier)==\"string\"and#account.verifier==64 and account.verifier:match(\"^[0-9a-f]+$\")~=nil end return type(account.salt)==\"string\"and#account.salt>0 and#account.salt<=256 and type(account.verifier)==\"string\"and account.verifier:match(\"^[0-9a-fA-F]+$\")~=nil and#account.verifier==8 end function M.merge(snapshot,authoritySeed)if authority()and authoritySeed~=true then return false,\"distributed account sync is disabled by central authority\"end if type(snapshot)~=\"table\"or type(snapshot.users)~=\"table\"then return false,\"invalid account sync\"end local all,removed,changed=users(),tombstones(),false for name,deletedAt in pairs(snapshot.tombstones or{})do if accountName(name)and type(deletedAt)==\"number\"and deletedAt>(removed[name]or 0)then local localAccount=all[name]if not localAccount or(localAccount.updated or 0)<=deletedAt then all[name],removed[name],changed=nil,deletedAt,true end end end for name,account in pairs(snapshot.users)do if accountName(name)and type(account)==\"table\"and rank[account.role]and validIncomingPassword(account)then local updated=tonumber(account.updated)or 0 local localAccount,incomingOrigin=all[name],tostring(account.origin or snapshot.source or\"\")local localOrigin=localAccount and tostring(localAccount.origin or os.getComputerID())or\"\"local wins=not localAccount or updated>(localAccount.updated or 0)or(updated==(localAccount.updated or 0)and incomingOrigin~=\"\"and incomingOrigin<localOrigin)if(removed[name]==nil or updated>removed[name])and wins then all[name]={role=account.role,salt=account.salt,verifier=account.verifier,passwordVersion=account.passwordVersion,scheme=account.scheme,workFactor=account.workFactor,revision=math.max(0,math.floor(tonumber(account.revision)or 0)),disabled=account.disabled==true,updated=updated,origin=incomingOrigin,}changed=true end end end if changed then assert(save(all),\"could not save account sync\")assert(saveTombstones(removed),\"could not save account tombstones\")M.refreshSession()end return changed end function M.authorityAccount(name)if not accountName(name)then return nil end return users()[name]end function M.authorityDirectory()local out={}for name,account in pairs(users())do out[name]={role=account.role,disabled=account.disabled==true,revision=tonumber(account.revision)or 0}end return out end function M.authorityMutate(action,fields)fields=type(fields)==\"table\"and fields or{}local name=fields.name assert(accountName(name),\"invalid user name\")local all,account=users(),users()[name]if action==\"add\"then assert(not account,\"user exists\")assert(rank[fields.role],\"invalid role\")local record=fields.record assert(type(record)==\"table\"and password.isModern(record),\"central account mutation requires a verifier record\")record.role,record.disabled=fields.role,false;all[name]=stamp(record);assert(save(all),\"could not save user\")elseif action==\"role\"then assert(account and rank[fields.role],\"unknown user or invalid role\")if account.role==\"admin\"and fields.role~=\"admin\"then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot demote the last active admin\")end account.role=fields.role;stamp(account);all[name]=account;assert(save(all),\"could not save role\")elseif action==\"disable\"then if account and account.role==\"admin\"and fields.disabled==true then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot disable the last active admin\")end assert(account,\"unknown user\");account.disabled=fields.disabled==true;stamp(account);all[name]=account;assert(save(all),\"could not save user state\")elseif action==\"remove\"then assert(account,\"unknown user\")if account.role==\"admin\"and not account.disabled then local admins=0;for _,candidate in pairs(all)do if candidate.role==\"admin\"and not candidate.disabled then admins=admins+1 end end assert(admins>1,\"cannot remove the last active admin\")end all[name]=nil;local removed=tombstones();removed[name]=now();assert(saveTombstones(removed),\"could not save tombstone\");assert(save(all),\"could not remove user\")elseif action==\"reset\"then assert(account,\"unknown user\")local replacement=fields.record assert(type(replacement)==\"table\"and password.isModern(replacement),\"central password reset requires a verifier record\")replacement.role,replacement.disabled=account.role,account.disabled==true;all[name]=stamp(replacement);assert(save(all),\"could not save password\")else error(\"unsupported account mutation\")end safeAudit(\"authority.\"..action,{account=name})return M.authorityDirectory()end M.refreshSession()return M",
  ["ceetos/lib/password.lua"] = "local M={}M.SCHEME=\"pbkdf2-hmac-sha256\"M.PASSWORD_VERSION=2 M.DEFAULT_WORK_FACTOR=256 M.MIN_WORK_FACTOR=64 M.MAX_WORK_FACTOR=2048 M.MIN_LENGTH=8 M.MAX_LENGTH=128 local MOD=4294967296 local band,bor,bxor,bnot=bit32.band,bit32.bor,bit32.bxor,bit32.bnot local rshift,lshift=bit32.rshift,bit32.lshift local unpack=table.unpack or unpack local K={0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,}local initial={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}local function add(...)local value=0 for i=1,select(\"#\",...)do value=(value+(select(i,...)or 0))%MOD end return value end local function rrotate(value,amount)if bit32.rrotate then return bit32.rrotate(value,amount)end return bor(rshift(value,amount),lshift(value,32-amount))end local function word(bytes,index)return bytes:byte(index)*16777216+bytes:byte(index+1)*65536+bytes:byte(index+2)*256+bytes:byte(index+3)end local function packWord(value)return string.char(band(rshift(value,24),0xff),band(rshift(value,16),0xff),band(rshift(value,8),0xff),band(value,0xff))end local function sha256Raw(value)local bitLength=#value*8 value=value..string.char(0x80)value=value..string.rep(\"\\0\",(56-(#value%64))%64)value=value..packWord(math.floor(bitLength/MOD))..packWord(bitLength%MOD)local h={unpack(initial)}for offset=1,#value,64 do if#value>16384 and offset>1 and((offset-1)/64)%128==0 and type(sleep)==\"function\"then sleep(0)end local w={}for i=1,16 do w[i]=word(value,offset+(i-1)*4)end for i=17,64 do local x,y=w[i-15],w[i-2]local s0=bxor(rrotate(x,7),rrotate(x,18),rshift(x,3))local s1=bxor(rrotate(y,17),rrotate(y,19),rshift(y,10))w[i]=add(w[i-16],s0,w[i-7],s1)end local a,b,c,d,e,f,g,hh=unpack(h)for i=1,64 do local s1=bxor(rrotate(e,6),rrotate(e,11),rrotate(e,25))local choice=bxor(band(e,f),band(bnot(e),g))local t1=add(hh,s1,choice,K[i],w[i])local s0=bxor(rrotate(a,2),rrotate(a,13),rrotate(a,22))local majority=bxor(band(a,b),band(a,c),band(b,c))local t2=add(s0,majority)hh,g,f,e,d,c,b,a=g,f,e,add(d,t1),c,b,a,add(t1,t2)end h[1],h[2],h[3],h[4]=add(h[1],a),add(h[2],b),add(h[3],c),add(h[4],d)h[5],h[6],h[7],h[8]=add(h[5],e),add(h[6],f),add(h[7],g),add(h[8],hh)end local result={}for i=1,8 do result[i]=packWord(h[i])end return table.concat(result)end local function hmac(key,message)if#key>64 then key=sha256Raw(key)end key=key..string.rep(\"\\0\",64-#key)local inner,outer={},{}for i=1,64 do local byte=key:byte(i)inner[i],outer[i]=string.char(bxor(byte,0x36)),string.char(bxor(byte,0x5c))end return sha256Raw(table.concat(outer)..sha256Raw(table.concat(inner)..message))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function cooperate(round)if round%32~=0 or not(os and os.queueEvent and os.pullEvent)then return end os.queueEvent(\"ceetos_password_yield\")os.pullEvent(\"ceetos_password_yield\")end local function toHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function constantEqual(left,right)if type(left)~=\"string\"or type(right)~=\"string\"then return false end local differing=bxor(#left,#right)local length=math.max(#left,#right)for i=1,length do differing=bor(differing,bxor(left:byte(i)or 0,right:byte(i)or 0))end return differing==0 end function M.hmacSha256(key,message)if type(key)~=\"string\"or type(message)~=\"string\"then return nil,\"HMAC key and message must be strings\"end return toHex(hmac(key,message))end function M.sha256(value)if type(value)~=\"string\"then return nil,\"SHA-256 input must be a string\"end return toHex(sha256Raw(value))end function M.constantTimeEqual(left,right)return constantEqual(left,right)end function M.legacyDigest(value)local h=2166136261 for i=1,#value do h=bxor(h,value:byte(i))h=(h*16777619)%MOD end return string.format(\"%08x\",h)end function M.normaliseWorkFactor(value)value=tonumber(value)if not value or value%1~=0 then return nil,\"invalid password work factor\"end if value<M.MIN_WORK_FACTOR or value>M.MAX_WORK_FACTOR then return nil,\"password work factor must be \"..M.MIN_WORK_FACTOR..\"-\"..M.MAX_WORK_FACTOR end return value end function M.policy(password)if type(password)~=\"string\"then return false,\"password is required\"end if#password<M.MIN_LENGTH or#password>M.MAX_LENGTH then return false,\"password must contain \"..M.MIN_LENGTH..\"-\"..M.MAX_LENGTH..\" characters\"end if password:find(\"[%z\\1-\\31\\127]\")then return false,\"password contains control characters\"end return true end function M.derive(password,salt,workFactor)local work,err=M.normaliseWorkFactor(workFactor)if not work then return nil,err end if type(password)~=\"string\"or type(salt)~=\"string\"or#salt<16 or#salt>256 then return nil,\"invalid password record\"end local block=string.char(0,0,0,1)local value=hmac(password,salt..block)local result=value for _=2,work do value=hmac(password,value)result=xorBytes(result,value)cooperate(_)end return toHex(result)end local saltCounter=0 function M.newSalt(context)saltCounter=saltCounter+1 local now=os.epoch and os.epoch(\"utc\")or 0 local computer=os.getComputerID and os.getComputerID()or 0 local label=os.getComputerLabel and os.getComputerLabel()or\"\"local random=math.random and math.random(0,2147483647)or 0 return toHex(sha256Raw(table.concat({tostring(now),tostring(computer),tostring(label),tostring(context or\"\"),tostring(saltCounter),tostring(random)},\":\"))):sub(1,32)end function M.record(password,salt,workFactor)local valid,err=M.policy(password)if not valid then return nil,err end local work,workErr=M.normaliseWorkFactor(workFactor or M.DEFAULT_WORK_FACTOR)if not work then return nil,workErr end salt=salt or M.newSalt()local verifier,deriveErr=M.derive(password,salt,work)if not verifier then return nil,deriveErr end return{passwordVersion=M.PASSWORD_VERSION,scheme=M.SCHEME,salt=salt,verifier=verifier,workFactor=work,}end function M.isModern(record)return type(record)==\"table\"and record.passwordVersion==M.PASSWORD_VERSION and record.scheme==M.SCHEME end function M.verify(record,password)if type(record)~=\"table\"or type(password)~=\"string\"or type(record.salt)~=\"string\"or type(record.verifier)~=\"string\"then return false,\"invalid password record\"end if M.isModern(record)then local verifier,err=M.derive(password,record.salt,record.workFactor)if not verifier then return false,err end return constantEqual(record.verifier,verifier),nil end return constantEqual(record.verifier,M.legacyDigest(record.salt..password)),\"legacy\"end return M",
  ["ceetos/lib/release_keys.lua"] = "return{algorithm=\"lamport-sha256-v1\",roots={[\"router-server-release-0.16.8\"]={public=\"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\",profile=\"router-server\"},[\"router-server-release-0.16.9\"]={public=\"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\",profile=\"router-server\"},},}",
  ["ceetos/lib/release_verify.lua"] = "local password=require(\"ceetos.lib.password\")local roots=require(\"ceetos.lib.release_keys\")local profile=require(\"ceetos.lib.profile\")local M={}M.CACHE_ROOT=\"/ceetos-updates\"M.CACHE_FILE=\"/ceetos-updates/release.lua\"M.META_FILE=\"/ceetos-updates/cache.lua\"M.PART_FILE=\"/ceetos-updates/release.part\"M.PENDING_FILE=\"/ceetos-updates/pending.lua\"M.MAX_PACKAGE_BYTES=1024*1024 M.MAX_MANIFEST_BYTES=48*1024 M.CHUNK_BYTES=3072 M.KEY_PARTS=256 local alphabet=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"local decodeMap={}for i=1,#alphabet do decodeMap[alphabet:sub(i,i)]=i-1 end local function read(path)if not fs.exists(path)or fs.isDir(path)then return nil end local handle=fs.open(path,\"r\")if not handle then return nil end local value=handle.readAll();handle.close()return value end local function write(path,value)local parent=fs.getDir(path)if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary=path..\".tmp\"if fs.exists(temporary)then fs.delete(temporary)end local handle=assert(fs.open(temporary,\"w\"),\"could not create temporary release state\")handle.write(value);handle.close()if fs.exists(path)then fs.delete(path)end fs.move(temporary,path)end local function encode(value)local out,index={},1 while index<=#value do local a,b,c=value:byte(index,index+2)local n=(a or 0)*65536+(b or 0)*256+(c or 0)out[#out+1]=alphabet:sub(math.floor(n/262144)%64+1,math.floor(n/262144)%64+1)out[#out+1]=alphabet:sub(math.floor(n/4096)%64+1,math.floor(n/4096)%64+1)out[#out+1]=b and alphabet:sub(math.floor(n/64)%64+1,math.floor(n/64)%64+1)or\"=\"out[#out+1]=c and alphabet:sub(n%64+1,n%64+1)or\"=\"index=index+3 end return table.concat(out)end local function decode(value)if type(value)~=\"string\"or#value%4~=0 or#value>M.MAX_MANIFEST_BYTES*2 then return nil,\"invalid base64\"end local out={}for index=1,#value,4 do local a,b,c,d=value:sub(index,index),value:sub(index+1,index+1),value:sub(index+2,index+2),value:sub(index+3,index+3)if not decodeMap[a]or not decodeMap[b]or(c~=\"=\"and not decodeMap[c])or(d~=\"=\"and not decodeMap[d])then return nil,\"invalid base64\"end if(c==\"=\"and d~=\"=\")or((c==\"=\"or d==\"=\")and index+3~=#value)then return nil,\"invalid base64 padding\"end local n=decodeMap[a]*262144+decodeMap[b]*4096+(decodeMap[c]or 0)*64+(decodeMap[d]or 0)out[#out+1]=string.char(math.floor(n/65536)%256)if c~=\"=\"then out[#out+1]=string.char(math.floor(n/256)%256)end if d~=\"=\"then out[#out+1]=string.char(n%256)end end return table.concat(out)end local function unhex(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function semver(value)if type(value)~=\"string\"then return nil end local major,minor,patch=value:match(\"^(%d+)%.(%d+)%.(%d+)$\")if not major then return nil end return tonumber(major),tonumber(minor),tonumber(patch)end function M.compareVersions(left,right)local a,b,c=semver(left);local x,y,z=semver(right)if not a or not x then return nil,\"invalid semantic version\"end if a~=x then return a<x and-1 or 1 end if b~=y then return b<y and-1 or 1 end if c~=z then return c<z and-1 or 1 end return 0 end local function canonical(manifest)if manifest._legacyProfile==true then return table.concat({\"ceetos-release-v1\",tostring(manifest.channel),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end return table.concat({\"ceetos-release-v2\",tostring(manifest.channel),tostring(manifest.profile),tostring(manifest.version),tostring(manifest.size),tostring(manifest.digest),tostring(manifest.key_id),tostring(manifest.next_key_id),tostring(manifest.next_public),},\"|\")end local function unpackKey(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*2*32 then return nil,err or\"invalid public key\"end local parts={}for index=1,M.KEY_PARTS*2 do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end function M.validPublicKey(value)return unpackKey(value)end local function lookupKey(keyId)local saved=M.trustedKeys()local value=saved[keyId]if value then return unpackKey(value)end value=roots.roots and roots.roots[keyId]if type(value)==\"table\"and type(value.public)==\"string\"then value=value.public end return unpackKey(value)end local function bitAt(digest,index)local byte=digest:byte(math.floor((index-1)/8)+1)return bit32.band(bit32.rshift(byte,7-((index-1)%8)),1)end local function decodeSignature(value)local raw,err=decode(value)if not raw or#raw~=M.KEY_PARTS*32 then return nil,err or\"invalid signature\"end local parts={}for index=1,M.KEY_PARTS do parts[index]=raw:sub((index-1)*32+1,index*32)end return parts end local function verifySignature(manifest,signature)if roots.algorithm~=\"lamport-sha256-v1\"then return false,\"unsupported release signing algorithm\"end local public,publicErr=lookupKey(manifest.key_id)local parts,signatureErr=decodeSignature(signature)if not public or not parts then local prefix=not public and\"invalid release public key: \"or\"invalid release signature: \"return false,prefix..tostring(publicErr or signatureErr or\"unknown release key\")end local digest=unhex(password.sha256(canonical(manifest))or\"\")if not digest then return false,\"could not hash release manifest\"end for index=1,M.KEY_PARTS do local expected=public[(index-1)*2+bitAt(digest,index)+1]local candidate=unhex(password.sha256(parts[index])or\"\")if not candidate or not password.constantTimeEqual(candidate,expected)then return false,\"invalid release signature\"end end return true end local function validateManifest(manifest)if type(manifest)~=\"table\"or manifest.channel~=\"release\"then return nil,\"only signed release packages are accepted\"end if manifest.profile==nil then manifest.profile,manifest._legacyProfile=\"desktop\",true end if type(manifest.profile)~=\"string\"or not profile.IDS[manifest.profile]then return nil,\"invalid release profile\"end if not semver(manifest.version)or type(manifest.size)~=\"number\"or manifest.size<1 or manifest.size>M.MAX_PACKAGE_BYTES then return nil,\"invalid release manifest size or version\"end if type(manifest.digest)~=\"string\"or#manifest.digest~=64 or manifest.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if type(manifest.key_id)~=\"string\"or#manifest.key_id<1 or#manifest.key_id>64 then return nil,\"invalid release key id\"end if type(manifest.next_key_id)~=\"string\"or#manifest.next_key_id<1 or#manifest.next_key_id>64 then return nil,\"invalid next release key id\"end local nextKey=unpackKey(manifest.next_public)if not nextKey then return nil,\"invalid successor release key\"end return manifest end function M.parse(source)if type(source)~=\"string\"or#source>M.MAX_PACKAGE_BYTES then return nil,\"release package is too large\"end local encodedManifest,encodedSignature=source:match(\"^%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")if not encodedManifest then encodedManifest,encodedSignature=source:match(\"^%-%- CeetOS signed release%. Generated; do not edit%.[\\r\\n]+%-%- CEETOS_RELEASE_MANIFEST:([^\\r\\n]+)[\\r\\n]+%-%- CEETOS_RELEASE_SIGNATURE:([^\\r\\n]+)\")end local first=source:find(\"%-%- CEETOS_RELEASE_PAYLOAD_BEGIN[\\r\\n]+\")if not encodedManifest or not encodedSignature or not first then return nil,\"not a signed CeetOS release package\"end local decoded,decodeErr=decode(encodedManifest)if not decoded then return nil,\"invalid release manifest encoding: \"..tostring(decodeErr)end local loader=load(\"return \"..decoded,\"=release-manifest\",\"t\",{})if not loader then return nil,\"invalid release manifest\"end local ok,manifest=pcall(loader)if not ok then return nil,\"invalid release manifest\"end local valid,manifestErr=validateManifest(manifest)if not valid then return nil,manifestErr end local start=source:find(\"\\n\",first)+1 local finish=start+valid.size-1 local payload=source:sub(start,finish)local suffix=source:sub(finish+1)if suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\\n\"and suffix~=\"\\n-- CEETOS_RELEASE_PAYLOAD_END\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\\r\\n\"and suffix~=\"\\r\\n-- CEETOS_RELEASE_PAYLOAD_END\"then return nil,\"release payload boundary mismatch\"end if#payload~=valid.size or not password.constantTimeEqual(password.sha256(payload)or\"\",valid.digest)then return nil,\"release payload digest mismatch\"end local signed,signatureErr=verifySignature(valid,encodedSignature)if not signed then return nil,signatureErr end return{manifest=valid,signature=encodedSignature,payload=payload,source=source}end function M.trustedKeys()local raw=read(M.CACHE_ROOT..\"/trusted-keys.lua\")if not raw then return{}end local loader=load(raw,\"=trusted-release-keys\",\"t\",{})if not loader then return{}end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or{}end local function saveKeys(value)local encoded=textutils.serialise(value,{compact=true})write(M.CACHE_ROOT..\"/trusted-keys.lua\",\"return \"..encoded)end function M.metadata()local raw=read(M.META_FILE)if not raw then return nil end local loader=load(raw,\"=release-cache\",\"t\",{})if not loader then return nil end local ok,value=pcall(loader)return ok and type(value)==\"table\"and value or nil end function M.cache(source,provider)local package,err=M.parse(source)if not package then return nil,err end if fs.exists(M.CACHE_ROOT)and fs.isDir(M.CACHE_ROOT)then if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end elseif not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end write(M.CACHE_FILE,package.source)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))local keys=M.trustedKeys();keys[package.manifest.next_key_id]=package.manifest.next_public;saveKeys(keys)return metadata end function M.promotePart(path,provider)if type(path)~=\"string\"or path~=M.PART_FILE then return nil,\"invalid release staging path\"end local source=read(path)local package,err=M.parse(source)if not package then return nil,err end if not fs.exists(M.CACHE_ROOT)then fs.makeDir(M.CACHE_ROOT)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end fs.move(M.PART_FILE,M.CACHE_FILE)local metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=provider and tostring(provider)or\"local\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))M.adopt(package)return metadata end function M.adopt(package)if type(package)~=\"table\"or type(package.manifest)~=\"table\"then return false,\"invalid verified package\"end local keys=M.trustedKeys()keys[package.manifest.next_key_id]=package.manifest.next_public saveKeys(keys)return true end function M.cachedPackage()local source,metadata=read(M.CACHE_FILE),M.metadata()if not source then return nil end local package,err=M.parse(source)if not package then return nil,err end if not metadata then metadata={schema=2,channel=package.manifest.channel,profile=package.manifest.profile,version=package.manifest.version,size=package.manifest.size,digest=package.manifest.digest,keyId=package.manifest.key_id,nextKeyId=package.manifest.next_key_id,source=\"local installer\",cachedAt=os.epoch(\"utc\"),}write(M.META_FILE,\"return \"..textutils.serialise(metadata,{compact=true}))end M.adopt(package)return package,metadata end function M.clear()if fs.exists(M.PART_FILE)then fs.delete(M.PART_FILE)end if fs.exists(M.CACHE_FILE)then fs.delete(M.CACHE_FILE)end if fs.exists(M.META_FILE)then fs.delete(M.META_FILE)end return true end function M.encode(value)return encode(value)end function M.decode(value)return decode(value)end function M.canonical(manifest)return canonical(manifest)end return M",
  ["ceetos/lib/updater.lua"] = "local store=require(\"ceetos.lib.store\")local release=require(\"ceetos.lib.release_verify\")local version=require(\"ceetos.lib.version\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local STATE_PATH=\"/ceetos/data/update-status.lua\"local OFFER_LIMIT,HISTORY_LIMIT=20,16 local BEACON_INTERVAL,REQUEST_TIMEOUT,REQUEST_LIMIT=30000,3500,3 local MAX_OFFER_AGE=5*60*1000 local CLOUD_RELEASE_ORIGIN=\"https://releases.ceet.uk\"local CLOUD_MANIFEST_URL=CLOUD_RELEASE_ORIGIN..\"/manifest.json\"local CLOUD_SOURCE_ID=\"cloud.releases.ceet.uk\"local state=nil local lastBeacon,lastCacheRead=0,0 local cached=nil local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function defaults()return{schema=1,offers={},history={},revision=0,status=\"idle\",message=nil,transfer=nil,cache=nil}end local function loadState()if state then return state end state=store.read(STATE_PATH,defaults())for key,value in pairs(defaults())do if state[key]==nil then state[key]=value end end state.offers=type(state.offers)==\"table\"and state.offers or{}state.history=type(state.history)==\"table\"and state.history or{}return state end local function save()local value=loadState()value.revision=(tonumber(value.revision)or 0)+1 store.write(STATE_PATH,value)end local function record(kind,fields)local value=loadState()local row={at=now(),kind=tostring(kind):sub(1,48)}for key,item in pairs(fields or{})do if key~=\"data\"and key~=\"source\"and key~=\"signature\"then row[key]=item end end value.history[#value.history+1]=row while#value.history>HISTORY_LIMIT do table.remove(value.history,1)end end local function setStatus(status,message)local value=loadState()value.status,value.message=status,message and tostring(message):sub(1,180)or nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=96 end local function releaseFilename(profileId,releaseVersion)if profileId==\"desktop\"then return\"desktop/ceetos-release\"..releaseVersion..\".lua\"end return profileId..\"/ceetos-\"..profileId..\"-release\"..releaseVersion..\".lua\"end local function readHttp(url,limit)if not http or type(http.get)~=\"function\"then return nil,\"HTTP is unavailable; enable it to check releases.ceet.uk\"end local ok,response,requestErr=pcall(http.get,url,{[\"Accept\"]=\"application/json\"})if not ok or not response then return nil,tostring(requestErr or\"release server request failed\")end local chunks,total={},0 while true do local part=response.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then pcall(response.close);return nil,\"release server response is too large\"end chunks[#chunks+1]=part end pcall(response.close)return table.concat(chunks)end local function validOffer(body)if type(body)~=\"table\"or type(body.version)~=\"string\"or type(body.size)~=\"number\"or type(body.digest)~=\"string\"or type(body.keyId)~=\"string\"or type(body.profile)~=\"string\"then return nil,\"malformed release offer\"end if body.profile~=profile.id()then return nil,\"release profile does not match this installation\"end local compare=release.compareVersions(body.version,version.string)if compare==nil then return nil,\"invalid release version\"end if body.size<1 or body.size>release.MAX_PACKAGE_BYTES then return nil,\"invalid release size\"end if#body.digest~=64 or body.digest:find(\"[^%x]\")then return nil,\"invalid release digest\"end if#body.keyId<1 or#body.keyId>64 then return nil,\"invalid release key ID\"end local filename=body.filename if filename~=nil and filename~=releaseFilename(body.profile,body.version)then return nil,\"invalid release filename\"end return{profile=body.profile,version=body.version,size=math.floor(body.size),digest=body.digest:lower(),keyId=body.keyId,filename=filename,fingerprint=body.digest:sub(1,16),newer=compare>0}end local function refreshCached()local timestamp=now()if cached and timestamp-lastCacheRead<5000 then return cached end lastCacheRead=timestamp local value=loadState()local previous=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil local package,metadata=release.cachedPackage()if package and package.manifest.profile==profile.id()then cached={package=package,metadata=metadata,offer={version=package.manifest.version,size=#package.source,digest=package.manifest.digest,profile=package.manifest.profile,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),}}value.cache={profile=package.manifest.profile,version=package.manifest.version,size=#package.source,digest=package.manifest.digest,keyId=package.manifest.key_id,fingerprint=package.manifest.digest:sub(1,16),source=metadata and metadata.source or\"local\",verifiedAt=timestamp}else cached=nil value.cache=nil end local current=value.cache and(tostring(value.cache.version)..\":\"..tostring(value.cache.digest))or nil if current~=previous then save()end return cached end local function providerOffer()local available=refreshCached()if not available then return nil end return{version=available.offer.version,size=available.offer.size,digest=available.offer.digest,profile=available.offer.profile,keyId=available.offer.keyId,label=localLabel(),id=localId(),}end local function upsertOffer(source,body,transport,distance)source=tostring(source)if source==localId()then return false,\"ignored own release offer\"end local offer,err=validOffer(body)if not offer then return false,err end if not offer.newer then return false,\"offered release is not newer\"end local value=loadState()local key=source..\":\"..offer.version..\":\"..offer.digest:sub(1,16)value.offers[key]={id=source,label=tostring(body.label or(\"Computer \"..source)):sub(1,96),version=offer.version,profile=offer.profile,size=offer.size,digest=offer.digest,fingerprint=offer.fingerprint,keyId=offer.keyId,filename=offer.filename,transport=transport,distance=tonumber(distance),seen=now(),key=key,}local rows={}for entryKey,item in pairs(value.offers)do rows[#rows+1]={key=entryKey,seen=tonumber(item.seen)or 0}end table.sort(rows,function(a,b)return a.seen>b.seen end)while#rows>OFFER_LIMIT do value.offers[table.remove(rows).key]=nil end setStatus(\"offers\",\"Signed release \"..offer.version..\" available from \"..tostring(body.label or source))record(\"offer\",{id=source,version=offer.version,transport=transport,distance=distance})save()return true end local function checkCloudManifest()local raw,readErr=readHttp(CLOUD_MANIFEST_URL,release.MAX_MANIFEST_BYTES)if not raw then return 0,readErr end local ok,catalogue=pcall(textutils.unserialiseJSON,raw)if not ok or type(catalogue)~=\"table\"or catalogue.schema~=1 or type(catalogue.releases)~=\"table\"or#catalogue.releases>OFFER_LIMIT then return 0,\"invalid signed-release catalogue\"end local count=0 for index=1,#catalogue.releases do local entry=catalogue.releases[index]if type(entry)==\"table\"and entry.profile==profile.id()then local accepted=upsertOffer(CLOUD_SOURCE_ID,entry,\"cloud\")if accepted then count=count+1 end end end return count end local function offers()local value,timestamp,rows=loadState(),now(),{}for key,item in pairs(value.offers)do if type(item)==\"table\"and timestamp-(tonumber(item.seen)or 0)<=MAX_OFFER_AGE then rows[#rows+1]=item else value.offers[key]=nil end end table.sort(rows,function(left,right)local compare=release.compareVersions(left.version,right.version)or 0 if compare~=0 then return compare>0 end return tostring(left.id)<tostring(right.id)end)return rows end local function findOffer(source)source=tostring(source)for _,item in ipairs(offers())do if item.key==source or tostring(item.id)==source then return item end end return nil,\"release source is unavailable; run update check first\"end local function removePart()if fs.exists(release.PART_FILE)then fs.delete(release.PART_FILE)end end local function appendPart(data)local handle,err=fs.open(release.PART_FILE,\"a\")if not handle then return false,err or\"could not open update staging file\"end handle.write(data);handle.close()return true end local function cachedSource()local available=refreshCached()return available and available.package and available.package.source end local function transferRequest(transfer)local length=math.min(release.CHUNK_BYTES,transfer.size-transfer.offset+1)if length<1 then return false,\"transfer is already complete\"end transfer.awaiting,transfer.requestedAt=true,now()local body={transfer=transfer.id,offset=transfer.offset,length=length}local sent,err if transfer.transport==\"routed\"then sent,err=net.request(transfer.source,\"update_chunk_request\",body,{safe=true})else sent,err=net.publicSend(transfer.source,\"update_chunk_request\",body)end if not sent then transfer.awaiting=false;return false,err end return true end local function beginDownload(source)local offer,err=findOffer(source)if not offer then return false,err end local compare=release.compareVersions(offer.version,version.string)if not compare or compare<=0 then return false,\"refusing a downgrade or current release\"end local free=fs.getFreeSpace and fs.getFreeSpace(\"/\")or nil if type(free)==\"number\"and free<offer.size+4096 then return false,\"not enough free space for one verified release cache\"end removePart()release.clear();cached=nil local value=loadState()if offer.transport==\"cloud\"then setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from releases.ceet.uk\")save()local sourceText,readErr=readHttp(CLOUD_RELEASE_ORIGIN..\"/\"..tostring(offer.filename or\"\"),release.MAX_PACKAGE_BYTES)if not sourceText then setStatus(\"error\",readErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=readErr});save();return false,readErr end local parsed,parseErr=release.parse(sourceText)if not parsed or parsed.manifest.profile~=offer.profile or parsed.manifest.version~=offer.version or parsed.manifest.digest:lower()~=offer.digest or parsed.manifest.key_id~=offer.keyId then local reason=parseErr or\"verified package did not match selected release offer\"setStatus(\"error\",reason);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=reason});save();return false,reason end local metadata,cacheErr=release.cache(sourceText,\"releases.ceet.uk\")if not metadata then setStatus(\"error\",cacheErr);record(\"download_failed\",{id=CLOUD_SOURCE_ID,error=cacheErr});save();return false,cacheErr end cached=nil;refreshCached()setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=CLOUD_SOURCE_ID,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end value.transfer={id=\"update-\"..localId()..\"-\"..tostring(now())..\"-\"..tostring(math.random(1000,9999)),source=tostring(offer.id),label=offer.label,transport=offer.transport==\"routed\"and\"routed\"or\"direct\",profile=offer.profile,version=offer.version,size=offer.size,digest=offer.digest,keyId=offer.keyId,offset=1,received=0,retries=0,awaiting=false,started=now(),}setStatus(\"downloading\",\"Downloading signed release \"..offer.version..\" from \"..offer.label)record(\"download_started\",{id=offer.id,version=offer.version,transport=value.transfer.transport})local sent,sendErr=transferRequest(value.transfer)if not sent then value.transfer=nil;setStatus(\"error\",sendErr);record(\"download_failed\",{id=offer.id,error=sendErr})end save()return sent,sendErr end local function finishTransfer(transfer)local handle=fs.open(release.PART_FILE,\"r\")local source=handle and handle.readAll()or nil if handle then handle.close()end if not source or#source~=transfer.size then return false,\"download size did not match offer\"end local parsed,parseErr=release.parse(source)if not parsed then return false,parseErr end if parsed.manifest.profile~=profile.id()or parsed.manifest.profile~=transfer.profile or parsed.manifest.version~=transfer.version or parsed.manifest.digest:lower()~=transfer.digest:lower()or parsed.manifest.key_id~=transfer.keyId then return false,\"verified package did not match selected release offer\"end local metadata,promoteErr=release.promotePart(release.PART_FILE,transfer.label)if not metadata then return false,promoteErr end cached=nil;refreshCached()local value=loadState();value.transfer=nil setStatus(\"downloaded\",\"Verified release \"..metadata.version..\" is ready for local confirmation\")record(\"download_verified\",{id=transfer.source,version=metadata.version,digest=metadata.digest:sub(1,16)})save()return true,metadata end local function acceptChunk(source,body,transport)local value,transfer=loadState(),loadState().transfer if not transfer or transfer.transport~=transport or tostring(source)~=tostring(transfer.source)then return false,\"unexpected update chunk\"end if type(body)~=\"table\"or body.transfer~=transfer.id or math.floor(tonumber(body.offset)or 0)~=transfer.offset or type(body.data)~=\"string\"then return false,\"malformed update chunk\"end local remaining=transfer.size-transfer.offset+1 if#body.data<1 or#body.data>math.min(release.CHUNK_BYTES,remaining)then return false,\"invalid update chunk length\"end local ok,err=appendPart(body.data)if not ok then transfer.awaiting=false;setStatus(\"error\",err);record(\"download_failed\",{error=err});save();return false,err end transfer.offset,transfer.received,transfer.awaiting,transfer.retries=transfer.offset+#body.data,(transfer.received or 0)+#body.data,false,0 if transfer.offset>transfer.size then local complete,result=finishTransfer(transfer)if not complete then removePart();value.transfer=nil;setStatus(\"error\",result);record(\"download_failed\",{id=source,error=result});save()end return complete,result end local sent,sendErr=transferRequest(transfer)if not sent then setStatus(\"error\",sendErr);record(\"download_failed\",{id=source,error=sendErr});value.transfer=nil;removePart()end save()return sent,sendErr end local function serveChunk(target,body,routed,request)if type(body)~=\"table\"or not validId(body.transfer)or math.floor(tonumber(body.offset)or 0)<1 or math.floor(tonumber(body.length)or 0)<1 or tonumber(body.length)>release.CHUNK_BYTES then return false,\"invalid update chunk request\"end local source=cachedSource()if not source then return false,\"no verified newer signed release is cached\"end local offset,length=math.floor(body.offset),math.floor(body.length)if offset>#source then return false,\"requested update offset is beyond package\"end local data=source:sub(offset,math.min(#source,offset+length-1))local response={transfer=body.transfer,offset=offset,data=data}if routed then return net.reply(request,\"update_chunk\",response,{safe=true})end return net.publicSend(target,\"update_chunk\",response)end function M.publicPacket(packet,distance)local source,body=tostring(packet.from),packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then net.publicSend(source,\"update_offer\",offer)end return elseif packet.type==\"update_offer\"then return upsertOffer(source,body,\"direct\",distance)elseif packet.type==\"update_chunk_request\"then return serveChunk(source,body,false)elseif packet.type==\"update_chunk\"then return acceptChunk(source,body,\"direct\")end end function M.authenticatedPacket(from,peer,packet)local body=packet.body or{}if packet.type==\"update_query\"then if body.profile~=profile.id()then return false,\"release profile does not match this installation\"end local offer=providerOffer()local compare=offer and release.compareVersions(offer.version,body.version or\"\")if offer and compare and compare>0 then return net.reply(packet,\"update_offer\",offer,{safe=true})end elseif packet.type==\"update_offer\"then return upsertOffer(from,body,\"routed\")elseif packet.type==\"update_chunk_request\"then return serveChunk(from,body,true,packet)elseif packet.type==\"update_chunk\"then return acceptChunk(from,body,\"routed\")end end function M.check()local value=loadState()for key in pairs(value.offers)do value.offers[key]=nil end setStatus(\"checking\",\"Looking for newer signed releases\")local cloudOffers,cloudErr=checkCloudManifest()local sent,err=net.publicBroadcast(\"update_query\",{version=version.string,profile=profile.id()})local routed=0 for _,peer in ipairs(net.peers())do if not peer.rekeyRequired then local ok=net.request(peer.id,\"update_query\",{version=version.string,profile=profile.id()},{safe=true})if ok then routed=routed+1 end end end if cloudErr then setStatus(\"warning\",\"Cloud release check failed: \"..tostring(cloudErr):sub(1,120))elseif cloudOffers==0 and not(sent or routed>0)then setStatus(\"idle\",\"No newer signed release is available\")elseif cloudOffers>0 then setStatus(\"offers\",tostring(cloudOffers)..\" signed cloud release offer\"..(cloudOffers==1 and\"\"or\"s\")..\" available\")end record(\"check\",{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr,error=sent and nil or err})save()if cloudErr and not sent and routed==0 then return false,cloudErr end return true,{cloud=cloudOffers,direct=sent==true,routed=routed,cloudError=cloudErr}end function M.download(source)return beginDownload(source)end function M.installLatest()local checked,err=M.check()if not checked then return false,err end local rows=offers()if#rows==0 then return false,\"no newer compatible signed release is available\"end table.sort(rows,function(a,b)local comparison=release.compareVersions(a.version,b.version)or 0 return comparison==0 and tostring(a.id)<tostring(b.id)or comparison>0 end)return beginDownload(rows[1].id)end function M.cancel()local value=loadState()if not value.transfer then return false,\"no update transfer is active\"end record(\"download_cancelled\",{id=value.transfer.source,version=value.transfer.version})value.transfer=nil;removePart();setStatus(\"cancelled\",\"Update download cancelled\");save()return true end function M.clearCache()local value=loadState()if value.transfer then return false,\"cancel the active download first\"end release.clear();cached=nil;value.cache=nil;setStatus(\"idle\",\"Verified release cache cleared\");record(\"cache_cleared\");save()return true end function M.prepareApply()local package,metadata=release.cachedPackage()if not package then return false,metadata or\"no verified signed release is cached\"end local compare=release.compareVersions(package.manifest.version,version.string)if not compare or compare<=0 then return false,\"cached release is not newer than this CeetOS installation\"end if package.manifest.profile~=profile.id()then return false,\"cached release profile does not match this installation\"end local marker={schema=2,state=\"apply\",profile=package.manifest.profile,version=package.manifest.version,digest=package.manifest.digest,keyId=package.manifest.key_id,approvedAt=now()}store.write(release.PENDING_FILE,marker)local value=loadState();setStatus(\"applying\",\"Applying verified release \"..package.manifest.version..\" after reboot\");record(\"apply_approved\",{version=package.manifest.version,digest=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id});save()return true,{version=package.manifest.version,fingerprint=package.manifest.digest:sub(1,16),keyId=package.manifest.key_id}end function M.recover()local marker=store.read(release.PENDING_FILE,nil)if type(marker)~=\"table\"or marker.state~=\"verify\"then return end local value=loadState()if marker.version==version.string and(marker.profile==nil or marker.profile==profile.id())then if fs.exists(release.PENDING_FILE)then fs.delete(release.PENDING_FILE)end setStatus(\"applied\",\"Verified release \"..version.string..\" is now active\")record(\"apply_verified\",{version=version.string})else setStatus(\"error\",\"Update installed but running version did not match \"..tostring(marker.version))record(\"apply_version_mismatch\",{expected=marker.version,actual=version.string})end save()end function M.tick()local value,timestamp=loadState(),now()local offer=providerOffer()if offer and timestamp-lastBeacon>=BEACON_INTERVAL then net.publicBroadcast(\"update_offer\",offer)lastBeacon=timestamp end local transfer=value.transfer if transfer and transfer.awaiting and timestamp-(transfer.requestedAt or timestamp)>=REQUEST_TIMEOUT then transfer.awaiting,transfer.retries=false,(transfer.retries or 0)+1 if transfer.retries>REQUEST_LIMIT then record(\"download_timeout\",{id=transfer.source,version=transfer.version})value.transfer=nil;removePart();setStatus(\"error\",\"Update source timed out\");save()else local sent,err=transferRequest(transfer)if not sent then value.transfer=nil;removePart();setStatus(\"error\",err);record(\"download_failed\",{id=transfer.source,error=err});save()end end end end function M.status()local value=loadState()return{profile=profile.id(),version=version.string,status=value.status,message=value.message,revision=value.revision,offers=offers(),transfer=value.transfer,cache=value.cache,history=value.history,cacheRoot=release.CACHE_ROOT,maxPackageBytes=release.MAX_PACKAGE_BYTES,}end return M",
  ["ceetos/lib/release_broker.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local crypto=require(\"ceetos.lib.mesh_crypto\")local cloud=require(\"ceetos.lib.cloud\")local net=require(\"ceetos.lib.net\")local profile=require(\"ceetos.lib.profile\")local M={}local PATH,LIMIT,LIFE=\"/ceetos/data/release-broker.lua\",8,120000 local pending={}local function now()return os.epoch(\"utc\")end local function localId()return tostring(os.getComputerID())end local function localLabel()return os.getComputerLabel()or(\"Computer \"..localId())end local function clean(v,n)return type(v)==\"string\"and#v>0 and#v<=n and not v:find(\"[%z\\1-\\31\\127]\")end local function state()local value=store.read(PATH,{})return{schema=1,enabled=value.enabled==true,promotedAt=tonumber(value.promotedAt)}end local function save(value)return store.write(PATH,value)end local function key(session,target,targetNonce,phrase)return password.hmacSha256(phrase,table.concat({\"ceetos/release-broker/v1\",session,target,localId(),targetNonce},\"|\"))end local function mac(secret,label,value)return password.hmacSha256(secret,label..\"|\"..value)end local function expiry()return now()+LIFE end local function pendingCount()local count=0 for _,row in pairs(pending)do if row.expires>now()then count=count+1 end end return count end function M.status()local value,cloudState=state(),cloud.publicStatus()local rows={}for id,row in pairs(pending)do if row.expires>now()then rows[#rows+1]={id=id,target=row.target,label=row.label,profile=row.profile,expires=row.expires,state=row.state}end end table.sort(rows,function(a,b)return a.expires<b.expires end)return{enabled=value.enabled,enrolled=cloudState.enrolled,pending=rows}end function M.promote(ownerKey)if not clean(ownerKey,256)then return false,\"owner enrollment key is required\"end local result,err=cloud.call(\"auth\",\"/v1/broker/promote\",{ownerKey=ownerKey})if not result then return false,err end save({schema=1,enabled=true,promotedAt=now()})return true,result end function M.revoke(ownerKey)if not clean(ownerKey,256)then return false,\"owner enrollment key is required\"end local result,err=cloud.call(\"auth\",\"/v1/broker/revoke\",{ownerKey=ownerKey})if not result then return false,err end save({schema=1,enabled=false})for id in pairs(pending)do pending[id]=nil end return true,result end function M.handle(packet)local body,source=packet.body or{},tostring(packet.from or\"\")if packet.type==\"broker_query\"then if not state().enabled or not cloud.publicStatus().enrolled then return end if not clean(body.session,96)or not clean(body.nonce,128)or not clean(body.profile,32)or not clean(body.label,96)or body.profile~=profile.id()then return end if pendingCount()>=LIMIT and not pending[body.session]then return end pending[body.session]={session=body.session,target=source,targetNonce=body.nonce,profile=body.profile,label=body.label,expires=expiry(),state=\"waiting\"}return net.publicSend(source,\"broker_offer\",{session=body.session,broker=localId(),label=localLabel(),profile=profile.id(),expires=pending[body.session].expires})elseif packet.type==\"broker_proof\"then local row=pending[body.session]if not row or row.expires<=now()or row.target~=source or row.state~=\"challenged\"or not clean(body.proof,128)then return end if not password.constantTimeEqual(row.expected,body.proof)then pending[body.session]=nil;return net.publicSend(source,\"broker_reject\",{session=body.session,reason=\"phrase proof rejected\"})end local result,err=cloud.call(\"auth\",\"/v1/broker/enroll\",{session=row.session,targetComputerId=row.target,targetLabel=row.label,targetProfile=row.profile,expires=row.expires})if not result or type(result.node)~=\"table\"then pending[body.session]=nil;return net.publicSend(source,\"broker_reject\",{session=body.session,reason=tostring(err or\"cloud provisioning failed\"):sub(1,96)})end local aad=\"ceetos/release-broker/grant/v1|\"..row.session..\"|\"..row.target..\"|\"..localId()local nonce=crypto.nonce(row.key,1,aad)local envelope=nonce and crypto.seal(row.key,nonce,aad,textutils.serialise({node=result.node,urls=cloud.publicStatus().urls}))pending[body.session]=nil if not envelope then return net.publicSend(source,\"broker_reject\",{session=body.session,reason=\"could not secure enrollment\"})end return net.publicSend(source,\"broker_grant\",{session=body.session,broker=localId(),envelope=envelope})end end function M.approve(session,phrase)local row=pending[tostring(session or\"\")]if not row or row.expires<=now()then return false,\"bootstrap session is unavailable or expired\"end if not clean(phrase,128)then return false,\"invalid bootstrap phrase\"end row.key=key(row.session,row.target,row.targetNonce,phrase)row.brokerNonce=password.newSalt(\"broker:\"..row.session)row.expected=mac(row.key,\"proof\",row.brokerNonce)row.state,row.expires=\"challenged\",expiry()local challenge=mac(row.key,\"challenge\",row.brokerNonce)local sent,err=net.publicSend(row.target,\"broker_challenge\",{session=row.session,broker=localId(),nonce=row.brokerNonce,mac=challenge,expires=row.expires})if not sent then row.state=\"waiting\";return false,err end return true end function M.tick()for id,row in pairs(pending)do if row.expires<=now()then pending[id]=nil end end end return M",
  ["ceetos/lib/broker_bootstrap.lua"] = "local password=require(\"ceetos.lib.password\")local crypto=require(\"ceetos.lib.mesh_crypto\")local M={}local CHANNEL,LIFE=45731,120 local function label()return os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID()))end local function valid(v,n)return type(v)==\"string\"and#v>0 and#v<=n end local function modem()for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped and wrapped.isWireless and wrapped.isWireless()then return wrapped end end end end local function random(context)return password.newSalt(context..\":\"..tostring(os.epoch(\"utc\")))end function M.enroll(profile)local link=modem()if not link then return nil,\"No wireless modem is attached; a trusted release broker must be directly reachable.\"end link.open(CHANNEL)local session,target,targetNonce=random(\"session\"),tostring(os.getComputerID()),random(\"target\")local phrase=random(\"phrase\"):sub(1,20)print(\"Trusted broker enrollment required.\")print(\"On an enrolled broker run: nx broker approve \"..session..\" \"..phrase)link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_query\",from=target,to=\"0\",body={session=session,nonce=targetNonce,profile=profile,label=label()}})local deadline,broker,linkKey=os.epoch(\"utc\")+LIFE*1000,nil,nil while os.epoch(\"utc\")<deadline do local timer=os.startTimer(2)local event={os.pullEventRaw()}if event[1]==\"timer\"and event[2]==timer then link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_query\",from=target,to=\"0\",body={session=session,nonce=targetNonce,profile=profile,label=label()}})elseif event[1]==\"modem_message\"and event[3]==CHANNEL and type(event[5])==\"table\"then local packet,body=event[5],event[5].body or{}if packet.protocol==\"ceetos/update/1\"and tostring(packet.to)==target and body.session==session then if packet.type==\"broker_offer\"then broker=tostring(body.broker)elseif packet.type==\"broker_challenge\"and broker and tostring(body.broker)==broker and valid(body.nonce,128)and valid(body.mac,128)then linkKey=password.hmacSha256(phrase,table.concat({\"ceetos/release-broker/v1\",session,target,broker,targetNonce},\"|\"))if password.constantTimeEqual(password.hmacSha256(linkKey,\"challenge|\"..body.nonce),body.mac)then link.transmit(CHANNEL,CHANNEL,{protocol=\"ceetos/update/1\",type=\"broker_proof\",from=target,to=broker,body={session=session,proof=password.hmacSha256(linkKey,\"proof|\"..body.nonce)}})end elseif packet.type==\"broker_grant\"and linkKey and tostring(body.broker)==broker then local aad=\"ceetos/release-broker/grant/v1|\"..session..\"|\"..target..\"|\"..broker local opened=crypto.open(linkKey,body.envelope,aad)local grant=opened and textutils.unserialise(opened)if type(grant)==\"table\"and type(grant.node)==\"table\"and valid(grant.node.id,96)and valid(grant.node.secret,192)then return grant end elseif packet.type==\"broker_reject\"then return nil,tostring(body.reason or\"broker rejected enrollment\")end end end end return nil,broker and\"Broker did not complete enrollment in time.\"or\"No trusted release broker answered. Installation was not changed.\"end return M",
  ["ceetos/lib/mesh_crypto.lua"] = "local password=require(\"ceetos.lib.password\")local M={}local band,bor,bxor=bit32.band,bit32.bor,bit32.bxor local lshift,rshift=bit32.lshift,bit32.rshift local MOD32,LIMB=4294967296,67108864 local function add32(...)local n=0 for i=1,select(\"#\",...)do n=(n+(select(i,...)or 0))%MOD32 end return n end local function rotl(v,bits)return bor(lshift(v,bits),rshift(v,32-bits))end local function le32(data,index)local a,b,c,d=data:byte(index,index+3)return(a or 0)+(b or 0)*256+(c or 0)*65536+(d or 0)*16777216 end local function put32(value)value=value%MOD32 return string.char(value%256,math.floor(value/256)%256,math.floor(value/65536)%256,math.floor(value/16777216)%256)end local function le64(value)value=math.max(0,math.floor(tonumber(value)or 0))local low,high=value%MOD32,math.floor(value/MOD32)%MOD32 return put32(low)..put32(high)end local function hexToRaw(value)if type(value)~=\"string\"or#value%2~=0 or value:find(\"[^%x]\")then return nil end return(value:gsub(\"..\",function(pair)return string.char(tonumber(pair,16))end))end local function rawToHex(value)return(value:gsub(\".\",function(byte)return string.format(\"%02x\",byte:byte())end))end local function xorBytes(left,right)local out={}for i=1,#left do out[i]=string.char(bxor(left:byte(i),right:byte(i)))end return table.concat(out)end local function quarter(x,a,b,c,d)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),16)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),12)x[a]=add32(x[a],x[b]);x[d]=rotl(bxor(x[d],x[a]),8)x[c]=add32(x[c],x[d]);x[b]=rotl(bxor(x[b],x[c]),7)end local function chachaBlock(key,counter,nonce)local state={0x61707865,0x3320646e,0x79622d32,0x6b206574}for i=1,8 do state[4+i]=le32(key,(i-1)*4+1)end state[13],state[14],state[15],state[16]=counter%MOD32,le32(nonce,1),le32(nonce,5),le32(nonce,9)local x={}for i=1,16 do x[i]=state[i]end for _=1,10 do quarter(x,1,5,9,13);quarter(x,2,6,10,14);quarter(x,3,7,11,15);quarter(x,4,8,12,16)quarter(x,1,6,11,16);quarter(x,2,7,12,13);quarter(x,3,8,9,14);quarter(x,4,5,10,15)end local out={}for i=1,16 do out[i]=put32(add32(x[i],state[i]))end return table.concat(out)end local function chachaXor(key,nonce,counter,plaintext)local out,position={},1 while position<=#plaintext do local block=chachaBlock(key,counter,nonce)local part=plaintext:sub(position,position+63)out[#out+1]=xorBytes(part,block:sub(1,#part))position,counter=position+#part,(counter+1)%MOD32 end return table.concat(out)end local function poly1305(message,key)local function zero(length)local out={};for i=1,length do out[i]=0 end;return out end local function normalise(value)local carry=0 for i=1,#value do local n=(value[i]or 0)+carry value[i],carry=n%256,math.floor(n/256)end while carry>0 do value[#value+1],carry=carry%256,math.floor(carry/256)end return value end local function add(left,right)local out=zero(math.max(#left,#right)+1)for i=1,#left do out[i]=out[i]+left[i]end for i=1,#right do out[i]=out[i]+right[i]end return normalise(out)end local function multiply(left,right)local out=zero(#left+#right+1)for i=1,#left do for j=1,#right do out[i+j-1]=out[i+j-1]+left[i]*right[j]end end return normalise(out)end local function high130(value)local out={}for i=1,#value-16 do local low=value[i+16]or 0 local high=value[i+17]or 0 out[i]=math.floor(low/4)+(high%4)*64 end return normalise(out)end local function hasHigh(value)if#value>17 then for i=18,#value do if value[i]~=0 then return true end end end return(value[17]or 0)>=4 end local function reduce(value)while hasHigh(value)do local low,high=zero(17),high130(value)for i=1,17 do low[i]=value[i]or 0 end low[17]=low[17]%4 for i=1,#high do high[i]=high[i]*5 end value=add(low,high)end local prime={251}for i=2,16 do prime[i]=255 end prime[17]=3 local greater=false for i=17,1,-1 do if(value[i]or 0)~=prime[i]then greater=(value[i]or 0)>prime[i];break end end if greater then local borrow=0 for i=1,17 do local n=(value[i]or 0)-prime[i]-borrow if n<0 then n,borrow=n+256,1 else borrow=0 end value[i]=n end end return value end local r,h=zero(17),zero(17)for i=1,16 do r[i]=key:byte(i)end r[4],r[8],r[12],r[16]=band(r[4],15),band(r[8],15),band(r[12],15),band(r[16],15)r[5],r[9],r[13]=band(r[5],252),band(r[9],252),band(r[13],252)for at=1,#message,16 do local part,n=message:sub(at,at+15),zero(17)for i=1,#part do n[i]=part:byte(i)end n[#part+1]=1 h=reduce(multiply(add(h,n),r))end local pad,out,carry={},{},0 for i=1,16 do pad[i]=key:byte(i+16)end for i=1,16 do local n=(h[i]or 0)+pad[i]+carry out[i],carry=n%256,math.floor(n/256)end return string.char(table.unpack(out))end local function padded(value)return value..string.rep(\"\\0\",(16-(#value%16))%16)end local function derive(linkKey)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-key/v1\")or\"\")return raw end function M.nonce(linkKey,counter,context)local raw=hexToRaw(password.hmacSha256(linkKey,\"ceetos/mesh/aead-nonce/v1|\"..tostring(counter)..\"|\"..tostring(context or\"\"))or\"\")return raw and raw:sub(1,12)or nil end function M.seal(linkKey,nonce,aad,plaintext)if type(linkKey)~=\"string\"or type(nonce)~=\"string\"or#nonce~=12 or type(aad)~=\"string\"or type(plaintext)~=\"string\"then return nil,\"invalid mesh envelope input\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local ciphertext=chachaXor(key,nonce,1,plaintext)local tag=poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey)return{nonce=rawToHex(nonce),ciphertext=rawToHex(ciphertext),tag=rawToHex(tag)}end function M.open(linkKey,envelope,aad)if type(linkKey)~=\"string\"or type(envelope)~=\"table\"or type(aad)~=\"string\"then return nil,\"invalid mesh envelope\"end local nonce,ciphertext,tag=hexToRaw(envelope.nonce or\"\"),hexToRaw(envelope.ciphertext or\"\"),hexToRaw(envelope.tag or\"\")if not nonce or#nonce~=12 or not ciphertext or not tag or#tag~=16 then return nil,\"invalid mesh envelope encoding\"end local key=derive(linkKey);if not key or#key~=32 then return nil,\"could not derive mesh envelope key\"end local polyKey=chachaBlock(key,0,nonce):sub(1,32)local expected=rawToHex(poly1305(padded(aad)..padded(ciphertext)..le64(#aad)..le64(#ciphertext),polyKey))if not password.constantTimeEqual(expected,envelope.tag)then return nil,\"mesh envelope authentication failed\"end return chachaXor(key,nonce,1,ciphertext)end function M.selfTest()local key=hexToRaw(\"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b\")local tag=poly1305(\"Cryptographic Forum Research Group\",key)return rawToHex(tag)==\"a8061dc1305136c6c22b8baf0c0127a9\"end return M",
  ["ceetos/lib/audit.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/audit.log\"M.LIMITS={maxEntries=250,maxBytes=64*1024}function M.log(actor,action,detail)return store.append(PATH,{ts=os.epoch(\"utc\"),actor=actor or\"system\",action=action,detail=detail,},M.LIMITS)end function M.recent(limit)limit=math.max(1,math.min(50,tonumber(limit)or 10))local raw=store.readAppend(PATH)local result={}for line in(raw..\"\\n\"):gmatch(\"(.-)\\n\")do if line~=\"\"then local entry=textutils.unserialise(line)if entry then result[#result+1]=entry if#result>limit then table.remove(result,1)end end end end return result end return M",
  ["ceetos/lib/net.lua"] = "local store=require(\"ceetos.lib.store\")local audit=require(\"ceetos.lib.audit\")local password=require(\"ceetos.lib.password\")local meshCrypto=require(\"ceetos.lib.mesh_crypto\")local M={handler=nil,publicHandler=nil}local PATH=\"/ceetos/data/network.lua\"local SECURITY_PATH=\"/ceetos/data/network-security.lua\"local SEEN_PATH=\"/ceetos/data/seen-peers.lua\"local CHANNEL,PROTOCOL=45731,\"ceetos/2\"local PUBLIC_UPDATE_PROTOCOL=\"ceetos/update/1\"local PUBLIC_UPDATE_TYPES={update_query=true,update_offer=true,update_chunk_request=true,update_chunk=true,broker_query=true,broker_offer=true,broker_challenge=true,broker_proof=true,broker_grant=true,broker_reject=true,}local DISCOVERY_CHANNEL=CHANNEL local DISCOVERY_TTL,ROUTE_TTL,PACKET_TTL=120000,120000,8 local DISCOVERY_INTERVAL,PAIR_RETRY,ROUTE_INTERVAL=2000,2000,15000 local MESH_BEACON_INTERVAL,MESH_FULL_INTERVAL=15000,30000 local PROBE_INTERVAL,PROBE_DEGRADED,PROBE_OFFLINE,PROBE_RECOVERY=5000,3,6,10000 local ROUTE_CANDIDATE_LIMIT,ROUTE_BUCKET_LIMIT=4,96 local SAFE_READ_WINDOW,SAFE_READ_LIMIT=1000,16 local MAX_PACKET_STRING,MAX_PACKET_TABLE,MAX_PACKET_DEPTH=8192,128,6 local COUNTER_RESERVATION,MAX_RX_EPOCHS,MAX_REVERSE_ROUTES=64,3,128 local routes,discovered,confirmations,seenPackets,reverseRoutes={},{},{},{},{}local routeSequence,lastRouteAdvertisement,routesDirty=0,0,false local discovery,lastDiscovery=nil,{state=\"inactive\"}local security={tx={},rx={}}local autoEdges,linkHealth,meshOffers,meshSeen,advertisedRoutes,meshEnrollmentSends={},{},{},{},{},{}local lastMeshBeacon,lastMeshFull,meshDirty=0,0,false local transport={modem=false,wireless=false,name=nil,channels={},lastTransmit=nil,lastReceive=nil,lastDistance=nil,lastError=nil,rejected=0,}local traces={discovery={},routing={},transport={}}local TRACE_LIMIT=48 local MESH_STATE_LIMIT=128 local rejectPacket local function now()return os.epoch(\"utc\")end local function id()return tostring(os.getComputerID())end local function label()return os.getComputerLabel()or(\"Computer \"..id())end local function isBroadcast(value)return tostring(value)==\"0\"end local function isForUs(value)return tostring(value)==id()end local function copy(value,depth)if type(value)~=\"table\"then return value end if(depth or 0)>MAX_PACKET_DEPTH then return nil end local out={}for k,v in pairs(value)do out[k]=copy(v,(depth or 0)+1)end return out end local function trace(kind,phase,fields)local bucket=traces[kind]or traces.transport local row={time=now(),phase=phase}for key,value in pairs(fields or{})do if key~=\"phrase\"and key~=\"proof\"and key~=\"key\"and key~=\"secret\"and key~=\"mac\"and key~=\"packet\"and key~=\"tag\"then row[key]=value end end bucket[#bucket+1]=row while#bucket>TRACE_LIMIT do table.remove(bucket,1)end end local function read(path,fallback)if store.invalidate then store.invalidate(path)end return store.read(path,fallback)end local function config()local value=read(PATH,{peers={},channel=CHANNEL})value.peers=type(value.peers)==\"table\"and value.peers or{}value.channel=tonumber(value.channel)or CHANNEL return value end local function save(value)local ok,err=store.write(PATH,value)if ok==false then error(err or\"could not save network configuration\",0)end end local function migrateV1Links()local value,changed=config(),false for _,peer in pairs(value.peers)do if peer.protocol~=2 or peer.rekeyRequired or type(peer.key)~=\"string\"or#peer.key<32 then peer.protocol,peer.rekeyRequired,peer.key=1,true,nil peer.secret=nil changed=true end end if changed then save(value)end return value end local function activePeer(value,peerId)local peer=value.peers[tostring(peerId)]if peer and peer.protocol==2 and peer.rekeyRequired~=true and type(peer.key)==\"string\"and#peer.key>=32 then return peer end return nil end local function activeLink(value,peerId)local manual=activePeer(value,peerId)if manual then return manual,\"direct\"end local edge=autoEdges[tostring(peerId)]if edge and type(edge.key)==\"string\"and#edge.key>=32 and(edge.expires or 0)>now()then return edge,\"mesh\"end return nil end local function healthFor(peerId)peerId=tostring(peerId)local state=linkHealth[peerId]if not state then state={state=\"healthy\",successes=0,misses=0,lastAuthenticated=now(),stableSince=now(),inFlight=0}linkHealth[peerId]=state end return state end local function linkState(peerId)return healthFor(peerId).state or\"healthy\"end local function currentInFlight(state,timestamp)state.inFlightUntil=type(state.inFlightUntil)==\"table\"and state.inFlightUntil or{}local kept={}for _,expires in ipairs(state.inFlightUntil)do if expires>timestamp then kept[#kept+1]=expires end end state.inFlightUntil,state.inFlight=kept,#kept return state.inFlight end local function markInFlight(state)local timestamp=now()currentInFlight(state,timestamp)state.inFlightUntil[#state.inFlightUntil+1]=timestamp+SAFE_READ_WINDOW table.sort(state.inFlightUntil)while#state.inFlightUntil>SAFE_READ_LIMIT do table.remove(state.inFlightUntil,1)end state.inFlight=#state.inFlightUntil end local function linkUsable(value,peerId,allowDegraded)if not activeLink(value,peerId)then return false end local state=linkState(peerId)return state==\"healthy\"or(allowDegraded and state==\"degraded\")end local function touchLink(peerId,distance,source)local state,timestamp=healthFor(peerId),now()state.lastAuthenticated,state.lastDistance,state.lastSource=timestamp,distance,source or\"traffic\"state.misses,state.awaiting,state.probeToken=0,false,nil state.loss=math.max(0,(state.loss or 0)*0.5)if state.state~=\"healthy\"then state.successes=(state.successes or 0)+1 if state.successes>=2 then state.state,state.stableSince,state.recoveredAt=\"healthy\",timestamp,timestamp routesDirty=true trace(\"routing\",\"link_recovered\",{peer=peerId,source=source})end else state.successes=math.min(2,(state.successes or 0)+1)end end local function allDirectLinks(value)local out,seen={},{}for peerId in pairs(value.peers)do if activePeer(value,peerId)then out[#out+1],seen[peerId]=tostring(peerId),true end end for peerId,edge in pairs(autoEdges)do if not seen[peerId]and edge.expires>now()then out[#out+1]=tostring(peerId)end end table.sort(out,function(a,b)return tonumber(a)<tonumber(b)end)return out end local function remember(peer,peerLabel,extra)local value=read(SEEN_PATH,{})local old=value[tostring(peer)]or{}old.label,old.seen=peerLabel or old.label or(\"Computer \"..tostring(peer)),now()if extra then for key,item in pairs(extra)do if key~=\"tag\"and key~=\"proof\"then old[key]=item end end end value[tostring(peer)]=old store.write(SEEN_PATH,value)end local function modem(requireWireless)local candidates,used={},{}local sides=rs and rs.getSides and rs.getSides()or{}for _,name in ipairs(sides)do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end if peripheral.getNames then for _,name in ipairs(peripheral.getNames())do if peripheral.getType(name)==\"modem\"and not used[name]then candidates[#candidates+1],used[name]=name,true end end end local fallback for _,name in ipairs(candidates)do local wrapped=peripheral.wrap(name)if wrapped then fallback=fallback or wrapped local ok,wireless=pcall(function()return not wrapped.isWireless or wrapped.isWireless()end)if ok and wireless then return wrapped end end end return requireWireless and nil or fallback end local function modems()local out,seen={},{}local function add(name)if not seen[name]and peripheral.getType(name)==\"modem\"then local wrapped=peripheral.wrap(name)if wrapped then out[#out+1],seen[name]={name=name,modem=wrapped},true end end end for _,name in ipairs(rs and rs.getSides and rs.getSides()or{})do add(name)end for _,name in ipairs(peripheral.getNames and peripheral.getNames()or{})do add(name)end return out end local function wirelessModems()local out={}for _,item in ipairs(modems())do local ok,wireless=pcall(function()return not item.modem.isWireless or item.modem.isWireless()end)if ok and wireless then out[#out+1]=item end end return out end local function openChannels(value)local channels={value.channel or CHANNEL}if channels[1]~=DISCOVERY_CHANNEL then channels[#channels+1]=DISCOVERY_CHANNEL end transport.channels=channels local all=modems()if#all==0 then transport.lastError=\"no modem attached\";trace(\"transport\",\"modem_missing\");return channels end for _,item in ipairs(all)do for _,channel in ipairs(channels)do local ok,err=pcall(item.modem.open,channel)if not ok then transport.lastError=tostring(err)trace(\"transport\",\"channel_open_failed\",{channel=channel,error=transport.lastError,modem=item.name})end end end return channels end local function canonical(value,depth)depth=depth or 0 local kind=type(value)if kind==\"nil\"then return\"n\"end if kind==\"boolean\"then return value and\"b1\"or\"b0\"end if kind==\"number\"then if value~=value or value==math.huge or value==-math.huge then return nil,\"invalid numeric packet value\"end return\"d\"..string.format(\"%.17g\",value)..\";\"end if kind==\"string\"then if#value>MAX_PACKET_STRING then return nil,\"packet string exceeds limit\"end return\"s\"..tostring(#value)..\":\"..value end if kind~=\"table\"then return nil,\"unsupported packet value\"end if depth>=MAX_PACKET_DEPTH then return nil,\"packet nesting exceeds limit\"end local entries={}for key,item in pairs(value)do if#entries>=MAX_PACKET_TABLE then return nil,\"packet table exceeds limit\"end local encodedKey,keyErr=canonical(key,depth+1);if not encodedKey then return nil,keyErr end local encodedValue,valueErr=canonical(item,depth+1);if not encodedValue then return nil,valueErr end entries[#entries+1]=encodedKey..\"=\"..encodedValue end table.sort(entries)return\"t\"..tostring(#entries)..\"{\"..table.concat(entries,\",\")..\"}\"end local function packetMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,origin=packet.origin,destination=packet.destination,ttl=packet.ttl,request_id=packet.request_id,timestamp=packet.timestamp,reply_to=packet.reply_to,auth=packet.auth and{epoch=packet.auth.epoch,counter=packet.auth.counter}or nil,confidential=packet.confidential==true,body=packet.body,})end local function confidentialAad(packet)return table.concat({\"ceetos/confidential/v1\",tostring(packet.type),tostring(packet.origin),tostring(packet.destination),tostring(packet.request_id)},\"|\")end local function sealBody(peer,packet)local encoded=textutils.serialise(packet.body or{},{compact=true})if#encoded>6144 then return nil,\"confidential payload exceeds limit\"end local nonce=meshCrypto.nonce(peer.key,password.newSalt(\"confidential:\"..tostring(packet.request_id)),confidentialAad(packet))if not nonce then return nil,\"could not create confidential nonce\"end local envelope,err=meshCrypto.seal(peer.key,nonce,confidentialAad(packet),encoded)if not envelope then return nil,err end return{envelope=envelope}end local function openBody(peer,packet)if type(packet.body)~=\"table\"or type(packet.body.envelope)~=\"table\"then return nil,\"malformed confidential envelope\"end local decoded,err=meshCrypto.open(peer.key,packet.body.envelope,confidentialAad(packet))if not decoded or#decoded>6144 then return nil,err or\"invalid confidential payload\"end local ok,value=pcall(textutils.unserialise,decoded)if not ok or type(value)~=\"table\"then return nil,\"invalid confidential payload\"end return value end local function loadSecurity()security=read(SECURITY_PATH,{tx={},rx={}})security.tx=type(security.tx)==\"table\"and security.tx or{}security.rx=type(security.rx)==\"table\"and security.rx or{}end local function saveSecurity()local ok,err=store.write(SECURITY_PATH,security)if ok==false then error(err or\"could not persist peer replay state\",0)end end local function counter(peerId)local key=tostring(peerId)local tx=security.tx[key]if not tx then tx={epoch=password.newSalt(\"peer-tx:\"..key),reserved=0};security.tx[key]=tx end tx.next=tonumber(tx.next)or((tonumber(tx.reserved)or 0)+1)if tx.next>(tonumber(tx.reserved)or 0)then tx.reserved=tx.next+COUNTER_RESERVATION-1 saveSecurity()end local value=tx.next;tx.next=value+1 return tx.epoch,value end local function verifyReplay(from,auth)if type(auth)~=\"table\"or type(auth.epoch)~=\"string\"or#auth.epoch<16 or#auth.epoch>128 then return false,\"invalid packet epoch\"end local sequence=tonumber(auth.counter)if not sequence or sequence<1 or sequence%1~=0 then return false,\"invalid packet counter\"end local key=tostring(from)local row=security.rx[key]or{epochs={}}row.epochs=type(row.epochs)==\"table\"and row.epochs or{}local old=tonumber(row.epochs[auth.epoch])if old and sequence<=old then return false,\"replayed packet counter\"end row.epochs[auth.epoch]=sequence local order={}for epoch,max in pairs(row.epochs)do order[#order+1]={epoch=epoch,max=tonumber(max)or 0}end table.sort(order,function(a,b)return a.max>b.max end)while#order>MAX_RX_EPOCHS do row.epochs[table.remove(order).epoch]=nil end security.rx[key]=row saveSecurity()return true end local function newRequestId()return id()..\":\"..password.newSalt(\"peer-request\")end local function sign(peerId,peer,packet)local epoch,sequence=counter(peerId)packet.auth={epoch=epoch,counter=sequence}local material,err=packetMaterial(packet)if not material then return false,err end local mac,macErr=password.hmacSha256(peer.key,material)if not mac then return false,macErr end packet.auth.mac=mac return true end local function verifyPacket(packet,value)if type(packet)~=\"table\"then return false,\"packet is not a table\"end if packet.protocol~=PROTOCOL then return false,packet.protocol==\"ceetos/1\"and\"v1 packet rejected; rekey required\"or\"invalid packet protocol\"end if type(packet.type)~=\"string\"or#packet.type==0 or#packet.type>64 then return false,\"invalid packet type\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid packet sender\"end local from=tostring(packet.from)local peer=activeLink(value,from)if not peer then return false,\"sender is not an active direct or mesh peer\"end if not isForUs(packet.to)then return false,\"packet addressed to another hop\"end if type(packet.origin)~=\"string\"and type(packet.origin)~=\"number\"then return false,\"invalid packet origin\"end if type(packet.destination)~=\"string\"and type(packet.destination)~=\"number\"then return false,\"invalid packet destination\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 or#packet.request_id>128 then return false,\"invalid packet request ID\"end if packet.reply_to~=nil and(type(packet.reply_to)~=\"string\"or#packet.reply_to==0 or#packet.reply_to>128)then return false,\"invalid reply correlation ID\"end local ttl=tonumber(packet.ttl)if not ttl or ttl%1~=0 or ttl<1 or ttl>PACKET_TTL then return false,\"invalid packet TTL\"end local timestamp=tonumber(packet.timestamp)if not timestamp or math.abs(now()-timestamp)>ROUTE_TTL then return false,\"stale packet timestamp\"end if type(packet.auth)~=\"table\"or type(packet.auth.mac)~=\"string\"or#packet.auth.mac~=64 then return false,\"missing packet MAC\"end local receivedMac=packet.auth.mac packet.auth.mac=nil local material,materialErr=packetMaterial(packet)packet.auth.mac=receivedMac if not material then return false,materialErr end local expected,macErr=password.hmacSha256(peer.key,material)if not expected or not password.constantTimeEqual(expected,receivedMac)then return false,macErr or\"invalid packet MAC\"end local replayOk,replayErr=verifyReplay(from,packet.auth)if not replayOk then return false,replayErr end return true,peer end local function routeBucket(targetId)local bucket=routes[tostring(targetId)]if bucket and bucket.next then bucket={candidates={{next=tostring(bucket.next),hops=tonumber(bucket.hops)or PACKET_TTL,expires=tonumber(bucket.expires)or 0,label=bucket.label,mode=bucket.mode,masterId=bucket.masterId,legacy=true,loss=1,}},primary=tostring(bucket.next),changedAt=now(),reason=\"legacy route\"}routes[tostring(targetId)]=bucket end if not bucket then bucket={candidates={},changedAt=now(),reason=\"new\"}routes[tostring(targetId)]=bucket end bucket.candidates=type(bucket.candidates)==\"table\"and bucket.candidates or{}return bucket end local function candidateHealth(candidate)local state=healthFor(candidate.next)local rank=state.state==\"healthy\"and 0 or(state.state==\"degraded\"and 1 or 2)return rank,state end local function directCandidate(value,targetId)local link,kind=activeLink(value,targetId)if link then return{next=targetId,hops=1,expires=now()+ROUTE_TTL,kind=kind,direct=true,label=link.label,mode=link.mode,masterId=link.masterId}end end local function validCandidates(targetId,value)local timestamp,out,seen=now(),{},{}local direct=directCandidate(value,targetId)if direct then out[#out+1],seen[direct.next..\":\"..direct.kind]=direct,true end local bucket=routes[tostring(targetId)]if bucket then for _,candidate in ipairs(routeBucket(targetId).candidates)do local key=tostring(candidate.next)..\":\"..tostring(candidate.kind or\"route\")if not seen[key]and candidate.expires>timestamp and candidate.hops>=1 and candidate.hops<=PACKET_TTL and activeLink(value,candidate.next)then out[#out+1],seen[key]=candidate,true end end end return out end local function compareCandidates(a,b)local ar,ah=candidateHealth(a)local br,bh=candidateHealth(b)if ar~=br then return ar<br end if(a.hops or PACKET_TTL)~=(b.hops or PACKET_TTL)then return(a.hops or PACKET_TTL)<(b.hops or PACKET_TTL)end if(ah.loss or 0)~=(bh.loss or 0)then return(ah.loss or 0)<(bh.loss or 0)end if(ah.rtt or 0)~=(bh.rtt or 0)then return(ah.rtt or 0)<(bh.rtt or 0)end return tostring(a.next)<tostring(b.next)end local function primaryCandidate(targetId,value,safe)local candidates=validCandidates(targetId,value)if#candidates==0 then return nil end table.sort(candidates,compareCandidates)local target,bucket,selected=tostring(targetId),routeBucket(targetId),candidates[1]local existing for _,item in ipairs(candidates)do if tostring(item.next)==tostring(bucket.primary)then existing=item;break end end if existing then local oldRank,newRank=candidateHealth(existing),candidateHealth(selected)if oldRank<newRank then selected=existing elseif oldRank==newRank and oldRank==0 and(selected.hops or 99)<(existing.hops or 99)then local health=healthFor(selected.next)if(health.successes or 0)<2 or(health.recoveredAt and now()-(health.stableSince or now())<PROBE_RECOVERY)then selected=existing end end end if safe then local rank,_,choices=candidateHealth(selected),nil,{}for _,item in ipairs(candidates)do local itemRank=candidateHealth(item)if itemRank==rank and item.hops==selected.hops then choices[#choices+1]=item end end if#choices>1 then table.sort(choices,function(a,b)local ah,bh=healthFor(a.next),healthFor(b.next)local aLoad,bLoad=currentInFlight(ah,now()),currentInFlight(bh,now())if aLoad~=bLoad then return aLoad<bLoad end return tostring(a.next)<tostring(b.next)end)selected=choices[1]end end if bucket.primary~=tostring(selected.next)then bucket.primary,bucket.changedAt,bucket.reason=tostring(selected.next),now(),existing and\"health/hop selection\"or\"initial selection\"trace(\"routing\",\"route_selected\",{destination=target,next=selected.next,hops=selected.hops,reason=bucket.reason})end return selected end local function nextHop(target,safe)local candidate=primaryCandidate(target,config(),safe)if candidate then local health=healthFor(candidate.next)if safe then markInFlight(health)end health.lastSelected=now()return candidate.next,candidate end routes[tostring(target)]=nil end local function transmit(items,channel,packet)if#items==0 then return false,\"no compatible modem attached\"end local sent,lastError=false,nil for _,item in ipairs(items)do local ok,err=pcall(item.modem.transmit,channel,channel,packet)if ok then sent=true else lastError=tostring(err)end end if not sent then transport.lastError=lastError or\"modem transmit failed\"end return sent,transport.lastError end local function send(target,input,forcedHop)local hop=forcedHop or nextHop(target,input.routeSafe==true and input.balanceSafe==true)if not hop then return false,\"peer is unreachable or requires rekey\"end local value,peer=config(),activeLink(config(),hop)if not peer then return false,\"direct route is unavailable\"end local packet=copy(input)packet.auth,packet.protocol,packet.from,packet.to=nil,PROTOCOL,id(),hop packet.origin,packet.destination=tostring(packet.origin or id()),tostring(packet.destination or target)packet.ttl=math.floor(tonumber(packet.ttl)or PACKET_TTL)packet.timestamp=now()if packet.ttl<1 or packet.ttl>PACKET_TTL then return false,\"invalid packet TTL\"end if type(packet.request_id)~=\"string\"or#packet.request_id==0 then packet.request_id=newRequestId()end if packet.confidential==true then local sealed,sealErr=sealBody(peer,packet)if not sealed then return false,sealErr end packet.body=sealed end local signed,signErr=sign(hop,peer,packet)if not signed then return false,signErr end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if not sent then trace(\"transport\",\"transmit_failed\",{type=packet.type,to=hop,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil healthFor(hop).lastTransmit=now()trace(\"routing\",\"packet_sent\",{type=packet.type,to=hop,destination=packet.destination,links=#links})return true end local function rememberReverse(packet,previousHop)if type(packet)~=\"table\"or type(packet.request_id)~=\"string\"or#packet.request_id==0 then return false end local requestId,origin=packet.request_id,tostring(packet.origin)local existing=reverseRoutes[requestId]if existing and(existing.previous~=tostring(previousHop)or existing.origin~=origin)then return false,\"reverse route collision\"end reverseRoutes[requestId]={previous=tostring(previousHop),origin=origin,expires=now()+ROUTE_TTL}local entries={}for key,route in pairs(reverseRoutes)do entries[#entries+1]={id=key,expires=route.expires or 0}end table.sort(entries,function(a,b)return a.expires<b.expires end)while#entries>MAX_REVERSE_ROUTES do reverseRoutes[table.remove(entries,1).id]=nil end return true end local function broadcast(packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";trace(\"discovery\",\"wireless_missing\");return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to=PROTOCOL,id(),0 out.timestamp=now()openChannels(config())local sent,err=transmit(links,DISCOVERY_CHANNEL,out)if not sent then trace(\"discovery\",\"transmit_failed\",{type=out.type,error=err});return false,err end transport.lastTransmit,transport.lastError=now(),nil trace(\"discovery\",out.type==\"discover\"and\"announcement_sent\"or\"discovery_packet_sent\",{type=out.type})return true end local function publicTransmit(target,typeName,body)if not PUBLIC_UPDATE_TYPES[typeName]then return false,\"invalid public update packet type\"end local encoded,encodeErr=canonical(body or{})if not encoded then return false,encodeErr or\"invalid public update body\"end local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end openChannels(config())local packet={protocol=PUBLIC_UPDATE_PROTOCOL,type=typeName,from=id(),to=tostring(target),timestamp=now(),request_id=newRequestId(),body=body or{},}local sent,err=transmit(links,DISCOVERY_CHANNEL,packet)if not sent then transport.lastError=err or\"public update transmit failed\"trace(\"transport\",\"public_update_transmit_failed\",{type=typeName,to=target,error=transport.lastError})return false,transport.lastError end transport.lastTransmit,transport.lastError=now(),nil trace(\"transport\",\"public_update_sent\",{type=typeName,to=target,bytes=#encoded})return true end function M.publicSend(target,typeName,body)if tostring(target)==\"0\"or tostring(target)==\"\"then return false,\"public update target must be a computer ID\"end return publicTransmit(target,typeName,body)end function M.publicBroadcast(typeName,body)return publicTransmit(\"0\",typeName,body)end local function handshake(target,packet)local links=wirelessModems()if#links==0 then transport.lastError=\"no wireless modem attached\";return false,transport.lastError end local out=copy(packet)out.protocol,out.from,out.to,out.timestamp=PROTOCOL,id(),tostring(target),now()out.destination,out.ttl=tostring(target),1 openChannels(config())local sent,err=transmit(links,config().channel or CHANNEL,out)if not sent then trace(\"discovery\",\"handshake_transmit_failed\",{type=out.type,to=target,error=err});return false,err end transport.lastTransmit=now()trace(\"discovery\",out.type..\"_sent\",{to=target})return true end local function phraseTag(phrase,sessionId,hostId)return password.hmacSha256(phrase,\"ceetos/discovery/v2|\"..sessionId..\"|\"..tostring(hostId))end local function joinProof(phrase,sessionId,hostId,joinerId,nonce)return password.hmacSha256(phrase,\"ceetos/pair/join/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce)end local function confirmProof(phrase,sessionId,hostId,joinerId,nonce,mode,master)return password.hmacSha256(phrase,\"ceetos/pair/confirm/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce..\"|\"..tostring(mode)..\"|\"..tostring(master or\"\"))end local function linkKey(phrase,sessionId,hostId,joinerId,nonce)return password.derive(phrase,\"ceetos/link/v2|\"..sessionId..\"|\"..tostring(hostId)..\"|\"..tostring(joinerId)..\"|\"..nonce,64)end local function keyId(key)local value=password.hmacSha256(key,\"ceetos/key-id/v2\")return value and value:sub(1,16)or\"\"end local function activeSession()return discovery and(discovery.state==\"hosting\"or discovery.state==\"searching\"or discovery.state==\"candidate\"or discovery.state==\"confirming\")end local function setLast(state,message)lastDiscovery={state=state,message=message,at=now()}end local function persistPair(peerId,key,metadata,masterId)local value=config()value.peers[tostring(peerId)]={protocol=2,rekeyRequired=false,key=key,keyId=keyId(key),role=\"operator\",mode=metadata.mode or\"peer\",master=tostring(masterId or\"\")==id(),masterId=tostring(masterId or\"\"),label=metadata.label,}save(value)remember(peerId,metadata.label,{mode=metadata.mode,masterId=masterId})routes[tostring(peerId)]=nil routesDirty=true audit.log(\"local\",\"peer.rekeyed\",{peer=peerId,mode=metadata.mode})end local function markRejected(reason)if discovery then discovery=nil end setLast(\"cancelled\",reason)end local function discoveryAnnouncement()if not discovery or discovery.state~=\"hosting\"then return false,\"no active host discovery\"end return broadcast({type=\"discover\",session=discovery.id,tag=discovery.tag,label=discovery.label,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,})end local function queueConfirmation(peerId,host)confirmations[host.id]=host local sent,err=handshake(peerId,{type=\"pair_confirm\",session=host.id,nonce=host.joinNonce,proof=host.confirmProof,label=host.label,mode=host.mode,master=host.masterId,})host.lastSent,host.retries=now(),0 if not sent then host.error=err end return sent,err end local function expireState(timestamp)if discovery and discovery.expires<=timestamp then local old=discovery.state discovery=nil setLast(\"expired\",old==\"searching\"and\"no matching discovery announcement received\"or\"discovery session expired\")trace(\"discovery\",\"session_expired\",{previous=old})end end local function boundMap(value,limit,timestamp)local entries={}for key,row in pairs(value)do entries[#entries+1]={key=key,at=type(row)==\"number\"and row or(type(row)==\"table\"and(row.expires or row.time or row.seen or row.lastAuthenticated or 0)or 0)}end table.sort(entries,function(a,b)if a.at~=b.at then return a.at<b.at end return tostring(a.key)<tostring(b.key)end)while#entries>limit do value[table.remove(entries,1).key]=nil end end local function pruneRouteBuckets(timestamp)local value=config()local entries={}for peerId,bucket in pairs(routes)do local latest=tonumber(bucket.changedAt)or 0 for _,candidate in ipairs(type(bucket.candidates)==\"table\"and bucket.candidates or{})do latest=math.max(latest,tonumber(candidate.expires)or 0)end entries[#entries+1]={peer=peerId,latest=latest}end table.sort(entries,function(a,b)if a.latest~=b.latest then return a.latest<b.latest end return tostring(a.peer)<tostring(b.peer)end)while#entries>ROUTE_BUCKET_LIMIT do local old=table.remove(entries,1)routes[old.peer],routesDirty=nil,true trace(\"routing\",\"route_bucket_evicted\",{destination=old.peer})end for peerId,state in pairs(linkHealth)do if not activeLink(value,peerId)and not routes[peerId]then linkHealth[peerId]=nil end end for peerId in pairs(advertisedRoutes)do if not activeLink(value,peerId)then advertisedRoutes[peerId]=nil end end boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)end local function controller(value)value=value or config()if value.controller and tostring(value.controller)~=\"\"then local chosen=tostring(value.controller)if chosen==id()or activeLink(value,chosen)then return chosen end local known=routes[chosen]if known then if known.expires and known.expires>now()then return chosen end if type(known.candidates)==\"table\"then for _,candidate in ipairs(known.candidates)do if(candidate.expires or 0)>now()and activeLink(value,candidate.next)then return chosen end end end end trace(\"routing\",\"controller_unreachable\",{controller=chosen})end local selected=tonumber(id())or 0 for peerId in pairs(value.peers)do if activePeer(value,peerId)then local n=tonumber(peerId);if n and n<selected then selected=n end end end for peerId,route in pairs(routes)do local reachable=route.expires and route.expires>now()if type(route.candidates)==\"table\"then reachable=false for _,candidate in ipairs(route.candidates)do if(candidate.expires or 0)>now()then reachable=true;break end end end if reachable then local n=tonumber(peerId);if n and n<selected then selected=n end end end return tostring(selected)end local function meshConfig(value)value=value or config()local mesh=value.mesh if type(mesh)==\"table\"and type(mesh.id)==\"string\"and#mesh.id>=16 and type(mesh.root)==\"string\"and#mesh.root>=32 and tonumber(mesh.epoch)then return mesh end return nil end local function meshMaterial(packet)return canonical({protocol=packet.protocol,type=packet.type,from=packet.from,to=packet.to,mesh=packet.mesh,epoch=packet.epoch,nonce=packet.nonce,offer=packet.offer,timestamp=packet.timestamp})end local function meshTag(mesh,packet)local material=meshMaterial(packet)return material and password.hmacSha256(mesh.root,material)or nil end local function meshPacket(typeName,target,fields)local value,mesh=config(),meshConfig()if not mesh then return false,\"mesh enrollment is pending\"end local packet=copy(fields or{})packet.protocol,packet.type,packet.from,packet.to=PROTOCOL,typeName,id(),target and tostring(target)or 0 packet.mesh,packet.epoch,packet.timestamp=mesh.id,mesh.epoch,now()packet.tag=meshTag(mesh,packet)if not packet.tag then return false,\"could not authenticate mesh packet\"end openChannels(value)local links=wirelessModems()if#links==0 then return false,\"no wireless modem attached\"end local sent,err=transmit(links,value.channel or CHANNEL,packet)if sent then trace(\"routing\",typeName..\"_sent\",{to=packet.to,mesh=mesh.id:sub(1,8)})end return sent,err end local function deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)local left,right=tostring(id()),tostring(peerId)if left>right then left,right=right,left end return password.hmacSha256(mesh.root,\"ceetos/mesh-edge/v1|\"..tostring(mesh.epoch)..\"|\"..left..\"|\"..right..\"|\"..tostring(firstNonce)..\"|\"..tostring(secondNonce))end local function ownsMeshOffer(peerId)local ours,theirs=tonumber(id()),tonumber(peerId)if ours and theirs then return ours<theirs end return tostring(id())<tostring(peerId)end local function installAutoEdge(mesh,peerId,firstNonce,secondNonce,peerLabel)peerId=tostring(peerId)local value=config()if activePeer(value,peerId)then return false,\"manual direct link already exists\"end local key=deriveAutoEdge(mesh,peerId,firstNonce,secondNonce)if not key then return false,\"could not derive mesh edge\"end autoEdges[peerId]={key=key,label=peerLabel,mesh=mesh.id,epoch=mesh.epoch,expires=now()+ROUTE_TTL,firstNonce=firstNonce,secondNonce=secondNonce}local state=healthFor(peerId)state.state,state.successes,state.misses,state.lastAuthenticated,state.stableSince=\"healthy\",2,0,now(),now()routesDirty,meshDirty=true,true trace(\"routing\",\"mesh_edge_active\",{peer=peerId,mesh=mesh.id:sub(1,8)})return true end local function meshEnrollmentAad(from,to,meshId,epoch,nonceCounter)return canonical({protocol=PROTOCOL,type=\"mesh_enroll\",from=tostring(from),to=tostring(to),mesh=meshId,epoch=tonumber(epoch),counter=tonumber(nonceCounter)})end local function sendEnrollment(peerId)local value,mesh,peer=config(),meshConfig(),activePeer(config(),peerId)if not mesh or not peer then return false,\"mesh or direct link unavailable\"end local _,nonceCounter=counter(peerId)local aad=meshEnrollmentAad(id(),peerId,mesh.id,mesh.epoch,nonceCounter)local nonce=meshCrypto.nonce(peer.key,nonceCounter,\"mesh-enroll|\"..id()..\"|\"..tostring(peerId))local plaintext=textutils.serialise({id=mesh.id,epoch=mesh.epoch,root=mesh.root},{compact=true})local envelope,err=meshCrypto.seal(peer.key,nonce,aad,plaintext)if not envelope then return false,err end local sent,sendErr=send(peerId,{type=\"mesh_enroll\",body={mesh=mesh.id,epoch=mesh.epoch,counter=nonceCounter,envelope=envelope},request_id=newRequestId()},peerId)if sent then trace(\"routing\",\"mesh_enrollment_sent\",{to=peerId,epoch=mesh.epoch})end return sent,sendErr end local function acceptEnrollment(from,peer,packet)if not activePeer(config(),from)then return rejectPacket(\"mesh enrollment requires a manual direct link\",packet)end local body=packet.body if type(body)~=\"table\"or type(body.mesh)~=\"string\"or type(body.envelope)~=\"table\"or not tonumber(body.epoch)or not tonumber(body.counter)then return rejectPacket(\"malformed_mesh_enrollment\",packet)end local aad=meshEnrollmentAad(from,id(),body.mesh,body.epoch,body.counter)local plaintext,err=meshCrypto.open(peer.key,body.envelope,aad)if not plaintext then return rejectPacket(err or\"mesh enrollment authentication failed\",packet)end local ok,mesh=pcall(textutils.unserialise,plaintext)if not ok or type(mesh)~=\"table\"or mesh.id~=body.mesh or tonumber(mesh.epoch)~=tonumber(body.epoch)or type(mesh.root)~=\"string\"or#mesh.root<32 then return rejectPacket(\"invalid_mesh_enrollment\",packet)end local value,existing=config(),meshConfig()if existing and existing.id==mesh.id and tonumber(existing.epoch)>tonumber(mesh.epoch)then return end value.mesh={id=mesh.id,epoch=tonumber(mesh.epoch),root=mesh.root,enrolledAt=now(),enrolledBy=tostring(from)}save(value)meshDirty,routesDirty=true,true trace(\"routing\",\"mesh_enrolled\",{from=from,mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end local function ensureMeshEnrollment(timestamp)local value,mesh=config(),meshConfig()if not mesh then if(M._meshBootstrapAt or 0)>timestamp or controller(value)~=id()then return end value.mesh={id=password.newSalt(\"mesh-id:\"..id()),root=password.newSalt(\"mesh-root:\"..id()),epoch=1,createdAt=timestamp,controller=id()}save(value);mesh,meshDirty,routesDirty=value.mesh,true,true trace(\"routing\",\"mesh_created\",{mesh=mesh.id:sub(1,8),epoch=mesh.epoch})end for _,peerId in ipairs(allDirectLinks(value))do if activePeer(value,peerId)then local previous=meshEnrollmentSends[peerId]if not previous or previous.epoch~=mesh.epoch or timestamp-previous.at>=MESH_FULL_INTERVAL then local sent=sendEnrollment(peerId)if sent then meshEnrollmentSends[peerId]={epoch=mesh.epoch,at=timestamp}end end end end end local function meshBeacon(timestamp)local mesh=meshConfig()if not mesh or timestamp-lastMeshBeacon<MESH_BEACON_INTERVAL then return end lastMeshBeacon=timestamp meshPacket(\"mesh_beacon\",nil,{nonce=password.newSalt(\"mesh-beacon:\"..id()),label=label()})end local function verifyMeshPacket(packet)local mesh=meshConfig()if not mesh or type(packet)~=\"table\"or packet.protocol~=PROTOCOL or packet.mesh~=mesh.id or tonumber(packet.epoch)~=tonumber(mesh.epoch)then return false,\"mesh membership proof failed\"end if type(packet.from)~=\"string\"and type(packet.from)~=\"number\"then return false,\"invalid mesh sender\"end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 then return false,\"invalid mesh nonce\"end if math.abs(now()-(tonumber(packet.timestamp)or 0))>ROUTE_TTL then return false,\"stale mesh packet\"end local material,tag=meshMaterial(packet),packet.tag local expected=material and password.hmacSha256(mesh.root,material)if type(tag)~=\"string\"or not expected or not password.constantTimeEqual(expected,tag)then return false,\"invalid mesh packet tag\"end local replay=tostring(packet.from)..\"|\"..tostring(packet.type)..\"|\"..tostring(packet.nonce)..\"|\"..tostring(packet.offer or\"\")if meshSeen[replay]and meshSeen[replay]+ROUTE_TTL>now()then return false,\"replayed mesh packet\"end meshSeen[replay]=now()return true,mesh end local function handleMeshPacket(packet,distance)local valid,meshOrErr=verifyMeshPacket(packet)if not valid then return rejectPacket(meshOrErr,packet,nil,distance)end local mesh,from=meshOrErr,tostring(packet.from)if from==id()then return end if packet.type==\"mesh_beacon\"then remember(from,packet.label,{mesh=mesh.id})if not activePeer(config(),from)and not autoEdges[from]and ownsMeshOffer(from)then local nonce=password.newSalt(\"mesh-offer:\"..from)meshOffers[from]={offer=nonce,expires=now()+DISCOVERY_TTL}meshPacket(\"mesh_edge_offer\",from,{nonce=nonce,label=label()})end return end if not isForUs(packet.to)then return rejectPacket(\"mesh packet addressed to another peer\",packet,nil,distance)end if packet.type==\"mesh_edge_offer\"then if activePeer(config(),from)then return end local response=password.newSalt(\"mesh-accept:\"..from)installAutoEdge(mesh,from,packet.nonce,response,packet.label)return meshPacket(\"mesh_edge_accept\",from,{nonce=response,offer=packet.nonce,label=label()})end if packet.type==\"mesh_edge_accept\"then local offer=meshOffers[from]if not offer or offer.expires<=now()or offer.offer~=packet.offer then return rejectPacket(\"unexpected mesh edge acceptance\",packet,nil,distance)end meshOffers[from]=nil return installAutoEdge(mesh,from,offer.offer,packet.nonce,packet.label)end end local function probeLinks(timestamp)local value=config()for _,peerId in ipairs(allDirectLinks(value))do local health=healthFor(peerId)local interval=health.state==\"offline\"and PROBE_INTERVAL*3 or PROBE_INTERVAL if timestamp-(health.lastAuthenticated or 0)>=interval and timestamp-(health.lastProbe or 0)>=interval then if health.awaiting then health.misses=(health.misses or 0)+1 health.loss=math.min(1,((health.loss or 0)*3+1)/4)local nextState=health.misses>=PROBE_OFFLINE and\"offline\"or(health.misses>=PROBE_DEGRADED and\"degraded\"or health.state)if nextState~=health.state then health.state,health.successes,health.recoveredAt=nextState,0,nil trace(\"routing\",\"link_\"..nextState,{peer=peerId,misses=health.misses})end routesDirty=true end health.awaiting,health.lastProbe,health.probeToken=true,timestamp,password.newSalt(\"mesh-probe:\"..peerId)send(peerId,{type=\"mesh_probe\",body={token=health.probeToken},request_id=newRequestId()},peerId)end end end local function advertisedMembers(value,peerId,timestamp)local members={}for other,manual in pairs(value.peers)do if other~=peerId and activeLink(value,other)and linkState(other)==\"healthy\"then members[other]={label=manual.label,mode=manual.mode,masterId=manual.masterId,hops=1,kind=\"direct\"}end end for other,edge in pairs(autoEdges)do if other~=peerId and edge.expires>timestamp and linkState(other)==\"healthy\"then members[other]={label=edge.label,mode=\"peer\",hops=1,kind=\"mesh\"}end end for other in pairs(routes)do if other~=peerId and not members[other]then local candidate=primaryCandidate(other,value,false)if candidate and candidate.next~=peerId and linkState(candidate.next)==\"healthy\"then members[other]={label=candidate.label,mode=candidate.mode,masterId=candidate.masterId,hops=candidate.hops,kind=candidate.kind or\"route\"}end end end return members end local function sameAdvertisement(left,right)local leftValue,leftErr=canonical(left)local rightValue,rightErr=canonical(right)return leftValue~=nil and rightValue~=nil and not leftErr and not rightErr and leftValue==rightValue end local function advertiseRoutes(force)local timestamp,value=now(),config()if not force and not routesDirty and timestamp-lastRouteAdvertisement<ROUTE_INTERVAL then return end lastRouteAdvertisement,routesDirty=timestamp,false local full=timestamp-lastMeshFull>=MESH_FULL_INTERVAL if full then lastMeshFull=timestamp end for _,peerId in ipairs(allDirectLinks(value))do if linkUsable(value,peerId,false)then local desired,previous=advertisedMembers(value,peerId,timestamp),advertisedRoutes[peerId]or{}local members,withdrawals={},{}if full then members=desired else for target,meta in pairs(desired)do if not sameAdvertisement(meta,previous[target])then members[target]=meta end end for target in pairs(previous)do if not desired[target]then withdrawals[#withdrawals+1]=target end end end table.sort(withdrawals,function(a,b)return tostring(a)<tostring(b)end)if full or next(members)~=nil or#withdrawals>0 then routeSequence=routeSequence+1 local body={sequence=routeSequence,routeVersion=2,full=full,controller=controller(value),members=members,withdrawals=withdrawals}if send(peerId,{type=\"route_advertise\",body=body,routeSafe=true,request_id=newRequestId()})then advertisedRoutes[peerId]=copy(desired)trace(\"routing\",full and\"route_snapshot_sent\"or\"route_delta_sent\",{to=peerId,changes=(full and 0 or#withdrawals)})end end else advertisedRoutes[peerId]=nil end end end function M.start()migrateV1Links()loadSecurity()assert(meshCrypto.selfTest(),\"CeetOS mesh cryptography self-test failed\")openChannels(config())local status=M.transportStatus()trace(\"transport\",status.wireless and\"wireless_modem_detected\"or\"wireless_modem_missing\",{name=status.name})routesDirty,M._meshBootstrapAt=true,now()end function M.transportStatus()local wireless=wirelessModems()transport.modem,transport.wireless=#modems()>0,#wireless>0 transport.name=wireless[1]and wireless[1].name or nil local out=copy(transport)out.wirelessLinks,out.wirelessLinkCount={},#wireless for _,item in ipairs(wireless)do out.wirelessLinks[#out.wirelessLinks+1]=item.name end out.usesAllWirelessLinks,out.protocol=true,2 out.directPeers,out.manualDirectPeers,out.meshPeers,out.rekeyRequiredPeers,out.routedPeers=0,0,0,0,0 out.healthyLinks,out.degradedLinks,out.offlineLinks=0,0,0 local value=config()for peerId,peer in pairs(value.peers)do if activePeer(value,peerId)then out.directPeers,out.manualDirectPeers=out.directPeers+1,out.manualDirectPeers+1 elseif peer.rekeyRequired then out.rekeyRequiredPeers=out.rekeyRequiredPeers+1 end end for peerId,edge in pairs(autoEdges)do if edge.expires>now()then out.meshPeers,out.directPeers=out.meshPeers+1,out.directPeers+1 end end for peerId,health in pairs(linkHealth)do if health.state==\"healthy\"then out.healthyLinks=out.healthyLinks+1 elseif health.state==\"degraded\"then out.degradedLinks=out.degradedLinks+1 elseif health.state==\"offline\"then out.offlineLinks=out.offlineLinks+1 end end for peerId,bucket in pairs(routes)do local usable=primaryCandidate(peerId,value,false)if usable and not value.peers[peerId]and not autoEdges[peerId]then out.routedPeers=out.routedPeers+1 end end local mesh=meshConfig(value)out.mesh=mesh and{id=mesh.id:sub(1,8),epoch=mesh.epoch,enrolled=true}or{enrolled=false}out.health={healthy=out.healthyLinks,degraded=out.degradedLinks,offline=out.offlineLinks}return out end function M.transportTrace(kind)if kind==\"discovery\"or kind==\"routing\"or kind==\"transport\"then return copy(traces[kind])end return{discovery=copy(traces.discovery),routing=copy(traces.routing),transport=copy(traces.transport)}end function M.discovery()expireState(now())return copy(discovery)end function M.discoveryStatus()expireState(now())local candidate=discovery and discovery.candidate and{id=discovery.candidate.from,label=discovery.candidate.label,mode=discovery.candidate.mode,master=discovery.candidate.master,}or nil local session=discovery and{session=discovery.id,state=discovery.state,mode=discovery.mode,master=discovery.masterSide,expires=discovery.expires,retries=discovery.retries or 0,candidate=candidate and copy(candidate)or nil,}or nil local state=session and session.state or(lastDiscovery and lastDiscovery.state or\"inactive\")return{state=state,active=session~=nil,lastState=lastDiscovery and lastDiscovery.state or\"inactive\",lastMessage=lastDiscovery and lastDiscovery.message or nil,session=session,searching=session and session.state==\"searching\"or false,candidate=candidate,discovered=#M.seenPeers(),transport=M.transportStatus(),message=(discovery and discovery.error)or(lastDiscovery and lastDiscovery.message),}end function M.startDiscovery(mode,masterSide,phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end mode=mode==\"master\"and\"master\"or\"peer\"masterSide=masterSide==\"joiner\"and\"joiner\"or\"initiator\"local sessionId=password.newSalt(\"discovery:\"..id())discovery={id=sessionId,state=\"hosting\",phrase=normalized,tag=phraseTag(normalized,sessionId,id()),mode=mode,masterSide=masterSide,label=label(),initiator=id(),expires=now()+DISCOVERY_TTL,retries=0,lastBroadcast=0,}local sent,err=discoveryAnnouncement()if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastBroadcast=now()setLast(\"hosting\")return true,{state=\"hosting\",session=sessionId,expires=discovery.expires}end function M.joinDiscovery(phrase)if activeSession()then return false,\"cancel the active discovery session first\"end local normalized,phraseErr=M.normalizePhrase(phrase)if not normalized then return false,phraseErr end local candidate for _,item in pairs(discovered)do if item.expires>now()and password.constantTimeEqual(item.tag or\"\",phraseTag(normalized,item.session,item.from))then candidate=item;break end end discovery={state=\"searching\",phrase=normalized,expires=now()+DISCOVERY_TTL,retries=0,lastQuery=0}if candidate then discovery.state,discovery.candidate=\"candidate\",candidate return true,{state=\"candidate\",candidate={id=candidate.from,label=candidate.label,mode=candidate.mode,master=candidate.master}}end local sent,err=broadcast({type=\"discover_query\"})if not sent then discovery=nil;setLast(\"cancelled\",err);return false,err end discovery.lastQuery=now()setLast(\"searching\",\"waiting for matching discovery announcement\")return true,{state=\"searching\"}end function M.confirmDiscovery()if not discovery or discovery.state~=\"candidate\"or not discovery.candidate then return false,\"no discovery candidate is awaiting confirmation\"end local candidate,value=discovery.candidate,config()local existing=value.peers[tostring(candidate.from)]if existing and not existing.rekeyRequired then return false,\"computer is already a network member\"end if routes[tostring(candidate.from)]and not existing then return false,\"computer is already a routed network member\"end local nonce=password.newSalt(\"pair-join:\"..candidate.session)local proof=joinProof(discovery.phrase,candidate.session,candidate.from,id(),nonce)discovery.state,discovery.joinNonce,discovery.joinProof,discovery.lastSent,discovery.retries=\"confirming\",nonce,proof,now(),0 local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=nonce,proof=proof,label=label()})if not sent then discovery.error=err;return false,err end trace(\"discovery\",\"pair_confirmation_requested\",{peer=candidate.from})return true end function M.cancelDiscovery()if discovery and discovery.state==\"hosting\"then broadcast({type=\"discover_cancel\",session=discovery.id})end discovery=nil setLast(\"cancelled\",\"discovery cancelled\")trace(\"discovery\",\"session_cancelled\")return true end function M.normalizePhrase(value)if type(value)~=\"string\"then return nil,\"phrase is required\"end if value:find(\"[%z\\1-\\31\\127]\")then return nil,\"phrase contains control characters\"end value=value:gsub(\"^%s+\",\"\"):gsub(\"%s+$\",\"\")if#value<8 then return nil,\"phrase must be at least 8 characters\"end if#value>128 then return nil,\"phrase must be at most 128 characters\"end return value end function M.tick()local timestamp=now()expireState(timestamp)if discovery then if discovery.state==\"hosting\"and timestamp-(discovery.lastBroadcast or 0)>=math.min(30000,DISCOVERY_INTERVAL*(2^math.min(discovery.retries or 0,4)))then local sent,err=discoveryAnnouncement()discovery.lastBroadcast=timestamp discovery.retries=(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"searching\"and timestamp-(discovery.lastQuery or 0)>=DISCOVERY_INTERVAL then local sent,err=broadcast({type=\"discover_query\"})discovery.lastQuery,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end elseif discovery.state==\"confirming\"and timestamp-(discovery.lastSent or 0)>=PAIR_RETRY then local candidate=discovery.candidate local sent,err=handshake(candidate.from,{type=\"pair_join\",session=candidate.session,nonce=discovery.joinNonce,proof=discovery.joinProof,label=label()})discovery.lastSent,discovery.retries=timestamp,(discovery.retries or 0)+1 if not sent then discovery.error=err end end end for sessionId,item in pairs(discovered)do if item.expires<=timestamp then discovered[sessionId]=nil end end for sessionId,record in pairs(confirmations)do if record.expires<=timestamp then confirmations[sessionId]=nil elseif timestamp-(record.lastSent or 0)>=PAIR_RETRY then queueConfirmation(record.peer,record)end end for peerId,bucket in pairs(routes)do local kept={}for _,candidate in ipairs(routeBucket(peerId).candidates)do if candidate.expires>timestamp then kept[#kept+1]=candidate end end bucket.candidates=kept if#kept==0 and not activeLink(config(),peerId)then routes[peerId],routesDirty=nil,true end end for peerId,edge in pairs(autoEdges)do if edge.expires<=timestamp then autoEdges[peerId],routesDirty=nil,true;trace(\"routing\",\"mesh_edge_expired\",{peer=peerId})end end for key,seenAt in pairs(meshSeen)do if seenAt+ROUTE_TTL<=timestamp then meshSeen[key]=nil end end for peerId,offer in pairs(meshOffers)do if offer.expires<=timestamp then meshOffers[peerId]=nil end end for requestId,seenAt in pairs(seenPackets)do if seenAt+ROUTE_TTL<=timestamp then seenPackets[requestId]=nil end end for requestId,route in pairs(reverseRoutes)do if route.expires<=timestamp then reverseRoutes[requestId]=nil end end boundMap(meshSeen,MESH_STATE_LIMIT,timestamp)boundMap(meshOffers,MESH_STATE_LIMIT,timestamp)pruneRouteBuckets(timestamp)ensureMeshEnrollment(timestamp)meshBeacon(timestamp)probeLinks(timestamp)advertiseRoutes(false)end function M.peers()local out,value,seen={},config(),read(SEEN_PATH,{})for peerId,peer in pairs(value.peers)do out[#out+1]={id=peerId,label=peer.label or(seen[peerId]and seen[peerId].label),role=peer.role or\"operator\",mode=peer.mode or\"peer\",master=peer.master==true,masterId=peer.masterId,direct=true,active=activePeer(value,peerId)~=nil,rekeyRequired=peer.rekeyRequired==true or peer.protocol~=2,health=linkState(peerId),auto=false,}end for peerId,edge in pairs(autoEdges)do if not value.peers[peerId]and edge.expires>now()then out[#out+1]={id=peerId,label=edge.label or(seen[peerId]and seen[peerId].label),role=\"mesh\",mode=\"peer\",direct=true,auto=true,active=true,health=linkState(peerId)}end end for peerId in pairs(routes)do if not value.peers[peerId]and not autoEdges[peerId]then local route=primaryCandidate(peerId,value,false)if route then out[#out+1]={id=peerId,label=route.label or(seen[peerId]and seen[peerId].label),role=\"routed\",mode=route.mode or\"peer\",masterId=route.masterId,routed=true,hops=route.hops,next=route.next,health=linkState(route.next),alternates=#routeBucket(peerId).candidates-1}end end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.directPeers()local out={}for _,peer in ipairs(M.peers())do if peer.direct and peer.active then out[#out+1]=peer end end return out end function M.seenPeers()local out={}for peerId,item in pairs(read(SEEN_PATH,{}))do if not item.seen or item.seen+DISCOVERY_TTL*2>now()then out[#out+1]={id=peerId,label=item.label,seen=item.seen,session=item.session}end end table.sort(out,function(a,b)return tonumber(a.id)<tonumber(b.id)end)return out end function M.routeStatus(target)local value,out=config(),{}local function row(peerId)local selected=primaryCandidate(peerId,value,false)if not selected then return end local health=healthFor(selected.next)local alternates={}for _,candidate in ipairs(validCandidates(peerId,value))do if tostring(candidate.next)~=tostring(selected.next)then local state=healthFor(candidate.next)alternates[#alternates+1]={next=candidate.next,hops=candidate.hops,kind=candidate.kind or\"route\",health=state.state,loss=state.loss or 0,rtt=state.rtt,distance=state.lastDistance}end end table.sort(alternates,compareCandidates)while#alternates>ROUTE_CANDIDATE_LIMIT-1 do table.remove(alternates)end out[#out+1]={id=tostring(peerId),label=selected.label,next=selected.next,hops=selected.hops,kind=selected.kind or\"route\",health=health.state,loss=health.loss or 0,rtt=health.rtt,distance=health.lastDistance,selectedAt=routeBucket(peerId).changedAt,reason=routeBucket(peerId).reason,alternates=alternates,}end if target then row(tostring(target))else local ids,seen={},{}for peerId in pairs(value.peers)do ids[#ids+1],seen[peerId]=peerId,true end for peerId in pairs(autoEdges)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end for peerId in pairs(routes)do if not seen[peerId]then ids[#ids+1],seen[peerId]=peerId,true end end table.sort(ids,function(a,b)return tonumber(a)<tonumber(b)end)for _,peerId in ipairs(ids)do row(peerId)end end return out end function M.statusSnapshot()return{protocol=2,transport=M.transportStatus(),discovery=M.discoveryStatus(),peers=M.peers(),routes=M.routeStatus(),trace=M.transportTrace(),controller=M.controller()}end function M.controller()return controller()end function M.isDirectController(from,packet)return tostring(from)==tostring(controller())and type(packet)==\"table\"and tostring(packet.origin or\"\")==tostring(from)end function M.setController(value)assert(tonumber(value),\"controller must be a computer ID\")local saved=config();saved.controller=tostring(value);save(saved);routesDirty=true audit.log(\"local\",\"jobs.controller\",{controller=saved.controller})return saved.controller end function M.request(target,typeName,body,options)if type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid request type\"end local destination=tostring(target)local value=config()if not primaryCandidate(destination,value,options and options.safe==true)then return false,\"peer is unreachable, degraded, or requires rekey\"end return send(destination,{type=typeName,body=body or{},origin=id(),routeSafe=options and options.safe==true,balanceSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId()})end function M.reply(request,typeName,body,options)if type(request)~=\"table\"or type(typeName)~=\"string\"or#typeName==0 or#typeName>64 then return false,\"invalid reply\"end local requestId,destination=request.request_id,tostring(request.origin or\"\")local reverse=type(requestId)==\"string\"and reverseRoutes[requestId]or nil if destination==\"\"or not reverse or reverse.expires<=now()or reverse.origin~=destination then return false,\"reverse reply route is unavailable\"end return send(destination,{type=typeName,body=body or{},origin=id(),destination=destination,reply_to=requestId,routeSafe=options and options.safe==true,confidential=options and options.confidential==true,request_id=newRequestId(),},reverse.previous)end function M.offer()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.accept()return false,\"legacy pairing is disabled; use phrase discovery\"end function M.discover()return broadcast({type=\"discover_query\"})end rejectPacket=function(reason,packet,channel,distance)transport.rejected=transport.rejected+1 trace(\"transport\",\"packet_rejected\",{reason=reason,type=type(packet)==\"table\"and packet.type or nil,channel=channel,distance=distance,from=type(packet)==\"table\"and packet.from or nil})end local function handleDiscovery(packet,channel,distance)local from=tostring(packet.from)if packet.type==\"discover_cancel\"and isBroadcast(packet.to)then discovered[tostring(packet.session)]=nil trace(\"discovery\",\"cancel_received\",{from=from,distance=distance})return end if packet.type==\"discover_query\"and isBroadcast(packet.to)and discovery and discovery.state==\"hosting\"then discoveryAnnouncement()trace(\"discovery\",\"query_answered\",{from=from,distance=distance})return end if packet.type==\"discover\"and isBroadcast(packet.to)and from~=id()then if type(packet.session)~=\"string\"or#packet.session<16 or type(packet.tag)~=\"string\"or#packet.tag~=64 then return rejectPacket(\"malformed_discovery\",packet,channel,distance)end local expires=tonumber(packet.expires)or(now()+DISCOVERY_TTL)discovered[packet.session]={session=packet.session,from=from,tag=packet.tag,label=tostring(packet.label or(\"Computer \"..from)):sub(1,128),mode=packet.mode==\"master\"and\"master\"or\"peer\",master=packet.master==\"joiner\"and\"joiner\"or\"initiator\",expires=math.min(expires,now()+DISCOVERY_TTL)}remember(from,packet.label,{session=packet.session})trace(\"discovery\",\"announcement_received\",{from=from,label=packet.label,distance=distance})if discovery and discovery.state==\"searching\"and password.constantTimeEqual(packet.tag,phraseTag(discovery.phrase,packet.session,from))then local value,existing=config(),config().peers[from]if existing and not existing.rekeyRequired then markRejected(\"computer is already a direct peer\")elseif routes[from]and not existing then markRejected(\"computer is already a routed network member\")else discovery.state,discovery.candidate,discovery.error=\"candidate\",discovered[packet.session],nil setLast(\"candidate\",\"matching computer found; confirm pairing\")trace(\"discovery\",\"candidate_found\",{from=from,label=packet.label,distance=distance})end end return end end local function handlePairJoin(packet,distance)if not discovery or discovery.state~=\"hosting\"or packet.session~=discovery.id then return end local from=tostring(packet.from)local value,existing=config(),config().peers[from]if(existing and not existing.rekeyRequired)or(routes[from]and not existing)then handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"already_network_member\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"already_network_member\"})return end if type(packet.nonce)~=\"string\"or#packet.nonce<16 or#packet.nonce>128 or type(packet.proof)~=\"string\"or#packet.proof~=64 then return rejectPacket(\"malformed_pair_join\",packet,nil,distance)end local expected=joinProof(discovery.phrase,discovery.id,id(),from,packet.nonce)if not password.constantTimeEqual(expected,packet.proof)then discovery.failures=(discovery.failures or 0)+1 if discovery.failures>=5 then markRejected(\"too many invalid pairing proofs\")end handshake(from,{type=\"pair_reject\",session=packet.session,reason=\"phrase_mismatch\"})trace(\"discovery\",\"pair_rejected\",{from=from,reason=\"phrase_mismatch\"})return end local masterId=discovery.mode==\"master\"and(discovery.masterSide==\"initiator\"and id()or from)or\"\"local key,keyErr=linkKey(discovery.phrase,discovery.id,id(),from,packet.nonce)if not key then return markRejected(keyErr)end persistPair(from,key,{mode=discovery.mode,label=packet.label},masterId)local record={id=discovery.id,peer=from,joinNonce=packet.nonce,mode=discovery.mode,masterId=masterId,label=label(),expires=now()+DISCOVERY_TTL}record.confirmProof=confirmProof(discovery.phrase,record.id,id(),from,record.joinNonce,record.mode,record.masterId)discovery=nil setLast(\"paired\",\"awaiting pairing acknowledgement\")trace(\"discovery\",\"pair_join_verified\",{from=from,distance=distance})return queueConfirmation(from,record)end local function handlePairConfirm(packet,distance)if not discovery or discovery.state~=\"confirming\"or not discovery.candidate or packet.session~=discovery.candidate.session then return end local from=tostring(packet.from)if from~=tostring(discovery.candidate.from)or packet.nonce~=discovery.joinNonce then return rejectPacket(\"unexpected_pair_confirmation\",packet,nil,distance)end local expected=confirmProof(discovery.phrase,packet.session,from,id(),discovery.joinNonce,packet.mode==\"master\"and\"master\"or\"peer\",packet.master or\"\")if not password.constantTimeEqual(expected,packet.proof or\"\")then return markRejected(\"pair confirmation proof did not match\")end local key,err=linkKey(discovery.phrase,packet.session,from,id(),discovery.joinNonce)if not key then return markRejected(err)end persistPair(from,key,{mode=packet.mode,label=packet.label},packet.master)local sessionId=packet.session discovery=nil setLast(\"paired\",\"paired with \"..tostring(packet.label or from))handshake(from,{type=\"pair_ack\",session=sessionId,proof=password.hmacSha256(key,\"ceetos/pair/ack/v2|\"..sessionId)})trace(\"discovery\",\"pair_confirmed\",{from=from,distance=distance})return true end local function handlePairAck(packet)local record=confirmations[packet.session]if not record or tostring(record.peer)~=tostring(packet.from)then return end local value,peer=config(),activePeer(config(),record.peer)if not peer then return end local expected=password.hmacSha256(peer.key,\"ceetos/pair/ack/v2|\"..packet.session)if password.constantTimeEqual(expected,packet.proof or\"\")then confirmations[packet.session]=nil setLast(\"paired\",\"paired with \"..tostring(record.peer))routesDirty=true trace(\"discovery\",\"pair_acknowledged\",{from=packet.from})end end local function handleRouteAdvertisement(from,packet)local body=packet.body if type(body)~=\"table\"or type(body.sequence)~=\"number\"or type(body.members)~=\"table\"or(body.withdrawals~=nil and type(body.withdrawals)~=\"table\")then return rejectPacket(\"malformed_route_advertisement\",packet)end local key=tostring(from)M._routeSequences=M._routeSequences or{}if(M._routeSequences[key]or-1)>=body.sequence then return end M._routeSequences[key]=body.sequence local value,changed,count=config(),false,0 if body.controller and not value.controller then value.controller,changed=tostring(body.controller),true end local announced={}for advertisedId,meta in pairs(body.members)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local peerId=tostring(advertisedId)announced[peerId]=true if peerId~=id()and peerId~=key and type(meta)==\"table\"then local hops=math.floor(tonumber(meta.hops)or 0)+1 if hops>1 and hops<=PACKET_TTL and type(meta.label)~=\"table\"and type(meta.mode)~=\"table\"then local bucket,found=routeBucket(peerId),nil for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)==key then found=candidate;break end end if found then local metadataChanged=found.hops~=hops or found.label~=meta.label or found.mode~=meta.mode or tostring(found.masterId or\"\")~=tostring(meta.masterId or\"\")or found.kind~=(meta.kind or\"route\")found.hops,found.expires=hops,now()+ROUTE_TTL found.label,found.mode,found.masterId,found.kind=meta.label,meta.mode,meta.masterId,meta.kind or\"route\"if metadataChanged then changed=true end else bucket.candidates[#bucket.candidates+1]={next=key,hops=hops,expires=now()+ROUTE_TTL,label=type(meta.label)==\"string\"and meta.label:sub(1,128)or nil,mode=meta.mode==\"master\"and\"master\"or\"peer\",masterId=meta.masterId and tostring(meta.masterId)or nil,kind=meta.kind==\"mesh\"and\"mesh\"or\"route\"}table.sort(bucket.candidates,compareCandidates)while#bucket.candidates>ROUTE_CANDIDATE_LIMIT do table.remove(bucket.candidates)end changed=true end end end end local withdrawals=body.withdrawals or{}for _,withdrawnId in pairs(withdrawals)do count=count+1 if count>MAX_PACKET_TABLE then return rejectPacket(\"route_advertisement_too_large\",packet)end local bucket=routes[tostring(withdrawnId)]if bucket and type(bucket.candidates)==\"table\"then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end if body.full==true then for peerId,bucket in pairs(routes)do if type(bucket.candidates)==\"table\"and not announced[tostring(peerId)]then local kept={}for _,candidate in ipairs(bucket.candidates)do if tostring(candidate.next)~=key then kept[#kept+1]=candidate else changed=true end end bucket.candidates=kept end end end if changed then if value.controller then save(value)end;routesDirty=true;trace(\"routing\",\"route_table_updated\",{from=from})end end local function handleProbe(from,packet)local token=type(packet.body)==\"table\"and packet.body.token if type(token)~=\"string\"or#token<16 or#token>128 then return rejectPacket(\"malformed link probe\",packet)end touchLink(from,nil,\"probe\")return send(from,{type=\"mesh_probe_ack\",body={token=token},request_id=newRequestId()},from)end local function handleProbeAck(from,packet)local health,token=healthFor(from),type(packet.body)==\"table\"and packet.body.token if not health.awaiting or token~=health.probeToken then return rejectPacket(\"unexpected link probe acknowledgement\",packet)end local sample=math.max(0,now()-(health.lastProbe or now()))health.rtt=health.rtt and math.floor((health.rtt*3+sample)/4)or sample health.awaiting,health.misses,health.probeToken=false,0,nil touchLink(from,health.lastDistance,\"probe_ack\")end function M.handle(event)if event[1]~=\"modem_message\"then return end local channel,packet,distance=event[3],event[5],event[6]local expected=false for _,item in ipairs(transport.channels or{})do if channel==item then expected=true;break end end if not expected then return rejectPacket(\"unexpected_channel\",packet,channel,distance)end transport.lastReceive,transport.lastDistance=now(),distance if type(packet)~=\"table\"then return rejectPacket(\"packet_not_table\",packet,channel,distance)end if packet.protocol==PUBLIC_UPDATE_PROTOCOL then if channel~=DISCOVERY_CHANNEL or not PUBLIC_UPDATE_TYPES[packet.type]or type(packet.from)~=\"string\"and type(packet.from)~=\"number\"or not(isForUs(packet.to)or isBroadcast(packet.to))then return rejectPacket(\"invalid_public_update_packet\",packet,channel,distance)end local encoded,encodeErr=canonical(packet.body or{})if not encoded then return rejectPacket(\"invalid_public_update_body:\"..tostring(encodeErr),packet,channel,distance)end trace(\"transport\",\"public_update_received\",{type=packet.type,from=packet.from,distance=distance,bytes=#encoded})if M.publicHandler then return M.publicHandler(packet,distance)end return end local discoveryPacket=packet.type==\"discover\"or packet.type==\"discover_query\"or packet.type==\"discover_cancel\"local handshakePacket=packet.type==\"pair_join\"or packet.type==\"pair_confirm\"or packet.type==\"pair_ack\"or packet.type==\"pair_reject\"local meshPacketType=packet.type==\"mesh_beacon\"or packet.type==\"mesh_edge_offer\"or packet.type==\"mesh_edge_accept\"if discoveryPacket then if packet.protocol~=PROTOCOL or channel~=DISCOVERY_CHANNEL then return rejectPacket(\"invalid_discovery_transport\",packet,channel,distance)end return handleDiscovery(packet,channel,distance)end if handshakePacket then if not isForUs(packet.to)then return end if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid_handshake_transport\",packet,channel,distance)end if packet.type==\"pair_join\"then return handlePairJoin(packet,distance)elseif packet.type==\"pair_confirm\"then return handlePairConfirm(packet,distance)elseif packet.type==\"pair_ack\"then return handlePairAck(packet)elseif packet.type==\"pair_reject\"and discovery then markRejected(\"pairing rejected: \"..tostring(packet.reason or\"remote peer rejected it\"));return end return end if meshPacketType then if packet.protocol~=PROTOCOL or channel~=(config().channel or CHANNEL)then return rejectPacket(\"invalid mesh transport\",packet,channel,distance)end if packet.type~=\"mesh_beacon\"and not isForUs(packet.to)then return end return handleMeshPacket(packet,distance)end if not isForUs(packet.to)then return end local value=config()local valid,peerOrReason=verifyPacket(packet,value)if not valid then return rejectPacket(peerOrReason,packet,channel,distance)end local peer,from=peerOrReason,tostring(packet.from)if packet.confidential==true then local opened,openErr=openBody(peer,packet)if not opened then return rejectPacket(openErr or\"could not open confidential packet\",packet,channel,distance)end packet.body=opened end touchLink(from,distance,\"authenticated_packet\")if autoEdges[from]then autoEdges[from].expires=now()+ROUTE_TTL end trace(\"routing\",\"packet_received\",{type=packet.type,from=from,destination=packet.destination,distance=distance})if packet.type==\"mesh_enroll\"then return acceptEnrollment(from,peer,packet)end if packet.type==\"mesh_probe\"then return handleProbe(from,packet)end if packet.type==\"mesh_probe_ack\"then return handleProbeAck(from,packet)end if packet.type==\"route_advertise\"then return handleRouteAdvertisement(from,packet)end if packet.reply_to and packet.destination and tostring(packet.destination)~=id()then local reverse=reverseRoutes[packet.reply_to]if not reverse or reverse.expires<=now()or reverse.origin~=tostring(packet.destination)then return rejectPacket(\"reverse reply route unavailable\",packet,channel,distance)end local requestId=tostring(packet.request_id or\"\")if seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 trace(\"routing\",\"reverse_reply_forwarded\",{from=from,to=reverse.previous,type=packet.type})return send(packet.destination,packet,reverse.previous)end if packet.destination and tostring(packet.destination)~=id()then local requestId=tostring(packet.request_id or\"\")if requestId==\"\"or seenPackets[requestId]then return trace(\"routing\",\"forward_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end if(tonumber(packet.ttl)or 0)<=1 then return rejectPacket(\"TTL exhausted\",packet,channel,distance)end packet.ttl=packet.ttl-1 return send(packet.destination,packet)end local requestId=tostring(packet.request_id or\"\")if requestId==\"\"then return rejectPacket(\"missing request ID\",packet,channel,distance)end if seenPackets[requestId]then return trace(\"routing\",\"destination_duplicate\",{from=from,type=packet.type})end seenPackets[requestId]=now()local remembered,rememberErr=rememberReverse(packet,from)if not remembered then return rejectPacket(rememberErr or\"could not record reverse route\",packet,channel,distance)end packet.authenticatedHop,packet.originVerified=from,false if M.handler then return M.handler(from,peer,packet)end end return M",
  ["ceetos/lib/network_ipc.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local ROOT=\"/ceetos/data/network-ipc\"local COMMANDS=ROOT..\"/commands\"local RESULTS=ROOT..\"/results\"local function ensure(path)if not fs.exists(path)then fs.makeDir(path)end end local function safeId(value)return type(value)==\"string\"and value:match(\"^[%w_%-%.]+$\")and#value<=160 end local function path(directory,requestId)return fs.combine(directory,requestId..\".lua\")end function M.submit(request)if type(request)~=\"table\"or not safeId(request.id)then return false,\"invalid IPC request ID\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local target=path(COMMANDS,request.id)if fs.exists(target)then return false,\"IPC request already exists\"end return store.write(target,request)end function M.take()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local names=fs.list(COMMANDS)table.sort(names)for _,name in ipairs(names)do local requestId=name:match(\"^([%w_%-%.]+)%.lua$\")if requestId and safeId(requestId)then local target=fs.combine(COMMANDS,name)store.invalidate(target)local request=store.readFresh(target,nil)fs.delete(target)if type(request)==\"table\"and request.id==requestId then return request end end end end function M.reply(requestId,value)if not safeId(requestId)or type(value)~=\"table\"then return false,\"invalid IPC result\"end ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)return store.write(path(RESULTS,requestId),value)end function M.poll(requestId,consume)if not safeId(requestId)then return nil,\"invalid IPC request ID\"end local target=path(RESULTS,requestId)if not fs.exists(target)then return nil end local handle=fs.open(target,\"r\")if not handle then return nil end local raw=handle.readAll()handle.close()local ok,result=pcall(textutils.unserialise,raw)if not ok or type(result)~=\"table\"or result.id~=requestId then return nil,\"invalid IPC result\"end if consume then fs.delete(target)end return result end function M.prune(limit)ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)limit=math.max(1,math.floor(tonumber(limit)or 32))local names={}for _,name in ipairs(fs.list(RESULTS))do if name:match(\"^[%w_%-%.]+%.lua$\")then names[#names+1]=name end end table.sort(names)while#names>limit do fs.delete(fs.combine(RESULTS,table.remove(names,1)))end end function M.status()ensure(ROOT);ensure(COMMANDS);ensure(RESULTS)local function count(directory)local total=0 for _,name in ipairs(fs.list(directory))do if name:match(\"^[%w_%-%.]+%.lua$\")then total=total+1 end end return total end return{commands=count(COMMANDS),results=count(RESULTS)}end return M",
  ["ceetos/lib/auth_client.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local networkIpc=require(\"ceetos.lib.network_ipc\")local M={}local REPLIES=\"/ceetos/data/auth-replies.lua\"local sequence=0 local function now()return os.epoch(\"utc\")end local function authority()store.invalidate(\"/ceetos/data/auth-authority.lua\")local value=store.read(\"/ceetos/data/auth-authority.lua\",nil)return type(value)==\"table\"and value.active==true and value or nil end local function requestId(kind)sequence=sequence+1 return table.concat({\"auth\",kind,tostring(os.getComputerID()),tostring(now()),tostring(sequence)},\"-\")end local function take(id)store.invalidate(REPLIES)local replies=store.read(REPLIES,{})local row=replies[id]if row then replies[id]=nil;store.write(REPLIES,replies)end return row end function M.receive(body)if type(body)~=\"table\"or type(body.request_id)~=\"string\"or#body.request_id>160 then return false,\"invalid authority reply\"end local replies=store.read(REPLIES,{})replies[body.request_id]={ok=body.ok==true,result=body.result,error=body.error,at=now()}local rows={}for id,row in pairs(replies)do rows[#rows+1]={id=id,at=tonumber(row.at)or 0}end table.sort(rows,function(a,b)return a.at>b.at end)while#rows>32 do replies[table.remove(rows).id]=nil end return store.write(REPLIES,replies)end local function send(typeName,body,timeout)local server=authority()if not server then return nil,\"no Auth Server is reachable\"end local id=body.request_id or requestId(typeName)body.request_id=id local command={id=\"auth-\"..id,action=\"auth_send\",target=server.id,type=typeName,body=body}local ok,err=networkIpc.submit(command)if not ok then return nil,err or\"could not reach CeetOS network service\"end local deadline=now()+(timeout or 6000)while now()<deadline do local ack=networkIpc.poll(command.id,true)if ack and ack.ok~=true then return nil,ack.error or\"Auth Server request was not sent\"end local reply=take(id)if reply then return reply.ok and reply.result or nil,reply.error or\"Auth Server rejected request\"end sleep(0.05)end return nil,\"Auth Server did not respond\"end local function loginProof(verifier,server,request,challenge,expires)return password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(server),tostring(os.getComputerID()),tostring(request),tostring(challenge),tostring(expires)},\"|\"))end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.login(name,plainPassword)end local request=requestId(\"begin\")local begin,beginErr=send(\"auth_login_begin\",{request_id=request,username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=loginProof(verifier,begin.authority,request,begin.challenge,begin.expires)local result,proofErr=send(\"auth_login_proof\",{request_id=request,username=name,node=tostring(os.getComputerID()),challenge=begin.challenge,proof=proof})if not result then return false,proofErr end local auth=require((\"ceetos.lib.auth\"))local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require((\"ceetos.lib.auth\"))local cloud=require(\"ceetos.lib.cloud_sync\")if cloud.authOnline()then return cloud.mutate(action,fields)end local current,server=auth.refreshSession(),authority()if not current or not current.central or not server then return false,\"an Auth Server login is required\"end local result,err=send(\"auth_mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end return M",
  ["ceetos/lib/telemetry.lua"] = "local store=require(\"ceetos.lib.store\")local M={}local PATH=\"/ceetos/data/config.lua\"local activity=\"desktop\"local function text(value,limit)if type(value)~=\"string\"then return nil end value=value:gsub(\"[%z\\1-\\31\\127]\",\" \")if value==\"\"then return nil end return value:sub(1,limit)end local function config()local value=store.read(PATH,{})if type(value)~=\"table\"then value={}end if value.telemetry==nil then value.telemetry=true store.write(PATH,value)end return value end function M.setEnabled(value)assert(type(value)==\"boolean\",\"telemetry state must be boolean\")require(\"ceetos.lib.auth\").require(\"admin\")local valueForSave=config()valueForSave.telemetry=value return store.write(PATH,valueForSave)end function M.status()return config().telemetry==true end function M.configuration()return{enabled=M.status()}end function M.markActivity(value)activity=text(value,48)or activity return activity end function M.activity()return activity end function M.snapshot(currentActivity)if currentActivity then M.markActivity(currentActivity)end local data={ts=os.epoch(\"utc\"),id=os.getComputerID(),label=text(os.getComputerLabel(),96),activity=activity,}if turtle and type(turtle.getFuelLevel)==\"function\"then local ok,fuel=pcall(turtle.getFuelLevel)if ok and type(fuel)==\"number\"then data.fuel=fuel end end if gps and type(gps.locate)==\"function\"then local ok,x,y,z=pcall(gps.locate,0.2)if ok and type(x)==\"number\"and type(y)==\"number\"and type(z)==\"number\"then data.gps={x=x,y=y,z=z}end end return data end return M",
  ["ceetos/lib/cloud.lua"] = "local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local M={}M.PATH=\"/ceetos/data/cloud.lua\"M.MAX_BODY=48*1024 M.MAX_RESPONSE=64*1024 M.DEFAULTS={auth=\"https://auth.ceet.uk\",recipe=\"https://recipe.ceet.uk\",dashboard=\"https://dash.ceet.uk\",}local function now()return os.epoch(\"utc\")end local function validUrl(value)if type(value)~=\"string\"or#value>160 then return false end return value:match(\"^https://[%w%-%.]+%.ceet%.uk$\")~=nil end local function validId(value)return type(value)==\"string\"and value:match(\"^[%w_.%-]+$\")~=nil and#value<=96 end local function copy(value)local out={}for key,item in pairs(value or{})do out[key]=item end return out end local function normalise(value)value=type(value)==\"table\"and value or{}local urls=type(value.urls)==\"table\"and value.urls or{}local result={schema=1,enabled=value.enabled==true,urls={auth=validUrl(urls.auth)and urls.auth or M.DEFAULTS.auth,recipe=validUrl(urls.recipe)and urls.recipe or M.DEFAULTS.recipe,dashboard=validUrl(urls.dashboard)and urls.dashboard or M.DEFAULTS.dashboard,},node=type(value.node)==\"table\"and copy(value.node)or nil,}if result.node and(not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 or#result.node.secret>192)then result.node=nil end return result end function M.load()store.invalidate(M.PATH)return normalise(store.read(M.PATH,{}))end function M.save(value)local clean=normalise(value)return store.write(M.PATH,clean)end function M.configure(urls)local value=M.load()urls=type(urls)==\"table\"and urls or{}for key in pairs(M.DEFAULTS)do if urls[key]~=nil then if not validUrl(urls[key])then return false,\"invalid \"..key..\" cloud URL\"end value.urls[key]=urls[key]end end return M.save(value)end function M.clear()local value=M.load();value.enabled,value.node=false,nil return M.save(value)end function M.publicStatus()local value=M.load()return{enabled=value.enabled,enrolled=value.node~=nil,node=value.node and value.node.id or nil,urls=copy(value.urls),profile=profile.id()}end local function readBounded(handle,limit)local chunks,total={},0 while true do local part=handle.read(math.min(4096,limit-total+1))if not part or part==\"\"then break end total=total+#part if total>limit then return nil,\"cloud response is too large\"end chunks[#chunks+1]=part end return table.concat(chunks)end local function json(value)local ok,result=pcall(textutils.unserialiseJSON,value)return ok and type(result)==\"table\"and result or nil end local function canonical(node,timestamp,nonce,method,path,body)local digest=assert(password.sha256(body))return table.concat({\"ceetos-cloud-node-v1\",node,tostring(timestamp),nonce,method,path,digest},\"\\n\")end local nonceCounter=0 local function nonce()nonceCounter=nonceCounter+1 return password.newSalt(\"cloud:\"..tostring(nonceCounter))end local function perform(url,method,path,body,headers)if not http or type(http.post)~=\"function\"then return nil,\"HTTP is unavailable\"end local response local ok,err=pcall(function()response=http.post(url..path,body,headers)end)if not ok or not response then return nil,tostring(err or\"cloud request failed\")end local raw,readErr=readBounded(response,M.MAX_RESPONSE)pcall(response.close)if not raw then return nil,readErr end local decoded=json(raw)if not decoded then return nil,\"cloud returned invalid JSON\"end if decoded.ok==false then return nil,tostring(decoded.error or\"cloud rejected request\"):sub(1,180)end return decoded end function M.enroll(code)if type(code)~=\"string\"or#code<12 or#code>128 or code:find(\"[%z\\1-\\31\\127]\")then return nil,\"invalid enrollment code\"end local value=M.load()local payload=textutils.serialiseJSON({code=code,profile=profile.id(),label=os.getComputerLabel()or(\"Computer \"..tostring(os.getComputerID())),computerId=tostring(os.getComputerID())})if#payload>M.MAX_BODY then return nil,\"enrollment request is too large\"end local result,err=perform(value.urls.auth,\"POST\",\"/v1/nodes/enroll\",payload,{[\"Content-Type\"]=\"application/json\"})if not result then return nil,err end if type(result.node)~=\"table\"or not validId(result.node.id)or type(result.node.secret)~=\"string\"or#result.node.secret<32 then return nil,\"cloud returned invalid enrollment\"end value.enabled,value.node=true,{id=result.node.id,secret=result.node.secret,enrolledAt=now()}local saved,saveErr=M.save(value)if not saved then return nil,saveErr or\"could not save cloud enrollment\"end return M.publicStatus()end function M.call(service,path,payload)local value=M.load()if not value.enabled or not value.node then return nil,\"cloud node is not enrolled\"end if not M.DEFAULTS[service]or type(path)~=\"string\"or not path:match(\"^/v1/[%w%-%._/]+$\")or#path>128 then return nil,\"invalid cloud endpoint\"end local body=textutils.serialiseJSON(type(payload)==\"table\"and payload or{})if#body>M.MAX_BODY then return nil,\"cloud request is too large\"end local timestamp,requestNonce=now(),nonce()local signature=password.hmacSha256(value.node.secret,canonical(value.node.id,timestamp,requestNonce,\"POST\",path,body))if not signature then return nil,\"could not sign cloud request\"end return perform(value.urls[service],\"POST\",path,body,{[\"Content-Type\"]=\"application/json\",[\"X-CeetOS-Node\"]=value.node.id,[\"X-CeetOS-Time\"]=tostring(timestamp),[\"X-CeetOS-Nonce\"]=requestNonce,[\"X-CeetOS-Signature\"]=signature,})end return M",
  ["ceetos/lib/cloud_sync.lua"] = "local cloud=require(\"ceetos.lib.cloud\")local store=require(\"ceetos.lib.store\")local password=require(\"ceetos.lib.password\")local profile=require(\"ceetos.lib.profile\")local telemetryService=require(\"ceetos.lib.telemetry\")local RECIPE_SERVICE_MODULE=\"ceetos.lib.\"..\"recipe_service\"local M={}local STATE=\"/ceetos/data/cloud-state.lua\"local INTERVALS={telemetry=24*60*60*1000,authority=30000,recipes=30000}local TELEMETRY_RETRIES={15*60*1000,60*60*1000,4*60*60*1000}local function now()return os.epoch(\"utc\")end local function defaults()return{schema=2,revision=0,auth={online=false,next=0},recipe={online=false,next=0,revision=0},telemetry={enabled=nil,next=0,lastSuccess=nil,failures=0,lastError=nil},lastError=nil}end local function state()store.invalidate(STATE)local value=store.read(STATE,defaults())if type(value)~=\"table\"then value=defaults()end if type(value.auth)~=\"table\"then value.auth={}end if type(value.recipe)~=\"table\"then value.recipe={}end if type(value.telemetry)~=\"table\"then value.telemetry={}end for key,fallback in pairs(defaults())do if value[key]==nil then value[key]=fallback end end for key,fallback in pairs(defaults().recipe)do if value.recipe[key]==nil then value.recipe[key]=fallback end end for key,fallback in pairs(defaults().telemetry)do if value.telemetry[key]==nil then value.telemetry[key]=fallback end end return value end local function save(value)value.revision=(tonumber(value.revision)or 0)+1 return store.write(STATE,value)end local function errorState(value,message)value.lastError=tostring(message or\"cloud request failed\"):sub(1,180)end function M.status()local value,cfg=state(),cloud.publicStatus()return{enabled=cfg.enabled,enrolled=cfg.enrolled,node=cfg.node,urls=cfg.urls,authOnline=value.auth.online==true,recipeOnline=value.recipe.online==true,telemetryNext=tonumber(value.telemetry and value.telemetry.next)or 0,telemetryInterval=INTERVALS.telemetry,telemetryEnabled=telemetryService.status(),telemetryLastSuccess=value.telemetry and value.telemetry.lastSuccess or nil,telemetryLastError=value.telemetry and value.telemetry.lastError or nil,telemetryFailures=math.max(0,math.floor(tonumber(value.telemetry and value.telemetry.failures)or 0)),lastSync=value.lastSync,lastError=value.lastError,}end function M.configure(urls)return cloud.configure(urls)end function M.enroll(code)local enrolled,err=cloud.enroll(code)if not enrolled then return nil,err end local value=state()value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=0,0,nil save(value)return enrolled end function M.clear()local ok,err=cloud.clear();if ok then store.write(STATE,defaults())end return ok,err end function M.authOnline()return M.status().authOnline==true end function M.recipeOnline()return M.status().recipeOnline==true end local function cloudAuthority(result)local auth=require(\"ceetos.lib.auth\")if type(result)~=\"table\"or type(result.directory)~=\"table\"then return false,\"invalid cloud authority response\"end local cfg=cloud.publicStatus()local record={id=\"cloud:\"..tostring(cfg.urls.auth),term=tonumber(result.term)or 0,revision=tonumber(result.revision)or 0,directory=result.directory}return pcall(auth.acceptAuthority,record)end function M.login(name,plainPassword)if type(name)~=\"string\"or type(plainPassword)~=\"string\"then return false,\"invalid credentials\"end local begin,beginErr=cloud.call(\"auth\",\"/v1/auth/login/begin\",{username=name,node=tostring(os.getComputerID())})if not begin then return false,beginErr end if type(begin.salt)~=\"string\"or type(begin.workFactor)~=\"number\"or type(begin.challenge)~=\"string\"or type(begin.expires)~=\"number\"then return false,\"invalid cloud login challenge\"end local verifier,deriveErr=password.derive(plainPassword,begin.salt,begin.workFactor)if not verifier then return false,deriveErr end local proof=password.hmacSha256(verifier,table.concat({\"ceetos/auth/login/v1\",tostring(begin.authority),tostring(os.getComputerID()),tostring(begin.requestId),tostring(begin.challenge),tostring(begin.expires)},\"|\"))local result,resultErr=cloud.call(\"auth\",\"/v1/auth/login/proof\",{username=name,node=tostring(os.getComputerID()),requestId=begin.requestId,challenge=begin.challenge,proof=proof})if not result then return false,resultErr end local auth=require(\"ceetos.lib.auth\")local saved,saveErr=auth.saveCentralSession(result.session)if not saved then return false,saveErr end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.mutate(action,fields)local auth=require(\"ceetos.lib.auth\")local current=auth.refreshSession()if not current or not current.central then return false,\"cloud login is required\"end local result,err=cloud.call(\"auth\",\"/v1/auth/mutate\",{action=action,fields=fields,session=current.nonce,node=tostring(os.getComputerID()),revision=current.accountRevision})if not result then return false,err end if type(result.directory)==\"table\"then auth.updateDirectory(result.directory,result.revision)end return true end function M.recipePlan(item,quantity,stock)if not M.recipeOnline()then return nil,\"cloud Recipe Server is unavailable\"end local result,err=cloud.call(\"recipe\",\"/v1/recipe/plan\",{item=item,quantity=quantity,stock=stock})if not result then return nil,err end return result.plan,result.error end local function telemetry()local snapshot=telemetryService.snapshot()local net=require(\"ceetos.lib.net\")local transport=net.statusSnapshot and net.statusSnapshot().transport or{}snapshot.health={profile=profile.id(),version=require(\"ceetos.lib.version\").string,uptime=os.clock(),freeSpace=fs.getFreeSpace(\"/\"),peers=#(net.peers and net.peers()or{}),healthyLinks=transport and transport.healthyLinks or 0,lastError=M.status().lastError,}local result,err=cloud.call(\"dashboard\",\"/v1/telemetry/ingest\",snapshot)return result~=nil,err end local function syncAuth()if profile.is(\"auth-server\")then local auth=require(\"ceetos.lib.auth\")local snapshot=auth.authoritySnapshot()local pushed,pushErr=cloud.call(\"auth\",\"/v1/auth/replica/merge\",{snapshot=snapshot,source=\"mesh\"})if not pushed then return false,pushErr end if type(pushed.snapshot)==\"table\"then auth.merge(pushed.snapshot,true)end local ok,authErr=cloudAuthority(pushed)if not ok then return false,authErr end return true end local result,err=cloud.call(\"auth\",\"/v1/auth/directory\",{})if not result then return false,err end local ok,authErr=cloudAuthority(result)if not ok then return false,authErr end return true end local function syncRecipes()if not profile.is(\"recipe-server\")then local result,err=cloud.call(\"recipe\",\"/v1/recipe/status\",{})return result~=nil,err end local service=require(RECIPE_SERVICE_MODULE)if type(service.exportOverlay)~=\"function\"then return false,\"recipe export unavailable\"end local payload,exportErr=service.exportOverlay()if not payload then return false,exportErr end local value=state()value.recipe=value.recipe or{revision=0}local result,err=cloud.call(\"recipe\",\"/v1/recipe/replica/merge\",{overlay=payload,baseRevision=math.max(0,math.floor(tonumber(value.recipe.revision)or 0)),})if not result then return false,err end if type(result.overlay)==\"table\"and type(service.replaceOverlay)==\"function\"then local applied,applyErr=service.replaceOverlay(result.overlay)if not applied then return false,applyErr end end return true,nil,math.max(0,math.floor(tonumber(result.revision)or 0))end function M.tick(activity)local cfg=cloud.publicStatus();if not cfg.enabled or not cfg.enrolled then return false,\"cloud node is not enrolled\"end local value,timestamp=state(),now()local changed=false if timestamp>=(tonumber(value.auth.next)or 0)then local ok,err=syncAuth();value.auth.online,value.auth.next=ok==true,timestamp+INTERVALS.authority if not ok then errorState(value,err)else value.lastError=nil end changed=true end if timestamp>=(tonumber(value.recipe.next)or 0)then local ok,err,recipeRevision=syncRecipes();value.recipe.online,value.recipe.next=ok==true,timestamp+INTERVALS.recipes if recipeRevision~=nil then value.recipe.revision=recipeRevision end if not ok then errorState(value,err)end changed=true end local telemetryEnabled=telemetryService.status()if not telemetryEnabled then if value.telemetry.enabled~=false or value.telemetry.next~=0 then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=false,0,0,nil changed=true end elseif value.telemetry.enabled~=true then value.telemetry.enabled,value.telemetry.next,value.telemetry.failures,value.telemetry.lastError=true,0,0,nil changed=true elseif timestamp>=(tonumber(value.telemetry.next)or 0)then local ok,err=telemetry()if ok then value.telemetry.next,value.telemetry.lastSuccess,value.telemetry.failures,value.telemetry.lastError=timestamp+INTERVALS.telemetry,timestamp,0,nil else local failures=math.max(0,math.floor(tonumber(value.telemetry.failures)or 0))+1 value.telemetry.failures,value.telemetry.lastError=failures,tostring(err or\"telemetry upload failed\"):sub(1,180)value.telemetry.next=timestamp+(TELEMETRY_RETRIES[failures]or INTERVALS.telemetry)errorState(value,value.telemetry.lastError)end changed=true end if changed then value.lastSync=timestamp;save(value)end return true end return M",
  ["ceetos/lib/version.lua"] = "return{major=0,minor=17,patch=0,string=\"0.17.0\"}",
  ["ceetos/lib/crafting.lua"] = "local M={}M.RECIPE_PACK_MAX_BYTES=64*1024 function M.isLocalPeer(peer,computerId)return tostring(peer)==tostring(computerId)end function M.normalise(rows)local out={}for _,row in pairs(type(rows)==\"table\"and rows or{})do if type(row)==\"table\"then local name,count=row.name or row.id,tonumber(row.count or row.amount or row.quantity or 0)or 0 if type(name)==\"string\"and count>0 then out[name]=(out[name]or 0)+math.floor(count)end end end return out end function M.rows(stock,query,filter,recipes)local output,needle,available={},tostring(query or\"\"):lower(),M.normalise(stock)local names={}for name in pairs(available)do names[name]=true end for name in pairs(type(recipes)==\"table\"and recipes or{})do names[name]=true end for name in pairs(names)do local count=available[name]or 0 local craftable=type(recipes)==\"table\"and recipes[name]~=nil local include=needle==\"\"or name:lower():find(needle,1,true)if filter==\"craftable\"then include=include and craftable elseif filter==\"stocked\"then include=include and count>0 end if include then output[#output+1]={name=name,count=count,craftable=craftable,stocked=count>0}end end table.sort(output,function(a,b)return a.name<b.name end)return output end function M.addToCart(cart,name,count)if type(cart)~=\"table\"or type(name)~=\"string\"or name==\"\"then return nil,\"invalid cart item\"end count=tonumber(count)if not count or count<1 then return nil,\"invalid cart quantity\"end count=math.floor(count)for _,row in ipairs(cart)do if row.name==name then row.count=(tonumber(row.count)or 0)+count;return row end end local row={name=name,count=count}cart[#cart+1]=row return row end function M.cartTotals(cart)local items,quantity=0,0 for _,row in ipairs(type(cart)==\"table\"and cart or{})do items=items+1 quantity=quantity+math.max(0,math.floor(tonumber(row.count)or 0))end return items,quantity end function M.acceptedCount(result,requested)local accepted=tonumber(result)requested=tonumber(requested)if not accepted or not requested or requested<1 then return nil,\"invalid request result\"end accepted=math.floor(accepted)if accepted<1 then return nil,\"Stock Ticker accepted no items\"end return math.min(accepted,math.floor(requested))end function M.displayRow(name,count,width)local suffix=\" x\"..tostring(count)width=math.max(#suffix+1,math.floor(tonumber(width)or#suffix+1))if#name+#suffix<=width then return name..suffix end return name:sub(1,math.max(1,width-#suffix-1))..\"…\"..suffix end function M.cancellationStatus(issued)return issued and\"cancelled-unconfirmed\"or\"cancelled\"end local function validReference(name)return type(name)==\"string\"and name:match(\"^#?[%w_.:%-]+$\")~=nil and not name:find(\"##\",1,true)end local function recipeIngredients(recipe,batches)local combined={}local declared=type(recipe.ingredients)==\"table\"and#recipe.ingredients>0 if declared then for _,ingredient in ipairs(recipe.ingredients)do local name=type(ingredient)==\"table\"and ingredient.id or ingredient local count=type(ingredient)==\"table\"and tonumber(ingredient.count or 1)or 1 if validReference(name)then combined[name]=(combined[name]or 0)+batches*math.max(1,math.floor(count or 1))end end else for slot=1,9 do local name=recipe.grid and recipe.grid[slot]if name and name~=false then combined[name]=(combined[name]or 0)+batches end end end local out={}for name,count in pairs(combined)do out[#out+1]={name=name,count=count}end table.sort(out,function(a,b)return a.name<b.name end)return out end function M.recipeInputs(recipe,batches)return recipeIngredients(recipe or{},math.max(1,math.floor(tonumber(batches)or 1)))end function M.validateRecipes(recipes)if type(recipes)~=\"table\"then return nil,\"recipes must return a table\"end for name,recipe in pairs(recipes)do if type(name)~=\"string\"or not name:match(\"^[%w_.:%-]+$\")or type(recipe)~=\"table\"then return nil,\"invalid recipe item id\"end if type(recipe.alternatives)==\"table\"then if#recipe.alternatives<1 then return nil,\"recipe \"..name..\" has no alternatives\"end for _,alternative in ipairs(recipe.alternatives)do local valid,err=M.validateRecipes({[name]=alternative});if not valid then return nil,err end end else if recipe.mode~=\"crafting\"then return nil,\"recipe \"..name..\" must use mode = crafting\"end if type(recipe.address)~=\"string\"or recipe.address==\"\"or#recipe.address>64 then return nil,\"recipe \"..name..\" requires an address\"end local crafter=recipe.address==\"Crafter\"if crafter and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires a 9-slot grid for Crafter\"end if not crafter and type(recipe.ingredients)~=\"table\"and type(recipe.grid)~=\"table\"then return nil,\"recipe \"..name..\" requires ingredients\"end local output=tonumber(recipe.output or 1)if not output or output<1 or output~=math.floor(output)then return nil,\"invalid output for \"..name end for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid grid slot in \"..name end end for _,ingredient in ipairs(type(recipe.ingredients)==\"table\"and recipe.ingredients or{})do local id,count=type(ingredient)==\"table\"and ingredient.id or ingredient,type(ingredient)==\"table\"and ingredient.count or 1 if not validReference(id)or not tonumber(count)or tonumber(count)<1 then return nil,\"invalid ingredient in \"..name end end end end return recipes end local function dataParser(source,maximum)if type(source)~=\"string\"then return nil,\"recipe data must be text\"end if#source==0 or#source>(maximum or M.RECIPE_PACK_MAX_BYTES)then return nil,\"recipe data exceeds the 64 KiB import limit\"end local state={source=source,index=1,length=#source,depth=0,nodes=0}local function skip()while state.index<=state.length do local char=state.source:sub(state.index,state.index)if char:match(\"%s\")then state.index=state.index+1 elseif state.source:sub(state.index,state.index+1)==\"--\"then local ending=state.source:find(\"\\n\",state.index+2,true)state.index=ending and ending+1 or state.length+1 else return true end end return true end local function fail(message)return nil,message..\" near byte \"..tostring(state.index)end local function identifier()local name=state.source:match(\"^[%a_][%w_]*\",state.index)if name then state.index=state.index+#name end return name end local parseValue local function parseString()local quote=state.source:sub(state.index,state.index);state.index=state.index+1 local out={}while state.index<=state.length do local char=state.source:sub(state.index,state.index);state.index=state.index+1 if char==quote then return table.concat(out)end if char==\"\\\\\"then local escaped=state.source:sub(state.index,state.index);state.index=state.index+1 local values={n=\"\\n\",r=\"\\r\",t=\"\\t\",[\"\\\\\"]=\"\\\\\",[\"\\\"\"]=\"\\\"\",[\"'\"]=\"'\"}if not values[escaped]then return fail(\"unsupported string escape\")end out[#out+1]=values[escaped]elseif char:byte()<32 then return fail(\"control character in string\")else out[#out+1]=char end end return fail(\"unterminated string\")end local function parseTable()state.depth=state.depth+1 if state.depth>32 then return fail(\"recipe data is nested too deeply\")end state.index=state.index+1 local out,nextIndex,keys={},1,{}skip()while state.index<=state.length and state.source:sub(state.index,state.index)~=\"}\"do state.nodes=state.nodes+1 if state.nodes>4096 then return fail(\"recipe data has too many values\")end local key,value,err local start=state.index if state.source:sub(state.index,state.index)==\"[\"then state.index=state.index+1;key,err=parseValue();if err then return nil,err end skip();if state.source:sub(state.index,state.index)~=\"]\"then return fail(\"missing closing recipe key bracket\")end state.index=state.index+1;skip();if state.source:sub(state.index,state.index)~=\"=\"then return fail(\"missing recipe key assignment\")end state.index=state.index+1;skip();value,err=parseValue();if err then return nil,err end else local named=identifier();skip()if named and state.source:sub(state.index,state.index)==\"=\"then key,state.index=named,state.index+1;skip();value,err=parseValue();if err then return nil,err end else state.index=start;value,err=parseValue();if err then return nil,err end key,nextIndex=nextIndex,nextIndex+1 end end if type(key)~=\"string\"and type(key)~=\"number\"then return fail(\"recipe table key must be text or a number\")end local signature=type(key)..\":\"..tostring(key)if keys[signature]then return fail(\"duplicate recipe table key\")end keys[signature],out[key]=true,value skip();local separator=state.source:sub(state.index,state.index)if separator==\",\"or separator==\";\"then state.index=state.index+1;skip()elseif separator~=\"}\"then return fail(\"expected recipe table separator\")end end if state.source:sub(state.index,state.index)~=\"}\"then return fail(\"unterminated recipe table\")end state.index,state.depth=state.index+1,state.depth-1 return out end parseValue=function()skip();local char=state.source:sub(state.index,state.index)if char==\"{\"then return parseTable()end if char==\"\\\"\"or char==\"'\"then return parseString()end local number=state.source:match(\"^-?%d+\",state.index)if number then state.index=state.index+#number;return tonumber(number)end local name=identifier()if name==\"true\"then return true elseif name==\"false\"then return false elseif name==\"nil\"then return nil elseif name then return fail(\"bare recipe values are not allowed\")end return fail(\"invalid recipe value\")end skip()if identifier()~=\"return\"then return fail(\"recipe data must start with return\")end local value,err=parseValue();if err then return nil,err end skip();if state.index<=state.length then return fail(\"unexpected content after recipe table\")end return value end local function validTags(tags)if tags==nil then return{}end if type(tags)~=\"table\"then return nil,\"recipe tags must be a table\"end local out={}for tag,members in pairs(tags)do local key=tostring(tag):gsub(\"^#\",\"\")if not key:match(\"^[%w_.:%-]+$\")or type(members)~=\"table\"or#members<1 then return nil,\"invalid recipe tag \"..tostring(tag)end out[key]={}for _,member in ipairs(members)do if not validReference(member)or tostring(member):sub(1,1)==\"#\"then return nil,\"invalid member of #\"..key end out[key][#out[key]+1]=member end table.sort(out[key])end return out end function M.validateRecipeGraph(recipes,tags)local tagMap,tagErr=validTags(tags);if not tagMap then return nil,tagErr end local visiting,complete={},{}local function visit(name)if complete[name]then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=recipes[name]if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end if not recipe then return true end visiting[name]=true for _,input in ipairs(recipeIngredients(recipe,1))do local ingredient=input.name local members=ingredient:sub(1,1)==\"#\"and tagMap[ingredient:sub(2)]or{ingredient}for _,member in ipairs(members or{})do if recipes[member]then local ok,err=visit(member);if not ok then return nil,err end end end end visiting[name],complete[name]=nil,true return true end for name in pairs(recipes)do local ok,err=visit(name);if not ok then return nil,err end end return true end function M.parseRecipeOverlay(source)local value,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not value then return nil,err end if type(value)~=\"table\"then return nil,\"recipe overlay must return a table\"end local recipes,tags if value.schema==1 and type(value.recipes)==\"table\"then recipes,tags=value.recipes,value.tags or{}else recipes,tags=value,{}end local valid,validationErr=M.validateRecipes(recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(tags);if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=recipes,tags=tagMap}end function M.parseRecipeFile(source)local overlay,err=M.parseRecipeOverlay(source)return overlay and overlay.recipes or nil,err end function M.parseRecipePack(source)local pack,err=dataParser(source,M.RECIPE_PACK_MAX_BYTES)if not pack then return nil,err end if type(pack)~=\"table\"or pack.schema~=1 or type(pack.recipes)~=\"table\"then return nil,\"recipe pack must return { schema = 1, recipes = { ... } }\"end local valid,validationErr=M.validateRecipes(pack.recipes)if not valid then return nil,validationErr end local tagMap,tagsErr=validTags(pack.tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(pack.recipes,tagMap)if not graphOk then return nil,graphErr end return{schema=1,recipes=pack.recipes,tags=tagMap}end function M.recipeEqual(left,right)if type(left)~=\"table\"or type(right)~=\"table\"then return false end if type(left.alternatives)==\"table\"then left=left.alternatives[1]end if type(right.alternatives)==\"table\"then right=right.alternatives[1]end if not left or not right or left.mode~=right.mode or left.kind~=right.kind or left.output~=right.output or left.address~=right.address then return false end for slot=1,9 do if left.grid and right.grid and left.grid[slot]~=right.grid[slot]then return false end end local a,b=recipeIngredients(left,1),recipeIngredients(right,1)if#a~=#b then return false end for index=1,#a do if a[index].name~=b[index].name or a[index].count~=b[index].count then return false end end return true end function M.reviewRecipePack(existing,incoming)local validExisting,existingErr=M.validateRecipes(existing)if not validExisting then return nil,existingErr end local validIncoming,incomingErr=M.validateRecipes(incoming)if not validIncoming then return nil,incomingErr end local rows,counts={},{new=0,unchanged=0,conflict=0,invalid=0}for name,recipe in pairs(incoming)do local prior=existing[name]local status=not prior and\"new\"or(M.recipeEqual(prior,recipe)and\"unchanged\"or\"conflict\")counts[status]=counts[status]+1 rows[#rows+1]={name=name,status=status,incoming=recipe,existing=prior,selected=status==\"new\"}end table.sort(rows,function(a,b)return a.name<b.name end)return{rows=rows,counts=counts}end local function cloneRecipe(recipe)if type(recipe)==\"table\"and type(recipe.alternatives)==\"table\"then recipe=recipe.alternatives[1]end local copy={mode=recipe.mode,kind=recipe.kind,output=recipe.output,address=recipe.address,grid={},ingredients={}}for slot=1,9 do copy.grid[slot]=recipe.grid and recipe.grid[slot]end for _,input in ipairs(recipe.ingredients or{})do copy.ingredients[#copy.ingredients+1]={id=input.id,count=input.count,tag=input.tag}end return copy end function M.mergeRecipePack(existing,review,existingTags,incomingTags)if type(existing)~=\"table\"or type(review)~=\"table\"or type(review.rows)~=\"table\"then return nil,\"invalid recipe import review\"end local merged,imported={},0 for name,recipe in pairs(existing)do merged[name]=cloneRecipe(recipe)end for _,row in ipairs(review.rows)do if row.status==\"new\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 elseif row.status==\"conflict\"and row.selected==true then merged[row.name],imported=cloneRecipe(row.incoming),imported+1 end end local tags={}for name,members in pairs(existingTags or{})do tags[name]=members end for name,members in pairs(incomingTags or{})do tags[name]=members end local valid,err=M.validateRecipes(merged);if not valid then return nil,err end local graphOk,graphErr=M.validateRecipeGraph(merged,tags);if not graphOk then return nil,graphErr end return merged,imported,tags end function M.encodeRecipeFile(recipes,tags)local valid,err=M.validateRecipes(recipes);if not valid then return nil,err end local tagMap,tagsErr=validTags(tags or{});if not tagMap then return nil,tagsErr end local graphOk,graphErr=M.validateRecipeGraph(recipes,tagMap);if not graphOk then return nil,graphErr end local ok,encoded=pcall(textutils.serialise,{schema=1,recipes=recipes,tags=tagMap},{compact=true})if not ok or type(encoded)~=\"string\"then return nil,\"could not serialise recipes\"end return\"return \"..encoded..\"\\n\"end function M.writeRecipeFile(path,recipes,tags)if type(path)~=\"string\"or path==\"\"then return false,\"invalid recipe file path\"end local raw,encodeErr=M.encodeRecipeFile(recipes,tags);if not raw then return false,encodeErr end local parent=fs.getDir(path);if parent~=\"\"and not fs.exists(parent)then fs.makeDir(parent)end local temporary,backup=path..\".new\",path..\".bak\"if fs.exists(temporary)then fs.delete(temporary)end local handle=fs.open(temporary,\"w\");if not handle then return false,\"could not stage recipes\"end handle.write(raw);handle.close()local check=fs.open(temporary,\"r\");local staged=check and check.readAll()or nil;if check then check.close()end if not M.parseRecipeOverlay(staged or\"\")then if fs.exists(temporary)then fs.delete(temporary)end;return false,\"could not validate staged recipes\"end if fs.exists(backup)then fs.delete(backup)end if fs.exists(path)then fs.move(path,backup)end local moved,moveErr=pcall(fs.move,temporary,path)if not moved then if fs.exists(backup)and not fs.exists(path)then fs.move(backup,path)end;if fs.exists(temporary)then fs.delete(temporary)end;return false,tostring(moveErr)end if fs.exists(backup)then fs.delete(backup)end return true end local function selectedRecipe(entry)if type(entry)==\"table\"and type(entry.alternatives)==\"table\"then return entry.alternatives[1]end return entry end local function tagMembers(tags,reference)if reference:sub(1,1)~=\"#\"then return{reference}end local members=tags[reference:sub(2)]if type(members)~=\"table\"or#members==0 then return nil,\"no known members for \"..reference end return members end local function chooseMember(reference,tags,available,recipes)local members,err=tagMembers(tags,reference);if not members then return nil,err end local best for _,member in ipairs(members)do if(available[member]or 0)>0 then return member end if recipes[member]and not best then best=member end end return best,best and nil or(\"no stocked or craftable member for \"..reference)end local function requesterGrid(recipe,resolved,tags,available,recipes)local grid={}for slot=1,9 do local value=recipe.grid and recipe.grid[slot]if type(value)==\"string\"and value:sub(1,1)==\"#\"then local concrete=resolved[value]if not concrete then concrete=select(1,chooseMember(value,tags,available,recipes))end if not concrete then return nil,\"no concrete item available for requester tag \"..value end grid[slot]=concrete else grid[slot]=value end end return grid end function M.plan(recipes,stock,item,quantity,options)quantity=tonumber(quantity)if type(item)~=\"string\"or item==\"\"or not quantity or quantity<1 or quantity~=math.floor(quantity)then return nil,\"invalid item or quantity\"end local valid,errorText=M.validateRecipes(recipes)if not valid then return nil,errorText end options=type(options)==\"table\"and options or{}local available,plan,visiting,tags=M.normalise(stock),{},{},type(options.tags)==\"table\"and options.tags or{}local function requireItem(name,needed)local used=options.forceRoot==true and name==item and 0 or math.min(available[name]or 0,needed)available[name]=(available[name]or 0)-used local missing=needed-used if missing<=0 then return true end if visiting[name]then return nil,\"recipe cycle at \"..name end local recipe=selectedRecipe(recipes[name])if not recipe then return nil,\"missing recipe for \"..name..\" (need \"..tostring(missing)..\")\"end if recipe.special or not recipe.output or not recipe.address then return nil,\"recipe \"..name..\" is not supported by Crafting Queue\"end visiting[name]=true local batches=math.ceil(missing/recipe.output)local inputs,resolved={},{}for _,ingredient in ipairs(recipeIngredients(recipe,batches))do local concrete,resolveErr=chooseMember(ingredient.name,tags,available,recipes)if not concrete then return nil,resolveErr end inputs[#inputs+1]={name=concrete,count=ingredient.count,source=ingredient.name,tag=ingredient.name:sub(1,1)==\"#\"and ingredient.name or nil}if ingredient.name:sub(1,1)==\"#\"then resolved[ingredient.name]=concrete end local ok,err=requireItem(concrete,ingredient.count)if not ok then return nil,err end end visiting[name]=nil local produced=batches*recipe.output available[name]=(available[name]or 0)+produced-missing local dispatch=recipe.address==\"Crafter\"and\"requester\"or\"package\"if dispatch==\"requester\"and type(recipe.grid)~=\"table\"then return nil,\"Crafter recipe \"..name..\" has no 3x3 grid\"end local grid,gridErr=recipe.grid,nil if dispatch==\"requester\"then grid,gridErr=requesterGrid(recipe,resolved,tags,available,recipes)if not grid then return nil,gridErr end end plan[#plan+1]={name=name,batches=batches,produced=produced,requested=missing,address=recipe.address,kind=recipe.kind,dispatch=dispatch,grid=grid,sourceGrid=recipe.grid,inputs=inputs,}return true end local ok,err=requireItem(item,quantity)return ok and plan or nil,err end function M.validateExecutionPlan(plan)if type(plan)~=\"table\"or#plan<1 or#plan>96 then return nil,\"invalid remote recipe plan\"end for _,step in ipairs(plan)do if type(step)~=\"table\"or not validReference(step.name)or tostring(step.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe output\"end if type(step.address)~=\"string\"or step.address==\"\"or#step.address>64 or step.address:find(\"[%c]\")then return nil,\"invalid remote recipe address\"end if step.dispatch~=\"requester\"and step.dispatch~=\"package\"then return nil,\"invalid remote recipe route\"end if(step.address==\"Crafter\")~=(step.dispatch==\"requester\")then return nil,\"invalid remote recipe executor\"end for _,field in ipairs({\"batches\",\"produced\",\"requested\"})do local value=tonumber(step[field])if not value or value<1 or value~=math.floor(value)or value>65536 then return nil,\"invalid remote recipe quantity\"end end if step.dispatch==\"requester\"then if type(step.grid)~=\"table\"then return nil,\"remote Crafter recipe has no grid\"end for slot=1,9 do local value=step.grid[slot]if value~=nil and value~=false and not validReference(value)then return nil,\"invalid remote recipe grid\"end if type(value)==\"string\"and value:sub(1,1)==\"#\"then return nil,\"remote requester grid contains unresolved tag\"end end end if type(step.inputs)~=\"table\"or#step.inputs>64 then return nil,\"invalid remote recipe inputs\"end for _,input in ipairs(step.inputs)do if type(input)~=\"table\"or not validReference(input.name)or tostring(input.name):sub(1,1)==\"#\"then return nil,\"invalid remote recipe input\"end local count=tonumber(input.count)if not count or count<1 or count~=math.floor(count)or count>65536 then return nil,\"invalid remote recipe input quantity\"end if input.source~=nil and not validReference(input.source)then return nil,\"invalid remote recipe input source\"end end end return plan end return M",
  ["ceetos/server.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local net=require(\"ceetos.lib.net\")local audit=require(\"ceetos.lib.audit\")local updater=require(\"ceetos.lib.updater\")local networkIpc=require(\"ceetos.lib.network_ipc\")local version=require(\"ceetos.lib.version\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local authority=profile.is(\"auth-server\")and require((\"ceetos.lib.auth_authority\"))or nil local authClient=require(\"ceetos.lib.auth_client\")local cloudSync=require(\"ceetos.lib.cloud_sync\")local releaseBroker=require(\"ceetos.lib.release_broker\")local function replyIpc(command,ok,result)networkIpc.reply(command.id,{id=command.id,ok=ok==true,result=ok and result or nil,error=ok and nil or tostring(result)})end local function command()local request=networkIpc.take()if not request then return end local ok,result=pcall(function()if request.action==\"server_status\"then return{profile=profile.id(),version=version.string,network=net.statusSnapshot(),authority=authority and authority.status()or auth.authority(),recipes=recipe and recipe.status()or nil}elseif request.action==\"server_discovery_start\"then auth.require(\"admin\");return net.startDiscovery(request.mode or\"peer\",request.master or\"initiator\",request.phrase)elseif request.action==\"server_discovery_join\"then auth.require(\"admin\");return net.joinDiscovery(request.phrase)elseif request.action==\"server_discovery_confirm\"then auth.require(\"admin\");return net.confirmDiscovery()elseif request.action==\"server_update_status\"then return updater.status()elseif request.action==\"server_update_apply\"then auth.require(\"admin\");return updater.prepareApply()elseif request.action==\"broker_status\"then auth.require(\"operator\");return releaseBroker.status()elseif request.action==\"broker_promote\"then auth.require(\"admin\");return releaseBroker.promote(request.ownerKey)elseif request.action==\"broker_revoke\"then auth.require(\"admin\");return releaseBroker.revoke(request.ownerKey)elseif request.action==\"broker_approve\"then auth.require(\"admin\");return releaseBroker.approve(request.session,request.phrase)elseif request.action==\"auth_send\"then local sent,err=net.request(request.target,request.type,request.body or{},{safe=true,confidential=true})if not sent then error(err or\"could not contact Auth Server\")end return true end error(\"unknown protected server command\")end)replyIpc(request,ok and result~=false,ok and result or result)end net.handler=function(from,peer,packet)if packet.type==\"update_query\"or packet.type==\"update_offer\"or packet.type==\"update_chunk_request\"or packet.type==\"update_chunk\"then return updater.authenticatedPacket(from,peer,packet)end if packet.type==\"profile_query\"then return net.reply(packet,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end if packet.type==\"recipe_plan_request\"and recipe then return recipe.handle(packet,net)end if packet.type==\"auth_login_begin_result\"or packet.type==\"auth_login_proof_result\"or packet.type==\"auth_mutate_result\"then return authClient.receive(packet.body)end if packet.type==\"auth_seed_request\"then return net.reply(packet,\"auth_seed\",{snapshot=auth.authoritySnapshot(),request_id=packet.body and packet.body.request_id},{safe=true,confidential=true})end if packet.type==\"auth_authority\"then return auth.acceptAuthority(packet.body)end if authority then return authority.handle(from,peer,packet,net)end end net.publicHandler=function(packet,distance)if tostring(packet.type or\"\"):match(\"^broker_\")then return releaseBroker.handle(packet,distance)end return updater.publicPacket(packet,distance)end local function service()net.start()if authority then authority.start()end local tick,update,cloud,advertised=os.startTimer(1),os.startTimer(1),os.startTimer(5),0 while true do local event={os.pullEventRaw()}local ok,err=pcall(net.handle,event)if not ok then audit.log(\"server\",\"network.error\",{error=tostring(err):sub(1,120)})end pcall(command)if event[1]==\"timer\"and event[2]==tick then pcall(net.tick);pcall(releaseBroker.tick);if authority then pcall(authority.tick,net)end if os.epoch(\"utc\")-advertised>=30000 then for _,peer in ipairs(net.peers())do net.request(peer.id,\"profile_status\",{profile=profile.id(),version=version.string},{safe=true})end advertised=os.epoch(\"utc\")end tick=os.startTimer(1)end if event[1]==\"timer\"and event[2]==update then pcall(updater.tick);update=os.startTimer(1)end if event[1]==\"timer\"and event[2]==cloud then pcall(cloudSync.tick);cloud=os.startTimer(5)end end end local function console()shell.run(\"/ceetos/bin/ceetserver.lua\")while true do sleep(1);shell.run(\"/ceetos/bin/ceetserver.lua\")end end local function devBridge()local path=\"/ceetos-dev/connection.lua\"while true do if fs.exists(\"/ceetos/bin/ceetdev.lua\")and fs.exists(path)then local handle=fs.open(path,\"r\")local cfg=handle and textutils.unserialise(handle.readAll())or nil if handle then handle.close()end if type(cfg)==\"table\"and type(cfg.url)==\"string\"then local token=type(cfg.token)==\"string\"and cfg.token or\"\"if token~=\"\"then pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url,token)else pcall(shell.run,\"/ceetos/bin/ceetdev.lua\",cfg.url)end sleep(3)else sleep(5)end else sleep(5)end end end parallel.waitForAny(service,console,devBridge)",
  ["ceetos/bin/ceetserver.lua"] = "package.path=\"/?.lua;/?/init.lua;\"..package.path local profile=require(\"ceetos.lib.profile\")local auth=require(\"ceetos.lib.auth\")local version=require(\"ceetos.lib.version\")local store=require(\"ceetos.lib.store\")local recipe=profile.is(\"recipe-server\")and require((\"ceetos.lib.recipe_service\"))or nil local function draw(message)term.setBackgroundColor(colors.black);term.setTextColor(colors.white);term.clear();term.setCursorPos(1,1)term.setBackgroundColor(colors.blue);term.clearLine();term.setCursorPos(2,1);term.write(\"CeetOS \"..profile.id()..\" server\")term.setBackgroundColor(colors.black);term.setCursorPos(2,3);term.write(\"Version: \"..version.string)local authority=auth.authority()term.setCursorPos(2,4);term.write(authority and(\"Auth authority: \"..authority.id)or\"Auth authority: distributed / waiting\")local current=auth.refreshSession()term.setCursorPos(2,6);term.write(current and(\"Signed in: \"..current.name..\" (\"..current.role..\")\")or\"Not signed in\")term.setTextColor(colors.lightGray);term.setCursorPos(2,8)if not current then term.write(\"L Login  |  E first-time enrolment  |  Backspace refresh\")elseif current.role==\"admin\"then local actions=recipe and\"I import pack  |  P pair  |  U updates  |  B broker\"or\"P pair  |  U updates  |  B broker\"term.write(actions..\"  |  L logout  |  Backspace refresh\")else term.write(\"L logout  |  Backspace refresh\")end if message then term.setTextColor(colors.red);term.setCursorPos(2,10);term.write(tostring(message):sub(1,48))end end local function login()term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Username: \");local user=read()term.setCursorPos(2,13);term.write(\"Password: \");local pass=read(\"*\")local ok,err=auth.login(user,pass);return ok and\"Logged in.\"or err end local function enrol()if#auth.list()>0 or auth.centralActive()then return\"Enrollment is already complete.\"end term.setCursorPos(2,12);term.setTextColor(colors.white);term.write(\"Create local admin password: \")local pass=read(\"*\")if type(pass)~=\"string\"or#pass<8 then return\"Enrollment password must contain at least 8 characters.\"end local ok,err=pcall(auth.bootstrap,pass)return ok and\"Enrollment complete.\"or err end local function importRecipePack(event)if not recipe then return\"This server has no recipe service.\"end if not auth.allowed(\"admin\")then return\"Recipe import requires an admin session.\"end local files=event and event.getFiles and event.getFiles()or nil if type(files)~=\"table\"or#files~=1 or type(files[1].read)~=\"function\"then return\"Drop exactly one data-only recipe pack.\"end local chunks,total={},0 while true do local part=files[1].read(4096)if not part then break end if type(part)~=\"string\"then return\"Dropped recipe pack has invalid data.\"end total=total+#part if total>64*1024 then return\"Recipe pack exceeds 64 KiB.\"end chunks[#chunks+1]=part end local ok,result=recipe.import(table.concat(chunks))if not ok then return tostring(result)end return\"Imported \"..tostring(result.imported or 0)..\" new recipes; conflicts kept.\"end local message while true do draw(message);message=nil local event,code=os.pullEventRaw()if event==\"key\"then local key=keys.getName(code)if key==\"l\"then if auth.refreshSession()then auth.logout();message=\"Logged out.\"else message=login()end elseif key==\"e\"then message=enrol()elseif key==\"backspace\"then elseif key==\"p\"and auth.allowed(\"admin\")then message=\"Use the Peers page on a desktop to pair; server pairing IPC is available to administrators.\"elseif key==\"u\"and auth.allowed(\"admin\")then message=\"Use nx update latest or the desktop Updates page; apply remains local.\"elseif key==\"b\"and auth.allowed(\"admin\")then message=\"Use nx broker status|enable <owner-key>|approve <session> <phrase>.\"elseif key==\"i\"and recipe and auth.allowed(\"admin\")then message=\"Drop one recipe pack into this console.\"end elseif event==\"file_transfer\"then message=importRecipePack(code)end end",
}
local CEETOS_RELEASE_INSTALLER = true
local CEETOS_PROFILE = "router-server"

-- `wget --install` may run inside a deliberately restricted CeetShell child
-- environment. Self-cleaning is optional there: never require the shell API
-- merely to install the runtime.
local args = { ... }
local automated = args[1] == "--ceetos-apply"
local self = shell and shell.getRunningProgram and shell.getRunningProgram()
local cache = "/ceetos-updates/release.lua"
-- A signed release launched directly is retained outside the replaceable
-- runtime tree for verified recovery. Development installers deliberately do
-- not become propagation sources. Do this before removing the downloaded
-- program itself, but avoid copying the cache onto itself during recovery.
if CEETOS_RELEASE_INSTALLER and not automated and self and fs.exists(self) and self ~= cache then
  if not fs.exists("/ceetos-updates") then fs.makeDir("/ceetos-updates") end
  if fs.exists(cache) then fs.delete(cache) end
  pcall(fs.copy, self, cache)
end
if self and self ~= cache and fs.exists(self) then pcall(fs.delete, self) end

local bytes = 0
for _, contents in pairs(files) do bytes = bytes + #contents end
print("CeetOS " .. CEETOS_PROFILE .. " installer (" .. bytes .. " bytes)")
if not automated then
  print("This will replace /ceetos and /startup.lua. Continue? [y/N]")
  if read():lower() ~= "y" then print("Cancelled."); return end
end

local backup, migrate, migrationData = nil, false, {}
-- Public signed installers intentionally do not create an enrolled Cloud node
-- by themselves. A completely fresh computer must obtain its one-use node
-- credential from a nearby, explicitly promoted broker before any runtime is
-- replaced. The tiny temporary module tree is removed on every outcome.
if CEETOS_RELEASE_INSTALLER and not automated and not fs.exists("ceetos") then
  local temporary = "/ceetos-bootstrap"
  if fs.exists(temporary) then fs.delete(temporary) end
  fs.makeDir(temporary); fs.makeDir(temporary .. "/ceetos"); fs.makeDir(temporary .. "/ceetos/lib")
  for _, path in ipairs({ "ceetos/lib/password.lua", "ceetos/lib/mesh_crypto.lua", "ceetos/lib/broker_bootstrap.lua" }) do
    local contents = files[path]
    if not contents then fs.delete(temporary); error("installer is missing bootstrap dependency " .. path, 0) end
    local handle = assert(fs.open(temporary .. "/" .. path, "w")); handle.write(contents); handle.close()
  end
  local oldPath = package.path
  package.path = temporary .. "/?.lua;" .. temporary .. "/?/init.lua;" .. package.path
  local loaded, bootstrap = pcall(require, "ceetos.lib.broker_bootstrap")
  local grant, bootstrapErr
  if loaded then grant, bootstrapErr = bootstrap.enroll(CEETOS_PROFILE) else bootstrapErr = bootstrap end
  package.loaded["ceetos.lib.broker_bootstrap"], package.loaded["ceetos.lib.mesh_crypto"], package.loaded["ceetos.lib.password"] = nil, nil, nil
  package.path = oldPath
  if fs.exists(temporary) then fs.delete(temporary) end
  if not grant then printError(tostring(bootstrapErr or "trusted broker enrollment failed")); return end
  migrationData["cloud.lua"] = textutils.serialize({ schema = 1, enabled = true, urls = grant.urls, node = grant.node })
  migrate = true
  print("Trusted broker enrollment received. Installing signed release...")
end
-- Clean stale full-tree backups from older installers before measuring space.
for _, name in ipairs(fs.list(".")) do
  if name:match("^ceetos%.backup") or name == "ceetos-migrate" then fs.delete(name) end
end
-- Development transactions can be much larger than the runtime. Preserve
-- only the reconnect record; staged payloads, test data, and rollback trees
-- are disposable and must not prevent an install from starting.
for _, name in ipairs({ "staging", "backups", "test-data" }) do
  local path = fs.combine("ceetos-dev", name)
  if fs.exists(path) then fs.delete(path) end
end
if fs.exists("ceetos") then
  if automated then migrate = true else
    print("Migrate saved CeetOS configuration? [Y/n]")
    local choice = read():lower()
    migrate = choice ~= "n" and choice ~= "no"
  end
  -- Copy only durable configuration to a small migration area, then remove
  -- the old tree before writing the new one. This works on nearly-full CC
  -- drives where retaining a complete backup would make installation fail.
  if migrate then
    local durable = { "users.lua", "network.lua", "shares.lua", "config.lua", "owner-service.lua", "seen-peers.lua", "jobs.lua", "job-workers.lua", "crafting-state.lua", "auth-authority.lua", "auth-authority-state.lua", "auth-directory.lua", "auth-session.lua", "cloud.lua", "cloud-state.lua" }
    if CEETOS_PROFILE == "recipe-server" then durable[#durable + 1] = "recipes.lua" end
    for _, name in ipairs(durable) do
      local source = fs.combine("ceetos/data", name)
      if fs.exists(source) then
        local input = fs.open(source, "r")
        if input then migrationData[name] = input.readAll(); input.close() end
      end
    end
  end
  fs.delete("ceetos")
end

for path, contents in pairs(files) do
  local parent = fs.getDir(path)
  if parent ~= "" and not fs.exists(parent) then fs.makeDir(parent) end
  local handle = assert(fs.open(path, "w"))
  handle.write(contents)
  handle.close()
end

if migrate then
  -- Preserve durable configuration, but never preserve an active session,
  -- temporary recovery window, remote result cache, or stale audit entries.
  local durable = { "users.lua", "network.lua", "shares.lua", "config.lua", "owner-service.lua", "seen-peers.lua", "jobs.lua", "job-workers.lua", "crafting-state.lua", "auth-authority.lua", "auth-authority-state.lua", "auth-directory.lua", "auth-session.lua", "cloud.lua", "cloud-state.lua" }
  if CEETOS_PROFILE == "recipe-server" then durable[#durable + 1] = "recipes.lua" end
  for _, name in ipairs(durable) do
    local contents = migrationData[name]
    if contents then
      if not fs.exists("ceetos/data") then fs.makeDir("ceetos/data") end
      local output = assert(fs.open(fs.combine("ceetos/data", name), "w"))
      output.write(contents); output.close()
    end
  end
  print("Saved CeetOS configuration migrated. Please log in again.")
end

-- The installer is intentionally transactional while it runs, but retaining
-- a full tree backup after a successful install quickly exhausts small CC
-- drives. Durable data has already been copied, so remove the old tree.
if automated then
  -- The root startup launcher sees this marker and boots the freshly written
  -- runtime rather than replaying the installer. The runtime verifies its
  -- loaded version before clearing it.
  if not fs.exists("/ceetos-updates") then fs.makeDir("/ceetos-updates") end
  local marker = fs.open("/ceetos-updates/pending.lua", "w")
  if marker then marker.write("return {state='verify',version=" .. "0.17.0" .. ",profile=" .. "\"router-server\"" .. "}"); marker.close() end
  print("CeetOS installed. Rebooting to verify the update.")
  os.reboot()
end
print("CeetOS installed. Reboot to start it.")

-- CEETOS_RELEASE_PAYLOAD_END