MBS as default shell

1 files changed, 702 insertions, 0 deletions

diff --git a/.mbs/bin/shell.lua b/.mbs/bin/shell.lua
new file mode 100644
index 0000000..6dd7d9c
--- /dev/null
+++ b/.mbs/bin/shell.lua
@@ -0,0 +1,702 @@
+
+local multishell = multishell
+local parentShell = shell
+
+if multishell then
+  multishell.setTitle(multishell.getCurrent(), "shell")
+end
+
+local bExit = false
+local sDir = (parentShell and parentShell.dir()) or ""
+local sPath = (parentShell and parentShell.path()) or ".:/rom/programs"
+local tAliases = (parentShell and parentShell.aliases()) or {}
+local tCompletionInfo = (parentShell and parentShell.getCompletionInfo()) or {}
+local tProgramStack = {}
+local history = parentShell and type(parentShell.history) == "function" and parentShell.history()
+local fWrapper = nil
+
+local shell = {}
+local function createShellEnv(sDir)
+  local tEnv = {}
+  tEnv["shell"] = shell
+  tEnv["multishell"] = multishell
+
+  if fWrapper then
+    if read then tEnv.read = fWrapper(read) end
+    if readline and readline.read then tEnv.readline = { read = fWrapper(readline.read) } end
+  end
+
+  local package = {}
+  package.loaded = {
+    _G = _G,
+    bit32 = bit32,
+    coroutine = coroutine,
+    math = math,
+    package = package,
+    string = string,
+    table = table,
+  }
+  package.path = settings.get('mbs.shell.require_path') or
+    "?;?.lua;?/init.lua;/rom/modules/main/?;/rom/modules/main/?.lua;/rom/modules/main/?/init.lua"
+  if turtle then
+    package.path = package.path..";/rom/modules/turtle/?;/rom/modules/turtle/?.lua;/rom/modules/turtle/?/init.lua"
+  elseif command then
+    package.path = package.path..";/rom/modules/command/?;/rom/modules/command/?.lua;/rom/modules/command/?/init.lua"
+  end
+  package.config = "/\n;\n?\n!\n-"
+  package.preload = {}
+  package.loaders = {
+    function(name)
+      if package.preload[name] then
+        return package.preload[name]
+      else
+        return nil, "no field package.preload['" .. name .. "']"
+      end
+    end,
+    function(name)
+      local fname = string.gsub(name, "%.", "/")
+      local sError = ""
+      for pattern in string.gmatch(package.path, "[^;]+") do
+        local sPath = string.gsub(pattern, "%?", fname)
+        if sPath:sub(1,1) ~= "/" then
+          sPath = fs.combine(sDir, sPath)
+        end
+        if fs.exists(sPath) and not fs.isDir(sPath) then
+          local fnFile, sError = loadfile(sPath, tEnv)
+          if fnFile then
+            return fnFile, sPath
+          else
+            return nil, sError
+          end
+        else
+          if #sError > 0 then
+            sError = sError .. "\n  "
+          end
+          sError = sError .. "no file '" .. sPath .. "'"
+        end
+      end
+      return nil, sError
+    end
+  }
+
+  local sentinel = {}
+  local function require(name)
+    if type(name) ~= "string" then
+      error("bad argument #1 (expected string, got " .. type(name) .. ")", 2)
+    end
+    if package.loaded[name] == sentinel then
+      error("loop or previous error loading module '" .. name .. "'", 0)
+    end
+    if package.loaded[name] then
+      return package.loaded[name]
+    end
+
+    local sError = "module '" .. name .. "' not found:"
+    for _, searcher in ipairs(package.loaders) do
+      local loader = table.pack(searcher(name))
+      if loader[1] then
+        package.loaded[name] = sentinel
+        local result = loader[1](name, table.unpack(loader, 2, loader.n))
+        if result == nil then result = true end
+
+        package.loaded[name] = result
+        return result
+      else
+        sError = sError .. "\n  " .. loader[2]
+      end
+    end
+    error(sError, 2)
+  end
+
+  tEnv["package"] = package
+  tEnv["require"] = require
+
+  return tEnv
+end
+
+-- Colours
+local promptColour, textColour, bgColour
+if term.isColour() then
+  promptColour = colours.yellow
+  textColour = colours.white
+  bgColour = colours.black
+else
+  promptColour = colours.white
+  textColour = colours.white
+  bgColour = colours.black
+end
+
+local function run(_sCommand, ...)
+  local sPath = shell.resolveProgram(_sCommand)
+  if sPath ~= nil then
+    tProgramStack[#tProgramStack + 1] = sPath
+    if multishell then
+      local sTitle = fs.getName(sPath)
+      if sTitle:sub(-4) == ".lua" then
+        sTitle = sTitle:sub(1,-5)
+      end
+      multishell.setTitle(multishell.getCurrent(), sTitle)
+    end
+    local sDir = fs.getDir(sPath)
+    local tEnv = setmetatable(createShellEnv(sDir), { __index = _G })
+
+    if settings.get("mbs.shell.strict_globals", false)  then
+      -- load (in bios.lua) will attempt to set _ENV on our environment, which
+      -- throws an error with this protection enabled. Thus we set it here first.
+      tEnv._ENV = tEnv
+      getmetatable(tEnv).__newindex = function(_, name)
+        error("Attempt to create global " .. tostring(name) .. "\n If this is intended then you probably want to use _G." .. tostring(name), 2)
+      end
+    end
+
+    local ok
+    local fnFile, err = loadfile(sPath, tEnv)
+    if fnFile then
+      if settings.get("mbs.shell.traceback", true) then
+        local tArgs = table.pack(...)
+        ok, err = stack_trace.xpcall_with(function() return fnFile(table.unpack(tArgs, 1, tArgs.n)) end)
+      else
+        ok, err = pcall(fnFile, ...)
+      end
+
+      if not ok then
+        ok = false
+        if err and err ~= "" then printError(err) end
+      end
+    else
+      ok = false
+      if err and err ~= "" then printError(err) end
+    end
+
+    tProgramStack[#tProgramStack] = nil
+    if multishell then
+      if #tProgramStack > 0 then
+        local sTitle = fs.getName(tProgramStack[#tProgramStack])
+        if sTitle:sub(-4) == ".lua" then
+          sTitle = sTitle:sub(1,-5)
+        end
+        multishell.setTitle(multishell.getCurrent(), sTitle)
+      else
+        multishell.setTitle(multishell.getCurrent(), "shell")
+      end
+    end
+    return ok
+  else
+    printError("No such program")
+    return false
+  end
+end
+
+local function tokenise(...)
+  local sLine = table.concat({ ... }, " ")
+  local tWords = {}
+  local bQuoted = false
+  for match in string.gmatch(sLine .. "\"", "(.-)\"") do
+    if bQuoted then
+      table.insert(tWords, match)
+    else
+      for m in string.gmatch(match, "[^ \t]+") do
+        table.insert(tWords, m)
+      end
+    end
+    bQuoted = not bQuoted
+  end
+  return tWords
+end
+
+-- Install shell API
+function shell.run(...)
+  local tWords = tokenise(...)
+  local sCommand = tWords[1]
+  if sCommand then
+    return run(sCommand, table.unpack(tWords, 2))
+  end
+  return false
+end
+
+function shell.exit()
+  bExit = true
+end
+
+function shell.dir()
+  return sDir
+end
+
+function shell.setDir(_sDir)
+  if type(_sDir) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sDir) .. ")", 2)
+  end
+  if not fs.isDir(_sDir) then
+    error("Not a directory", 2)
+  end
+  sDir = _sDir
+end
+
+function shell.path()
+  return sPath
+end
+
+function shell.setPath(_sPath)
+  if type(_sPath) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sPath) .. ")", 2)
+  end
+  sPath = _sPath
+end
+
+function shell.resolve(_sPath)
+  if type(_sPath) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sPath) .. ")", 2)
+  end
+  local sStartChar = string.sub(_sPath, 1, 1)
+  if sStartChar == "/" or sStartChar == "\\" then
+    return fs.combine("", _sPath)
+  else
+    return fs.combine(sDir, _sPath)
+  end
+end
+
+local function pathWithExtension(_sPath, _sExt)
+  local nLen = #sPath
+  local sEndChar = string.sub(_sPath, nLen, nLen)
+  -- Remove any trailing slashes so we can add an extension to the path safely
+  if sEndChar == "/" or sEndChar == "\\" then
+    _sPath = string.sub(_sPath, 1, nLen - 1)
+  end
+  return _sPath .. "." .. _sExt
+end
+
+function shell.resolveProgram(_sCommand)
+  if type(_sCommand) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sCommand) .. ")", 2)
+  end
+  -- Substitute aliases firsts
+  if tAliases[_sCommand] ~= nil then
+    _sCommand = tAliases[_sCommand]
+  end
+
+  -- If the path is a global path, use it directly
+  local sStartChar = string.sub(_sCommand, 1, 1)
+  if _sCommand:find("/") or _sCommand:find("\\") then
+    local sPath = shell.resolve(_sCommand)
+    if fs.exists(sPath) and not fs.isDir(sPath) then
+      return sPath
+    else
+      local sPathLua = pathWithExtension(sPath, "lua")
+      if fs.exists(sPathLua) and not fs.isDir(sPathLua) then
+        return sPathLua
+      end
+    end
+    return nil
+  end
+
+  -- Otherwise, look on the path variable
+  for sPath in string.gmatch(sPath, "[^:]+") do
+    sPath = fs.combine(shell.resolve(sPath), _sCommand)
+    if fs.exists(sPath) and not fs.isDir(sPath) then
+      return sPath
+    else
+      local sPathLua = pathWithExtension(sPath, "lua")
+      if fs.exists(sPathLua) and not fs.isDir(sPathLua) then
+        return sPathLua
+      end
+    end
+  end
+
+  -- Not found
+  return nil
+end
+
+function shell.programs(_bIncludeHidden)
+  local tItems = {}
+
+  -- Add programs from the path
+  for sPath in string.gmatch(sPath, "[^:]+") do
+    sPath = shell.resolve(sPath)
+    if fs.isDir(sPath) then
+      local tList = fs.list(sPath)
+      for n=1,#tList do
+        local sFile = tList[n]
+        if not fs.isDir(fs.combine(sPath, sFile)) and
+        (_bIncludeHidden or string.sub(sFile, 1, 1) ~= ".") then
+          if #sFile > 4 and sFile:sub(-4) == ".lua" then
+            sFile = sFile:sub(1,-5)
+          end
+          tItems[sFile] = true
+        end
+      end
+    end
+  end
+
+  -- Sort and return
+  local tItemList = {}
+  for sItem in pairs(tItems) do
+    table.insert(tItemList, sItem)
+  end
+  table.sort(tItemList)
+  return tItemList
+end
+
+local function completeProgram(sLine)
+  if #sLine > 0 and (sLine:find("/") or sLine:find("\\")) then
+    -- Add programs from the root
+    return fs.complete(sLine, sDir, true, false)
+
+  else
+    local tResults = {}
+    local tSeen = {}
+
+    -- Add aliases
+    for sAlias in pairs(tAliases) do
+      if #sAlias > #sLine and string.sub(sAlias, 1, #sLine) == sLine then
+        local sResult = string.sub(sAlias, #sLine + 1)
+        if not tSeen[sResult] then
+          table.insert(tResults, sResult)
+          tSeen[sResult] = true
+        end
+      end
+    end
+
+    -- Add all subdirectories. We don't include files as they will be added in the block below
+    local tDirs = fs.complete(sLine, sDir, false, false)
+    for i = 1, #tDirs do
+      local sResult = tDirs[i]
+      if not tSeen[sResult] then
+        table.insert(tResults, sResult)
+        tSeen[sResult] = true
+      end
+    end
+
+    -- Add programs from the path
+    local tPrograms = shell.programs()
+    for n=1,#tPrograms do
+      local sProgram = tPrograms[n]
+      if #sProgram > #sLine and string.sub(sProgram, 1, #sLine) == sLine then
+        local sResult = string.sub(sProgram, #sLine + 1)
+        if not tSeen[sResult] then
+          table.insert(tResults, sResult)
+          tSeen[sResult] = true
+        end
+      end
+    end
+
+    -- Sort and return
+    table.sort(tResults)
+    return tResults
+  end
+end
+
+local function completeProgramArgument(sProgram, nArgument, sPart, tPreviousParts)
+  local tInfo = tCompletionInfo[sProgram]
+  if tInfo then
+    return tInfo.fnComplete(shell, nArgument, sPart, tPreviousParts)
+  end
+  return nil
+end
+
+function shell.complete(sLine)
+  if type(sLine) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(sLine) .. ")", 2)
+  end
+  if #sLine > 0 then
+    local tWords = tokenise(sLine)
+    local nIndex = #tWords
+    if string.sub(sLine, #sLine, #sLine) == " " then
+      nIndex = nIndex + 1
+    end
+    if nIndex == 1 then
+      local sBit = tWords[1] or ""
+      local sPath = shell.resolveProgram(sBit)
+      if tCompletionInfo[sPath] then
+        return { " " }
+      else
+        local tResults = completeProgram(sBit)
+        for n=1,#tResults do
+          local sResult = tResults[n]
+          local sPath = shell.resolveProgram(sBit .. sResult)
+          if tCompletionInfo[sPath] then
+            tResults[n] = sResult .. " "
+          end
+        end
+        return tResults
+      end
+
+    elseif nIndex > 1 then
+      local sPath = shell.resolveProgram(tWords[1])
+      local sPart = tWords[nIndex] or ""
+      local tPreviousParts = tWords
+      tPreviousParts[nIndex] = nil
+      return completeProgramArgument(sPath , nIndex - 1, sPart, tPreviousParts)
+
+    end
+  end
+  return nil
+end
+
+function shell.completeProgram(sProgram)
+  if type(sProgram) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(sProgram) .. ")", 2)
+  end
+  return completeProgram(sProgram)
+end
+
+function shell.setCompletionFunction(sProgram, fnComplete)
+  if type(sProgram) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(sProgram) .. ")", 2)
+  end
+  if type(fnComplete) ~= "function" then
+    error("bad argument #2 (expected function, got " .. type(fnComplete) .. ")", 2)
+  end
+  tCompletionInfo[sProgram] = {
+    fnComplete = fnComplete
+  }
+end
+
+function shell.getCompletionInfo()
+  return tCompletionInfo
+end
+
+function shell.getRunningProgram()
+  if #tProgramStack > 0 then
+    return tProgramStack[#tProgramStack]
+  end
+  return nil
+end
+
+function shell.setAlias(_sCommand, _sProgram)
+  if type(_sCommand) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sCommand) .. ")", 2)
+  end
+  if type(_sProgram) ~= "string" then
+    error("bad argument #2 (expected string, got " .. type(_sProgram) .. ")", 2)
+  end
+  tAliases[_sCommand] = _sProgram
+end
+
+function shell.clearAlias(_sCommand)
+  if type(_sCommand) ~= "string" then
+    error("bad argument #1 (expected string, got " .. type(_sCommand) .. ")", 2)
+  end
+  tAliases[_sCommand] = nil
+end
+
+function shell.aliases()
+  -- Copy aliases
+  local tCopy = {}
+  for sAlias, sCommand in pairs(tAliases) do
+    tCopy[sAlias] = sCommand
+  end
+  return tCopy
+end
+
+function shell.history()
+  -- Read commands and execute them
+  if not history then
+    history = {}
+
+    local history_file = settings.get("mbs.shell.history_file", ".shell_history")
+    if history_file and fs.exists(history_file) then
+      local handle = fs.open(history_file, "r")
+      if handle then
+        for line in handle.readLine do history[#history + 1] = line end
+        handle.close()
+      end
+    end
+  end
+
+  return history
+end
+
+if multishell then
+  function shell.openTab(...)
+    local tWords = tokenise(...)
+    local sCommand = tWords[1]
+    if sCommand then
+      local sPath = shell.resolveProgram(sCommand)
+      if sPath == "rom/programs/shell.lua" then
+        return multishell.launch(createShellEnv("rom/programs"), sPath, table.unpack(tWords, 2))
+      elseif sPath ~= nil then
+        return multishell.launch(createShellEnv("rom/programs"), "rom/programs/shell.lua", sCommand, table.unpack(tWords, 2))
+      else
+        printError("No such program")
+      end
+    end
+  end
+
+  function shell.switchTab(nID)
+    if type(nID) ~= "number" then
+      error("bad argument #1 (expected number, got " .. type(nID) .. ")", 2)
+    end
+    multishell.setFocus(nID)
+  end
+end
+
+local tArgs = { ... }
+if #tArgs > 0 then
+  -- "shell x y z": Run the program specified on the commandline
+  shell.run(...)
+  return
+end
+
+-- "shell": Run the shell REPL
+local parent = term.current()
+local redirect = scroll_window.create(parent)
+
+local function get_first_startup()
+  if fs.exists("startup.lua") then return "startup.lua" end
+  if fs.isDir("startup")  then
+    local first = fs.list("startup")[1]
+    if first then return fs.combine("startup", first) end
+  end
+
+  return nil
+end
+
+--- Create a wrapper for various read functions, allowing the user to scroll
+-- when typing.
+local scroll_offset = nil
+fWrapper = function(fn)
+  return function(...)
+    -- Set the scroll_offset to 0 to allow scrolling
+    scroll_offset = 0
+
+    local ok, res = pcall(fn, ...)
+
+    -- And set to nil again to disable
+    if scroll_offset ~= 0 then redirect.draw(0) end
+    scroll_offset = nil
+
+    if not ok then error(res, 0) end
+    return res
+  end
+end
+
+local worker = coroutine.create(function()
+
+  -- Print the header
+  term.redirect(redirect)
+  term.setCursorPos(1, 1)
+  term.setBackgroundColor(bgColour)
+  term.setTextColour(promptColour)
+  print(os.version() .. " (+MBS)")
+  term.setTextColour(textColour)
+
+  if parentShell == nil then
+    -- If we've no parent shell. run the startup script. It's pretty unlikely,
+    -- but some mad people might be using it!
+    shell.run("/rom/startup.lua")
+  elseif parentShell.getRunningProgram() == get_first_startup() then
+    -- If we're currently in the first startup file, then run all the others.
+    local current = parentShell.getRunningProgram()
+
+    -- Run /startup or /startup.lua
+    local root_startup = shell.resolveProgram("startup")
+    if root_startup and root_startup ~= current then shell.run("/" .. root_startup) end
+
+    -- Run startup/*
+    if fs.isDir("startup") then
+      for _, file in ipairs(fs.list("startup")) do
+        local sub_startup = fs.combine("startup", file)
+        if sub_startup ~= current and not fs.isDir(sub_startup) then
+          shell.run("/" .. sub_startup)
+        end
+      end
+    end
+  end
+
+  -- The main interaction loop
+  local history = shell.history()
+  local wrapped_read = fWrapper(read)
+  while not bExit do
+    local scrollback = tonumber(settings.get("mbs.shell.scroll_max", 1e3))
+    if scrollback then redirect.setMaxScrollback(scrollback) end
+
+    term.setBackgroundColor(bgColour)
+    term.setTextColour(promptColour)
+    if term.getCursorPos() ~= 1 then print() end
+    write(shell.dir() .. "> ")
+    term.setTextColour(textColour)
+
+    local line
+    if settings.get("shell.autocomplete") then
+      line = wrapped_read(nil, history, shell.complete)
+    else
+      line = wrapped_read(nil, history)
+    end
+
+    if not line then break end
+
+    if line:match("%S") and history[#history] ~= line then
+      -- Add item to history
+      history[#history + 1] = line
+
+      -- Remove extra items from history
+      local max = tonumber(settings.get("mbs.shell.history_max", 1e4)) or 1e4
+      while #history > max do table.remove(history, 1) end
+
+      -- Write history file
+      local history_file = settings.get("mbs.shell.history_file", ".shell_history")
+      if history_file then
+        local handle = fs.open(history_file, "w")
+        if handle then
+          for i = 1, #history do handle.writeLine(history[i]) end
+          handle.close()
+        end
+      end
+    end
+
+    local _, y = term.getCursorPos()
+    redirect.setCursorThreshold(y)
+
+    local ok = shell.run(line)
+
+    term.redirect(redirect)
+    redirect.endPrivateMode(not ok)
+    redirect.draw(0)
+  end
+
+  term.redirect(parent)
+end)
+
+local ok, filter = coroutine.resume(worker)
+
+-- We run the main worker inside a coroutine, catching any potential scroll
+-- events.
+while coroutine.status(worker) ~= "dead" do
+  local event = table.pack(coroutine.yield())
+  local e = event[1]
+
+  -- Run the main REPL worker
+  if filter == nil or e == filter or e == "terminate" then
+    ok, filter = coroutine.resume(worker, table.unpack(event, 1, event.n))
+  end
+
+  -- Resize the terminal if required
+  if e == "term_resize" then
+    redirect.updateSize()
+    redirect.draw(scroll_offset or 0, true)
+  end
+
+  -- If we're in some interactive function, allow scrolling the input
+  if scroll_offset then
+    local change = 0
+    if e == "mouse_scroll" then
+      change = event[2]
+    elseif e == "key" and event[2] == keys.pageDown then
+      change = 10
+    elseif e == "key" and event[2] == keys.pageUp then
+      change = -10
+    elseif e == "key" or e == "paste" then
+      -- Reset offset if another key is pressed
+      change = -scroll_offset
+    end
+
+    if change ~= 0 and term.current() == redirect and not redirect.isPrivateMode() then
+      scroll_offset = scroll_offset + change
+      if scroll_offset > 0 then scroll_offset = 0 end
+      if scroll_offset < -redirect.getTotalHeight() then scroll_offset = -redirect.getTotalHeight() end
+      redirect.draw(scroll_offset)
+    end
+  end
+end
+
+if not ok then error(filter, 0) end
\ No newline at end of file