299 lines
10 KiB
Lua
299 lines
10 KiB
Lua
-- code_executor.lua
|
||
-- Secure Lua code execution for LLM-Connect / Smart Lua IDE
|
||
-- Privileges:
|
||
-- llm_dev → Sandbox + Whitelist, no persistent registrations
|
||
-- llm_root → Unrestricted execution + persistent registrations possible
|
||
|
||
local core = core
|
||
local M = {}
|
||
|
||
M.execution_history = {} -- per player: {timestamp, code_snippet, success, output/error}
|
||
|
||
local STARTUP_FILE = core.get_worldpath() .. DIR_DELIM .. "llm_startup.lua"
|
||
|
||
-- =============================================================
|
||
-- Helper functions
|
||
-- =============================================================
|
||
|
||
local function player_has_priv(name, priv)
|
||
local privs = core.get_player_privs(name) or {}
|
||
return privs[priv] == true
|
||
end
|
||
|
||
-- llm_root is a super-role: implies llm_dev and all others
|
||
local function has_llm_priv(name, priv)
|
||
if player_has_priv(name, "llm_root") then return true end
|
||
return player_has_priv(name, priv)
|
||
end
|
||
|
||
local function is_llm_root(name)
|
||
return player_has_priv(name, "llm_root")
|
||
end
|
||
|
||
-- =============================================================
|
||
-- Sandbox environment (for normal llm_dev / llm users)
|
||
-- =============================================================
|
||
|
||
local function create_sandbox_env(player_name)
|
||
local safe_core = {
|
||
-- Logging & Chat
|
||
log = core.log,
|
||
chat_send_player = core.chat_send_player,
|
||
|
||
-- Secure read access
|
||
get_node = core.get_node,
|
||
get_node_or_nil = core.get_node_or_nil,
|
||
find_node_near = core.find_node_near,
|
||
find_nodes_in_area = core.find_nodes_in_area,
|
||
get_meta = core.get_meta,
|
||
get_player_by_name = core.get_player_by_name,
|
||
get_connected_players = core.get_connected_players,
|
||
}
|
||
|
||
-- Block registration functions (require restart)
|
||
local function blocked_registration(name)
|
||
return function(...)
|
||
core.log("warning", ("[code_executor] Blocked registration call: %s by %s"):format(name, player_name))
|
||
core.chat_send_player(player_name, "Registrations are forbidden in sandbox mode.\nOnly llm_root may execute these persistently.")
|
||
return nil
|
||
end
|
||
end
|
||
|
||
safe_core.register_node = blocked_registration("register_node")
|
||
safe_core.register_craftitem = blocked_registration("register_craftitem")
|
||
safe_core.register_tool = blocked_registration("register_tool")
|
||
safe_core.register_craft = blocked_registration("register_craft")
|
||
safe_core.register_entity = blocked_registration("register_entity")
|
||
|
||
-- Allowed dynamic registrations (very restricted)
|
||
safe_core.register_chatcommand = core.register_chatcommand
|
||
safe_core.register_on_chat_message = core.register_on_chat_message
|
||
|
||
-- Safe standard libraries (without dangerous functions)
|
||
local env = {
|
||
-- Lua basics
|
||
assert = assert,
|
||
error = error,
|
||
pairs = pairs,
|
||
ipairs = ipairs,
|
||
next = next,
|
||
select = select,
|
||
type = type,
|
||
tostring = tostring,
|
||
tonumber = tonumber,
|
||
unpack = table.unpack or unpack,
|
||
|
||
-- Safe string/table/math functions
|
||
string = { byte=string.byte, char=string.char, find=string.find, format=string.format,
|
||
gmatch=string.gmatch, gsub=string.gsub, len=string.len, lower=string.lower,
|
||
match=string.match, rep=string.rep, reverse=string.reverse, sub=string.sub,
|
||
upper=string.upper },
|
||
table = { concat=table.concat, insert=table.insert, remove=table.remove, sort=table.sort },
|
||
math = math,
|
||
|
||
-- Minetest-safe API
|
||
core = safe_core,
|
||
|
||
-- Redirect print
|
||
print = function(...) end, -- will be overwritten later
|
||
}
|
||
|
||
-- Output buffer with limit
|
||
local output_buffer = {}
|
||
local output_size = 0
|
||
local MAX_OUTPUT = 100000 -- ~100 KB
|
||
|
||
env.print = function(...)
|
||
local parts = {}
|
||
for i = 1, select("#", ...) do
|
||
parts[i] = tostring(select(i, ...))
|
||
end
|
||
local line = table.concat(parts, "\t")
|
||
|
||
if output_size + #line > MAX_OUTPUT then
|
||
table.insert(output_buffer, "\n[OUTPUT TRUNCATED – 100 KB limit reached]")
|
||
return
|
||
end
|
||
|
||
table.insert(output_buffer, line)
|
||
output_size = output_size + #line
|
||
end
|
||
|
||
return env, output_buffer
|
||
end
|
||
|
||
-- =============================================================
|
||
-- Append persistent startup code (llm_root only)
|
||
-- =============================================================
|
||
|
||
local function append_to_startup(code, player_name)
|
||
local f, err = io.open(STARTUP_FILE, "a")
|
||
if not f then
|
||
core.log("error", ("[code_executor] Cannot open startup file: %s"):format(tostring(err)))
|
||
return false, err
|
||
end
|
||
|
||
f:write(("\n-- Added by %s at %s\n"):format(player_name, os.date("%Y-%m-%d %H:%M:%S")))
|
||
f:write(code)
|
||
f:write("\n\n")
|
||
f:close()
|
||
|
||
core.log("action", ("[code_executor] Appended code to %s by %s"):format(STARTUP_FILE, player_name))
|
||
return true
|
||
end
|
||
|
||
-- =============================================================
|
||
-- Main execution function
|
||
-- =============================================================
|
||
|
||
function M.execute(player_name, code, options)
|
||
options = options or {}
|
||
local result = { success = false }
|
||
|
||
if type(code) ~= "string" or code:trim() == "" then
|
||
result.error = "No or empty code provided"
|
||
return result
|
||
end
|
||
|
||
local is_root = is_llm_root(player_name)
|
||
local use_sandbox = options.sandbox ~= false
|
||
local allow_persist = options.allow_persist or is_root
|
||
|
||
-- Check whether the player has execution rights at all
|
||
if not has_llm_priv(player_name, "llm_dev") then
|
||
result.error = "Missing privilege: llm_dev (or llm_root)"
|
||
return result
|
||
end
|
||
|
||
-- =============================================
|
||
-- 1. Compile
|
||
-- =============================================
|
||
local func, compile_err = loadstring(code, "=(llm_ide)")
|
||
if not func then
|
||
result.error = "Compile error: " .. tostring(compile_err)
|
||
core.log("warning", ("[code_executor] Compile failed for %s: %s"):format(player_name, result.error))
|
||
return result
|
||
end
|
||
|
||
-- =============================================
|
||
-- 2. Prepare environment & print redirection
|
||
-- =============================================
|
||
local output_buffer = {}
|
||
local env
|
||
|
||
if use_sandbox then
|
||
env, output_buffer = create_sandbox_env(player_name)
|
||
setfenv(func, env) -- Lua 5.1 compatibility (Luanti mostly uses LuaJIT)
|
||
else
|
||
-- Unrestricted mode → Careful!
|
||
if not is_root then
|
||
result.error = "Unrestricted execution only allowed for llm_root"
|
||
return result
|
||
end
|
||
|
||
-- Redirect print (without overwriting _G)
|
||
local old_print = print
|
||
print = function(...)
|
||
local parts = {}
|
||
for i = 1, select("#", ...) do parts[#parts+1] = tostring(select(i, ...)) end
|
||
local line = table.concat(parts, "\t")
|
||
table.insert(output_buffer, line)
|
||
end
|
||
end
|
||
|
||
-- =============================================
|
||
-- 3. Execute (with instruction limit)
|
||
-- =============================================
|
||
local ok, exec_res = pcall(function()
|
||
-- Instruction limit could be added here later (currently dummy)
|
||
return func()
|
||
end)
|
||
|
||
-- Reset print (if unrestricted)
|
||
if not use_sandbox then
|
||
print = old_print
|
||
end
|
||
|
||
-- =============================================
|
||
-- 4. Process result
|
||
-- =============================================
|
||
result.output = table.concat(output_buffer, "\n")
|
||
|
||
if ok then
|
||
result.success = true
|
||
result.return_value = exec_res
|
||
|
||
core.log("action", ("[code_executor] Success by %s (sandbox=%s)"):format(player_name, tostring(use_sandbox)))
|
||
else
|
||
result.error = "Runtime error: " .. tostring(exec_res)
|
||
core.log("warning", ("[code_executor] Execution failed for %s: %s"):format(player_name, result.error))
|
||
end
|
||
|
||
-- =============================================
|
||
-- 5. Check for registrations → Persistence?
|
||
-- =============================================
|
||
local has_registration = code:match("register_node%s*%(") or
|
||
code:match("register_tool%s*%(") or
|
||
code:match("register_craftitem%s*%(") or
|
||
code:match("register_entity%s*%(") or
|
||
code:match("register_craft%s*%(")
|
||
|
||
if has_registration then
|
||
if allow_persist and is_root then
|
||
local saved, save_err = append_to_startup(code, player_name)
|
||
if saved then
|
||
local msg = "Code with registrations saved to llm_startup.lua.\nWill be active after server restart."
|
||
core.chat_send_player(player_name, msg)
|
||
result.output = (result.output or "") .. "\n\n" .. msg
|
||
result.persisted = true
|
||
else
|
||
result.error = (result.error or "") .. "\nPersistence failed: " .. tostring(save_err)
|
||
end
|
||
else
|
||
local msg = "Code contains registrations (node/tool/...). \nOnly llm_root can execute these persistently (restart required)."
|
||
core.chat_send_player(player_name, msg)
|
||
result.error = (result.error or "") .. "\n" .. msg
|
||
result.success = false -- even if execution was ok
|
||
end
|
||
end
|
||
|
||
-- Save history
|
||
M.execution_history[player_name] = M.execution_history[player_name] or {}
|
||
table.insert(M.execution_history[player_name], {
|
||
timestamp = os.time(),
|
||
code = code:sub(1, 200) .. (code:len() > 200 and "..." or ""),
|
||
success = result.success,
|
||
output = result.output,
|
||
error = result.error,
|
||
})
|
||
|
||
return result
|
||
end
|
||
|
||
-- =============================================================
|
||
-- History functions
|
||
-- =============================================================
|
||
|
||
function M.get_history(player_name, limit)
|
||
limit = limit or 10
|
||
local hist = M.execution_history[player_name] or {}
|
||
local res = {}
|
||
local start = math.max(1, #hist - limit + 1)
|
||
for i = start, #hist do
|
||
res[#res+1] = hist[i]
|
||
end
|
||
return res
|
||
end
|
||
|
||
function M.clear_history(player_name)
|
||
M.execution_history[player_name] = nil
|
||
end
|
||
|
||
-- Cleanup
|
||
core.register_on_leaveplayer(function(player)
|
||
local name = player:get_player_name()
|
||
M.execution_history[name] = nil
|
||
end)
|
||
|
||
return M
|