luajitos

Sys.lua (41579B)

---

 #!/usr/bin/env luajit
 -- System Management Library
 -- Handles running applications, active window, and input routing
 
 local sys = {}
 
 -- Initialize global hook instance (Hook should be loaded as _G.Hook in init.lua)
 if _G.Hook then
     sys.hook = _G.Hook.newInstance()
 else
     osprint("Warning: Hook library not available, sys.hook not initialized\n")
 end
 
 -- Running applications table
 sys.applications = {}
 
 -- Sandbox environments table (indexed by PID)
 sys.environments = {}
 
 -- Prompt mode state (for admin password prompts, etc.)
 sys.promptMode = {
     active = false,
     window = nil,  -- The only window allowed to draw/receive events
     pid = nil      -- PID of the app that owns the prompt window
 }
 
 -- Active window for keyboard input
 sys.activeWindow = nil
 
 -- Application registry
 sys.appRegistry = {}
 
 -- Hotkey registry
 -- Format: hotkeys["scancode_modifiers_event"] = function
 -- Example: hotkeys["59_0_down"] = function() ... end  (F1 key down, no modifiers)
 -- Modifiers: 1=shift, 2=ctrl, 4=alt (can be combined)
 -- Events: "down", "up", "press"
 sys.hotkeys = {}
 
 -- Screen API
 sys.screen = {}
 sys.screen[1] = {
     width = DEFAULT_SCREEN_WIDTH or 1200,   -- Get from C constants
     height = DEFAULT_SCREEN_HEIGHT or 900,
     setResolution = function(self, w, h)
         -- Check if caller has display-settings permission
         local caller = debug.getinfo(2, "f").func
         local hasPermission = false
 
         -- Find the calling app's environment
         for pid, env in pairs(sys.environments) do
             if env._permissions and env._permissions["display-settings"] then
                 -- Check if this function was called from that environment
                 hasPermission = true
                 break
             end
         end
 
         if not hasPermission then
             error("Permission denied: 'display-settings' permission required to change screen resolution")
         end
 
         -- Validate resolution
         if type(w) ~= "number" or type(h) ~= "number" then
             error("setResolution requires numeric width and height")
         end
 
         if w <= 0 or h <= 0 then
             error("Resolution must be positive")
         end
 
         -- Call VESA to set the mode
         if VESASetMode then
             local result = VESASetMode(w, h, 32)
             if result == 0 then
                 self.width = w
                 self.height = h
 
                 -- Trigger ScreenResolutionChanged hook
                 if sys.hook then
                     sys.hook:run("ScreenResolutionChanged", self)
                 end
 
                 return true
             else
                 error("Failed to set resolution " .. w .. "x" .. h)
             end
         else
             error("VESASetMode not available")
         end
     end
 }
 
 -- Modifier key state
 local modifierState = {
     shift = false,
     ctrl = false,
     alt = false,
     meta = false  -- Windows/Meta key
 }
 
 -- Modifier constants
 sys.MOD_NONE = 0
 sys.MOD_SHIFT = 1
 sys.MOD_CTRL = 2
 sys.MOD_ALT = 4
 sys.MOD_META = 8
 sys.MOD_SHIFT_CTRL = 3
 sys.MOD_SHIFT_ALT = 5
 sys.MOD_CTRL_ALT = 6
 sys.MOD_SHIFT_META = 9
 sys.MOD_CTRL_META = 10
 sys.MOD_ALT_META = 12
 sys.MOD_ALL = 15
 
 -- Event constants
 sys.EVENT_DOWN = "down"
 sys.EVENT_UP = "up"
 sys.EVENT_PRESS = "press"
 
 -- Common key scancodes
 sys.KEY_ESC = 1
 sys.KEY_1 = 2
 sys.KEY_2 = 3
 sys.KEY_3 = 4
 sys.KEY_4 = 5
 sys.KEY_5 = 6
 sys.KEY_6 = 7
 sys.KEY_7 = 8
 sys.KEY_8 = 9
 sys.KEY_9 = 10
 sys.KEY_0 = 11
 sys.KEY_MINUS = 12
 sys.KEY_EQUALS = 13
 sys.KEY_BACKSPACE = 14
 sys.KEY_TAB = 15
 sys.KEY_Q = 16
 sys.KEY_W = 17
 sys.KEY_E = 18
 sys.KEY_R = 19
 sys.KEY_T = 20
 sys.KEY_Y = 21
 sys.KEY_U = 22
 sys.KEY_I = 23
 sys.KEY_O = 24
 sys.KEY_P = 25
 sys.KEY_LBRACKET = 26
 sys.KEY_RBRACKET = 27
 sys.KEY_ENTER = 28
 sys.KEY_LCTRL = 29
 sys.KEY_A = 30
 sys.KEY_S = 31
 sys.KEY_D = 32
 sys.KEY_F = 33
 sys.KEY_G = 34
 sys.KEY_H = 35
 sys.KEY_J = 36
 sys.KEY_K = 37
 sys.KEY_L = 38
 sys.KEY_SEMICOLON = 39
 sys.KEY_QUOTE = 40
 sys.KEY_BACKTICK = 41
 sys.KEY_LSHIFT = 42
 sys.KEY_BACKSLASH = 43
 sys.KEY_Z = 44
 sys.KEY_X = 45
 sys.KEY_C = 46
 sys.KEY_V = 47
 sys.KEY_B = 48
 sys.KEY_N = 49
 sys.KEY_M = 50
 sys.KEY_COMMA = 51
 sys.KEY_PERIOD = 52
 sys.KEY_SLASH = 53
 sys.KEY_RSHIFT = 54
 sys.KEY_KPASTERISK = 55
 sys.KEY_LALT = 56
 sys.KEY_SPACE = 57
 sys.KEY_CAPSLOCK = 58
 sys.KEY_F1 = 59
 sys.KEY_F2 = 60
 sys.KEY_F3 = 61
 sys.KEY_F4 = 62
 sys.KEY_F5 = 63
 sys.KEY_F6 = 64
 sys.KEY_F7 = 65
 sys.KEY_F8 = 66
 sys.KEY_F9 = 67
 sys.KEY_F10 = 68
 sys.KEY_NUMLOCK = 69
 sys.KEY_SCROLLLOCK = 70
 sys.KEY_F11 = 87
 sys.KEY_F12 = 88
 sys.KEY_LMETA = 91  -- Left Windows/Meta key (0x5B)
 sys.KEY_RMETA = 92  -- Right Windows/Meta key (0x5C)
 
 ---Convert scancode and modifiers to hotkey string format
 ---@param scancode number The scancode
 ---@param modifiers number The modifier bitmask
 ---@return string|nil The hotkey string in format "ctrl+alt+meta+shift+key" or nil if unknown
 function sys.scancodeToHotkeyString(scancode, modifiers)
     -- Build modifier prefix in canonical order: ctrl+alt+meta+shift
     local parts = {}
 
     if bit.band(modifiers, sys.MOD_CTRL) ~= 0 then
         table.insert(parts, "ctrl")
     end
     if bit.band(modifiers, sys.MOD_ALT) ~= 0 then
         table.insert(parts, "alt")
     end
     if bit.band(modifiers, sys.MOD_META) ~= 0 then
         table.insert(parts, "meta")
     end
     if bit.band(modifiers, sys.MOD_SHIFT) ~= 0 then
         table.insert(parts, "shift")
     end
 
     -- Map scancode to key name
     local keyName = nil
 
     -- Letters
     if scancode == 16 then keyName = "q"
     elseif scancode == 17 then keyName = "w"
     elseif scancode == 18 then keyName = "e"
     elseif scancode == 19 then keyName = "r"
     elseif scancode == 20 then keyName = "t"
     elseif scancode == 21 then keyName = "y"
     elseif scancode == 22 then keyName = "u"
     elseif scancode == 23 then keyName = "i"
     elseif scancode == 24 then keyName = "o"
     elseif scancode == 25 then keyName = "p"
     elseif scancode == 30 then keyName = "a"
     elseif scancode == 31 then keyName = "s"
     elseif scancode == 32 then keyName = "d"
     elseif scancode == 33 then keyName = "f"
     elseif scancode == 34 then keyName = "g"
     elseif scancode == 35 then keyName = "h"
     elseif scancode == 36 then keyName = "j"
     elseif scancode == 37 then keyName = "k"
     elseif scancode == 38 then keyName = "l"
     elseif scancode == 44 then keyName = "z"
     elseif scancode == 45 then keyName = "x"
     elseif scancode == 46 then keyName = "c"
     elseif scancode == 47 then keyName = "v"
     elseif scancode == 48 then keyName = "b"
     elseif scancode == 49 then keyName = "n"
     elseif scancode == 50 then keyName = "m"
     -- Numbers
     elseif scancode == 2 then keyName = "1"
     elseif scancode == 3 then keyName = "2"
     elseif scancode == 4 then keyName = "3"
     elseif scancode == 5 then keyName = "4"
     elseif scancode == 6 then keyName = "5"
     elseif scancode == 7 then keyName = "6"
     elseif scancode == 8 then keyName = "7"
     elseif scancode == 9 then keyName = "8"
     elseif scancode == 10 then keyName = "9"
     elseif scancode == 11 then keyName = "0"
     -- Special keys
     elseif scancode == 1 then keyName = "esc"
     elseif scancode == 12 then keyName = "minus"
     elseif scancode == 13 then keyName = "equals"
     elseif scancode == 14 then keyName = "backspace"
     elseif scancode == 15 then keyName = "tab"
     elseif scancode == 28 then keyName = "enter"
     elseif scancode == 57 then keyName = "space"
     -- Function keys
     elseif scancode == 59 then keyName = "f1"
     elseif scancode == 60 then keyName = "f2"
     elseif scancode == 61 then keyName = "f3"
     elseif scancode == 62 then keyName = "f4"
     elseif scancode == 63 then keyName = "f5"
     elseif scancode == 64 then keyName = "f6"
     elseif scancode == 65 then keyName = "f7"
     elseif scancode == 66 then keyName = "f8"
     elseif scancode == 67 then keyName = "f9"
     elseif scancode == 68 then keyName = "f10"
     elseif scancode == 87 then keyName = "f11"
     elseif scancode == 88 then keyName = "f12"
     end
 
     if not keyName then
         return nil  -- Unknown scancode
     end
 
     table.insert(parts, keyName)
     return table.concat(parts, "+")
 end
 
 ---Add a hotkey handler
 ---@param scancode number The key scancode (use sys.KEY_* constants)
 ---@param modifiers number Modifier flags (use sys.MOD_* constants)
 ---@param event string Event type (use sys.EVENT_* constants, default "down")
 ---@param handler function Handler function that receives (scancode, modifiers, event)
 ---@return string The hotkey ID for later removal
 function sys.addHotkey(scancode, modifiers, event, handler)
     -- Handle optional event parameter
     if type(event) == "function" then
         handler = event
         event = "down"
     end
 
     modifiers = modifiers or 0
     event = event or "down"
 
     local hotkeyId = scancode .. "_" .. modifiers .. "_" .. event
     sys.hotkeys[hotkeyId] = handler
 
     return hotkeyId
 end
 
 ---Remove a hotkey handler
 ---@param hotkeyId string The hotkey ID returned by addHotkey, or scancode/modifiers/event
 ---@param modifiers number Optional: modifier flags if first param is scancode
 ---@param event string Optional: event type if first param is scancode
 function sys.removeHotkey(hotkeyId, modifiers, event)
     -- Support both formats: removeHotkey(id) or removeHotkey(scancode, modifiers, event)
     if type(hotkeyId) == "number" then
         -- Construct ID from components
         modifiers = modifiers or 0
         event = event or "down"
         hotkeyId = hotkeyId .. "_" .. modifiers .. "_" .. event
     end
 
     sys.hotkeys[hotkeyId] = nil
 end
 
 ---Add a hotkey using string notation (e.g., "ctrl+alt+r", "meta+r")
 ---@param keyCombo string Key combination like "ctrl+r", "ctrl+alt+shift+f", "meta+r"
 ---@param handler function Handler function
 ---@param event string Optional event type (default "down")
 ---@return string The hotkey ID for later removal
 function sys.addHotkeyString(keyCombo, handler, event)
     event = event or "down"
 
     -- Parse the key combination
     local parts = {}
     for part in string.gmatch(keyCombo, "[^+]+") do
         table.insert(parts, string.lower(part))
     end
 
     -- Build modifiers
     local modifiers = 0
     local keyName = nil
 
     for _, part in ipairs(parts) do
         if part == "ctrl" or part == "control" then
             modifiers = bit.bor(modifiers, sys.MOD_CTRL)
         elseif part == "alt" then
             modifiers = bit.bor(modifiers, sys.MOD_ALT)
         elseif part == "shift" then
             modifiers = bit.bor(modifiers, sys.MOD_SHIFT)
         elseif part == "meta" or part == "win" or part == "super" then
             modifiers = bit.bor(modifiers, sys.MOD_META)
         else
             keyName = part
         end
     end
 
     if not keyName then
         error("No key specified in key combination: " .. keyCombo)
     end
 
     -- Map key name to scancode
     local scancode = nil
 
     -- Check for special key names first
     local keyUpper = string.upper(keyName)
     if keyUpper == "PLUS" then scancode = 13  -- + key
     elseif keyUpper == "MINUS" then scancode = 12  -- - key
     elseif keyUpper == "EQUALS" then scancode = 13  -- = key (same as +)
     elseif keyUpper == "SPACE" then scancode = 57  -- Space
     elseif keyUpper == "ENTER" or keyUpper == "RETURN" then scancode = 28  -- Enter
     elseif keyUpper == "BACKSPACE" then scancode = 14  -- Backspace
     elseif keyUpper == "TAB" then scancode = 15  -- Tab
     elseif keyUpper == "ESC" or keyUpper == "ESCAPE" then scancode = 1  -- Escape
     elseif #keyName == 1 then
         -- Single character - map to scancode
         local char = string.upper(keyName)
         -- Letters
         if char == "Q" then scancode = 16
         elseif char == "W" then scancode = 17
         elseif char == "E" then scancode = 18
         elseif char == "R" then scancode = 19
         elseif char == "T" then scancode = 20
         elseif char == "Y" then scancode = 21
         elseif char == "U" then scancode = 22
         elseif char == "I" then scancode = 23
         elseif char == "O" then scancode = 24
         elseif char == "P" then scancode = 25
         elseif char == "A" then scancode = 30
         elseif char == "S" then scancode = 31
         elseif char == "D" then scancode = 32
         elseif char == "F" then scancode = 33
         elseif char == "G" then scancode = 34
         elseif char == "H" then scancode = 35
         elseif char == "J" then scancode = 36
         elseif char == "K" then scancode = 37
         elseif char == "L" then scancode = 38
         elseif char == "Z" then scancode = 44
         elseif char == "X" then scancode = 45
         elseif char == "C" then scancode = 46
         elseif char == "V" then scancode = 47
         elseif char == "B" then scancode = 48
         elseif char == "N" then scancode = 49
         elseif char == "M" then scancode = 50
         -- Numbers
         elseif char == "1" then scancode = 2
         elseif char == "2" then scancode = 3
         elseif char == "3" then scancode = 4
         elseif char == "4" then scancode = 5
         elseif char == "5" then scancode = 6
         elseif char == "6" then scancode = 7
         elseif char == "7" then scancode = 8
         elseif char == "8" then scancode = 9
         elseif char == "9" then scancode = 10
         elseif char == "0" then scancode = 11
         -- Special characters (based on US keyboard layout)
         elseif char == "!" then scancode = 2  -- Shift+1
         elseif char == "@" then scancode = 3  -- Shift+2
         elseif char == "#" then scancode = 4  -- Shift+3
         elseif char == "$" then scancode = 5  -- Shift+4
         elseif char == "%" then scancode = 6  -- Shift+5
         elseif char == "^" then scancode = 7  -- Shift+6
         elseif char == "&" then scancode = 8  -- Shift+7
         elseif char == "*" then scancode = 9  -- Shift+8
         elseif char == "(" then scancode = 10  -- Shift+9
         elseif char == ")" then scancode = 11  -- Shift+0
         elseif char == "-" then scancode = 12  -- Minus
         elseif char == "_" then scancode = 12  -- Shift+Minus
         elseif char == "=" then scancode = 13  -- Equals
         elseif char == "+" then scancode = 13  -- Shift+Equals
         elseif char == "[" then scancode = 26  -- Left bracket
         elseif char == "{" then scancode = 26  -- Shift+Left bracket
         elseif char == "]" then scancode = 27  -- Right bracket
         elseif char == "}" then scancode = 27  -- Shift+Right bracket
         elseif char == ";" then scancode = 39  -- Semicolon
         elseif char == ":" then scancode = 39  -- Shift+Semicolon
         elseif char == "'" then scancode = 40  -- Quote
         elseif char == '"' then scancode = 40  -- Shift+Quote
         elseif char == "\\" then scancode = 43  -- Backslash
         elseif char == "|" then scancode = 43  -- Shift+Backslash
         elseif char == "," then scancode = 51  -- Comma
         elseif char == "<" then scancode = 51  -- Shift+Comma
         elseif char == "." then scancode = 52  -- Period
         elseif char == ">" then scancode = 52  -- Shift+Period
         elseif char == "/" then scancode = 53  -- Slash
         elseif char == "?" then scancode = 53  -- Shift+Slash
         elseif char == "`" then scancode = 41  -- Backtick
         elseif char == "~" then scancode = 41  -- Shift+Backtick
         elseif char == "£" then scancode = 4   -- UK keyboard Shift+3
         else
             error("Unsupported key: " .. keyName)
         end
     else
         error("Multi-character key names not yet supported: " .. keyName)
     end
 
     return sys.addHotkey(scancode, modifiers, event, handler)
 end
 
 ---Register a running application
 ---@param appInstance table Application instance
 function sys.registerApplication(appInstance)
     if not appInstance or not appInstance.pid then
         return false
     end
 
     sys.applications[appInstance.pid] = appInstance
 
     return true
 end
 
 ---Register a sandbox environment for an application
 ---@param pid number Process ID
 ---@param environment table Sandbox environment
 function sys.registerEnvironment(pid, environment)
     if not pid or not environment then
         return false
     end
 
     sys.environments[pid] = environment
 
     return true
 end
 
 ---Get sandbox environment for an application
 ---@param pid number Process ID
 ---@return table|nil Sandbox environment
 function sys.getEnvironment(pid)
     return sys.environments[pid]
 end
 
 ---Unregister a running application
 ---@param pid number Process ID
 function sys.unregisterApplication(pid)
     sys.applications[pid] = nil
     sys.environments[pid] = nil
 
     -- Clear active window if it belonged to this app
     if sys.activeWindow and sys.activeWindow.appInstance and sys.activeWindow.appInstance.pid == pid then
         sys.activeWindow = nil
     end
 end
 
 ---Get application by PID
 ---@param pid number Process ID
 ---@return table|nil Application instance
 function sys.getApplication(pid)
     return sys.applications[pid]
 end
 
 ---Get all running applications
 ---@return table List of application instances
 function sys.getAllApplications()
     local apps = {}
     for _, app in pairs(sys.applications) do
         table.insert(apps, app)
     end
     return apps
 end
 
 ---Set the active window for keyboard input
 ---@param window table Window object
 function sys.setActiveWindow(window)
     sys.activeWindow = window
 end
 
 ---Get the active window
 ---@return table|nil Active window
 function sys.getActiveWindow()
     return sys.activeWindow
 end
 
 ---Find and set the first available window as active
 ---@return boolean True if a window was found and set
 function sys.findAndSetActiveWindow()
     -- Iterate through all running applications
     -- Find the window with onInput that has the highest createdAt (topmost)
     local foundWindow = nil
     local highestTime = -1
     for pid, app in pairs(sys.applications) do
         if app.windows then
             for i, window in ipairs(app.windows) do
                 if window.onInput and not window.isBackground then
                     local windowTime = window.createdAt or 0
                     if windowTime > highestTime then
                         highestTime = windowTime
                         foundWindow = window
                     end
                 end
             end
         end
     end
     if foundWindow then
         sys.setActiveWindow(foundWindow)
         return true
     end
     return false
 end
 
 ---Send keyboard input to the active window
 ---@param key string The key character
 ---@param scancode number The scancode
 ---@return boolean True if input was sent successfully
 function sys.sendInput(key, scancode)
     -- Track modifier key state
     -- Scancodes: 42=LShift, 54=RShift, 29=LCtrl, 56=LAlt, 91=LMeta, 92=RMeta
     local isKeyDown = scancode < 128  -- High bit not set = key down
     local baseScancode = scancode % 128  -- Remove high bit for key up events
 
     -- Debug: Print the baseScancode for all keys
 
     if baseScancode == 42 or baseScancode == 54 then
         modifierState.shift = isKeyDown
     elseif baseScancode == 29 then
         modifierState.ctrl = isKeyDown
     elseif baseScancode == 56 then
         modifierState.alt = isKeyDown
     elseif baseScancode == 91 or baseScancode == 92 then
         modifierState.meta = isKeyDown
     end
 
     -- Calculate modifier bitmask
     local modifiers = 0
     if modifierState.shift then modifiers = modifiers + 1 end
     if modifierState.ctrl then modifiers = modifiers + 2 end
     if modifierState.alt then modifiers = modifiers + 4 end
     if modifierState.meta then modifiers = modifiers + 8 end
 
 
     -- Determine event type
     local event = isKeyDown and "down" or "up"
 
     -- Check for hotkey match (down events)
     if isKeyDown then
         local hotkeyDown = baseScancode .. "_" .. modifiers .. "_down"
         if sys.hotkeys[hotkeyDown] then
             local success, shouldCancel = pcall(sys.hotkeys[hotkeyDown])
             if success and shouldCancel == true then
                 -- Hotkey handled and requested cancellation
                 return true
             end
         end
 
         -- Also check the new hotkey manager
         if sys.hotkey then
             local hotkeyStr = sys.scancodeToHotkeyString(baseScancode, modifiers)
             if hotkeyStr then
                 local hasHotkey = sys.hotkey.has(hotkeyStr)
                 if hasHotkey then
                     local success, result = pcall(sys.hotkey.trigger, hotkeyStr)
                     if success then
                         -- Hotkey was triggered successfully, don't send input to window
                         return true
                     end
                 end
             end
         end
     end
 
     -- Check for hotkey match (up events)
     if not isKeyDown then
         local hotkeyUp = baseScancode .. "_" .. modifiers .. "_up"
         if sys.hotkeys[hotkeyUp] then
             local success, shouldCancel = pcall(sys.hotkeys[hotkeyUp])
             if success and shouldCancel == true then
                 -- Hotkey handled and requested cancellation
                 return true
             end
         end
     end
 
     -- Check for press event (any key with modifiers)
     local hotkeyPress = baseScancode .. "_" .. modifiers .. "_press"
     if sys.hotkeys[hotkeyPress] then
         local success, shouldCancel = pcall(sys.hotkeys[hotkeyPress])
         if success and shouldCancel == true then
             -- Hotkey handled and requested cancellation
             return true
         end
     end
 
     -- Don't send modifier key presses/releases to windows
     -- Modifier scancodes: 42,54=Shift, 29=Ctrl, 56=Alt, 91,92=Meta
     local isModifierKey = (baseScancode == 42 or baseScancode == 54 or
                           baseScancode == 29 or baseScancode == 56 or
                           baseScancode == 91 or baseScancode == 92)
 
     if isModifierKey then
         -- Modifier keys don't get sent to windows, only tracked for hotkeys
         return false
     end
 
     -- Don't send key release events to windows (only key down)
     if not isKeyDown then
         return false
     end
 
     -- If no active window, try to find one
     if not sys.activeWindow then
         if not sys.findAndSetActiveWindow() then
             -- No window available to receive input
             return false
         end
     end
 
     -- Check if there's an active selection and a printable key was pressed
     local win = sys.activeWindow
     local hasSelection = win.selection and win.selection.start and win.selection.finish and
                          win.selection.content and win.selection.content ~= ""
 
     -- Check if this is a printable character or special editing key (backspace, delete, enter)
     local isPrintable = key and #key == 1 and key:byte() >= 32
     local isBackspace = key == "\b"
     local isEnter = key == "\n"
     local isDelete = baseScancode == 83
 
     if hasSelection and (isPrintable or isBackspace or isEnter or isDelete) then
         -- Selection is active and an editing key was pressed
         if win.onSelectionEditted then
             local newContent = ""
             if isPrintable then
                 newContent = key
             elseif isEnter then
                 newContent = "\n"
             end
             -- Backspace and Delete replace selection with empty string
 
             -- Convert selection indices to x,y coordinates
             local startText = win.selectableText and win.selectableText[win.selection.start.index]
             local finishText = win.selectableText and win.selectableText[win.selection.finish.index]
 
             local point1, point2
             if startText then
                 local charWidth = 8 * (startText.scale or 1)
                 point1 = {
                     x = startText.x + (win.selection.start.pos - 1) * charWidth,
                     y = startText.y
                 }
             end
             if finishText then
                 local charWidth = 8 * (finishText.scale or 1)
                 point2 = {
                     x = finishText.x + (win.selection.finish.pos - 1) * charWidth,
                     y = finishText.y
                 }
             end
 
             if not point1 or not point2 then
                 -- Fall back to passing the raw selection if we can't get coordinates
                 point1 = win.selection.start
                 point2 = win.selection.finish
             end
 
             local success, err = pcall(function()
                 win.onSelectionEditted(point1, point2, newContent)
             end)
 
             if not success and osprint then
                 osprint("ERROR: onSelectionEditted callback failed: " .. tostring(err) .. "\n")
             end
 
             -- Clear selection after edit
             win.selection = nil
             win.dirty = true
             return true
         end
     end
 
     -- Call the window's input callback if it exists
     if win.onInput then
         local success, err = pcall(function()
             win.onInput(key, scancode)
         end)
 
         if not success and osprint then
             osprint("ERROR: Input callback failed: " .. tostring(err) .. "\n")
             return false
         end
 
         return true
     else
         return false
     end
 end
 
 ---Register an application in the app registry
 ---@param appName string Application name
 ---@param appPath string Path to application
 function sys.registerAppInRegistry(appName, appPath)
     sys.appRegistry[appName] = appPath
 end
 
 ---Get application path from registry
 ---@param appName string Application name
 ---@return string|nil Application path
 function sys.getAppPath(appName)
     return sys.appRegistry[appName]
 end
 
 ---Add a permission to a running application (admin only)
 ---@param pid number Process ID
 ---@param permission string Permission to add
 ---@return boolean True if successful
 function sys.ADMIN_AppAddPermission(pid, permission)
     local app = sys.applications[pid]
     if not app then
         error("Application with PID " .. pid .. " not found")
     end
 
     if not app.permissions then
         app.permissions = {}
     end
 
     -- Check if permission already exists
     for _, perm in ipairs(app.permissions) do
         if perm == permission then
             -- Already has this permission
             return true
         end
     end
 
     -- Add the permission
     table.insert(app.permissions, permission)
 
 
     -- Re-apply permissions to the sandbox environment if it exists
     local env = sys.environments[pid]
     if env and env._reapplyPermissions then
         env._reapplyPermissions()
     end
 
     return true
 end
 
 ---Add an allowed path to a running application (admin only)
 ---@param pid number Process ID
 ---@param path string Path pattern to add (e.g., "$/data/*", "/tmp/*")
 ---@return boolean True if successful
 function sys.ADMIN_AppAddPath(pid, path)
     local app = sys.applications[pid]
     if not app then
         error("Application with PID " .. pid .. " not found")
     end
 
     if not app.allowedPaths then
         app.allowedPaths = {}
     end
 
     -- Check if path already exists
     for _, p in ipairs(app.allowedPaths) do
         if p == path then
             -- Already has this path
             return true
         end
     end
 
     -- Add the path
     table.insert(app.allowedPaths, path)
 
 
     -- Update the SafeFS instance if it exists in the environment
     local env = sys.environments[pid]
     if env and env.fs and env.fs._updateAllowedPaths then
         env.fs._updateAllowedPaths(app.allowedPaths)
     end
 
     return true
 end
 
 ---Start exclusive prompt mode (admin only)
 ---Only the specified window will be drawn and receive events
 ---All other apps are frozen until ADMIN_FinishPrompt is called
 ---@param window table The window to display exclusively
 ---@return boolean True if successful
 function sys.ADMIN_StartPrompt(window)
     if not window then
         error("ADMIN_StartPrompt: window parameter required")
     end
 
     -- Verify window has an appInstance with PID
     if not window.appInstance or not window.appInstance.pid then
         error("ADMIN_StartPrompt: window must have valid appInstance with PID")
     end
 
     sys.promptMode.active = true
     sys.promptMode.window = window
     sys.promptMode.pid = window.appInstance.pid
 
     -- Force the prompt window to be visible and on top
     window.visible = true
     window.alwaysOnTop = true
     window.dirty = true
 
 
     return true
 end
 
 ---Finish exclusive prompt mode (admin only)
 ---Re-enables drawing and events for all applications
 ---@return boolean True if successful
 function sys.ADMIN_FinishPrompt()
     if not sys.promptMode.active then
         return false
     end
 
     local prev_pid = sys.promptMode.pid
 
     sys.promptMode.active = false
     sys.promptMode.window = nil
     sys.promptMode.pid = nil
 
 
     -- Mark all windows as dirty to force redraw
     for pid, app in pairs(sys.applications) do
         if app.windows then
             for _, window in ipairs(app.windows) do
                 window.dirty = true
             end
         end
     end
 
     return true
 end
 
 ---Internal function to add allowed path (used by Dialog system only)
 ---This is not exposed to sandboxed apps
 ---@param app table Application instance
 ---@param path string Path pattern to add
 ---@param fs table SafeFS instance to update
 ---@return boolean True if successful
 function sys._internal_addAllowedPath(app, path, fs)
     if not app then
         return false, "Invalid app instance"
     end
 
     if not app.allowedPaths then
         app.allowedPaths = {}
     end
 
     -- Check if path already exists
     for _, p in ipairs(app.allowedPaths) do
         if p == path then
             -- Already has this path
             return true
         end
     end
 
     -- Add the path
     table.insert(app.allowedPaths, path)
 
 
     -- Update the SafeFS instance by adding the new path to its allowed roots
     if fs then
         -- Load SafeFS module to access the new() function
         local SafeFS = require or package.loaded.SafeFS
         if not SafeFS and _G.SafeFS then
             SafeFS = _G.SafeFS
         end
 
         if SafeFS and fs.rootNode and fs.allowedRoots then
             -- Get the filesystem root
             local fsRoot = fs.rootNode
 
             -- Resolve $ in path
             local app_dir = app.appPath or ""
             local resolved_path = string.gsub(path, "^%$", app_dir)
 
             -- Remove /* suffix if present
             local cleanPath = resolved_path
             if cleanPath:sub(-2) == "/*" then
                 cleanPath = cleanPath:sub(1, -3)
             end
 
             -- Find node in original filesystem using traverse or manual traversal
             local function findNode(rootNode, targetPath)
                 -- Check if rootNode has a traverse function (C-based filesystem)
                 if type(rootNode) == "table" and type(rootNode.traverse) == "function" then
                     local node, err = rootNode:traverse(targetPath)
                     return node, err
                 end
                 return nil, "Cannot traverse filesystem"
             end
 
             local node, err = findNode(fsRoot, cleanPath)
             if node and node.type == "directory" then
                 -- Deep copy the node (simplified version)
                 local function deepCopyNode(srcNode, parentNode)
                     if not srcNode then return nil end
 
                     local copy = {
                         name = srcNode.name,
                         type = srcNode.type,
                         parent = parentNode
                     }
 
                     if srcNode.type == "directory" then
                         copy.dirs = {}
                         copy.files = {}
 
                         if srcNode.dirs then
                             for _, dir in ipairs(srcNode.dirs) do
                                 local dirCopy = deepCopyNode(dir, copy)
                                 if dirCopy then
                                     table.insert(copy.dirs, dirCopy)
                                 end
                             end
                         end
 
                         if srcNode.files then
                             for _, file in ipairs(srcNode.files) do
                                 local fileCopy = {
                                     name = file.name,
                                     type = "file",
                                     parent = copy,
                                     content = file.content
                                 }
                                 table.insert(copy.files, fileCopy)
                             end
                         end
                     elseif srcNode.type == "file" then
                         copy.content = srcNode.content
                     end
 
                     return copy
                 end
 
                 local isolatedNode = deepCopyNode(node, nil)
                 if isolatedNode then
                     isolatedNode.name = cleanPath
                     fs.roots[cleanPath] = isolatedNode
                     table.insert(fs.allowedRoots, cleanPath)
                     return true
                 else
                     return false, "Failed to copy directory node"
                 end
             else
                 return false, "Directory not found: " .. cleanPath
             end
         end
     end
 
     return true
 end
 
 ---Open a file using the registered file handler for its extension
 ---If the handler app is not running, it will be launched
 ---@param filepath string The full path to the file to open
 ---@return boolean success True if handler was found and called
 ---@return string|nil error Error message if failed
 function sys.openFile(filepath)
     if not filepath or type(filepath) ~= "string" then
         return false, "Invalid filepath"
     end
 
     -- Extract extension from filepath
     local extension = filepath:match("%.([^%.]+)$")
     if not extension then
         return false, "No file extension found"
     end
 
     extension = extension:lower()
 
     -- Get the SafeFS module to access the file handler registry
     -- SafeFS should be loaded globally or we need to load it
     local SafeFS = _G.SafeFS
     if not SafeFS then
         -- Try to load SafeFS module
         local safefs_path = "/os/libs/SafeFS.lua"
         if CRamdiskOpen and CRamdiskRead and CRamdiskClose then
             local handle = CRamdiskOpen(safefs_path, "r")
             if handle then
                 local code = CRamdiskRead(handle)
                 CRamdiskClose(handle)
                 if code then
                     local safefs_func, err = loadstring(code, safefs_path)
                     if safefs_func then
                         local success, module = pcall(safefs_func)
                         if success then
                             SafeFS = module
                             _G.SafeFS = module  -- Cache it globally
                         end
                     end
                 end
             end
         end
     end
 
     if not SafeFS or not SafeFS.getFileHandler then
         return false, "SafeFS module not available"
     end
 
     -- Look up the handler for this extension
     local handler = SafeFS.getFileHandler(extension)
     if not handler then
         return false, "No handler registered for ." .. extension
     end
 
     local appId = handler.appId
     local functionName = handler.functionName
 
     if osprint then
         osprint("[sys.openFile] Opening " .. filepath .. " with " .. appId .. ":" .. functionName .. "\n")
     end
 
     -- Find the app in running applications
     local targetApp = nil
     local targetEnv = nil
 
     for pid, app in pairs(sys.applications) do
         -- Check if app path contains the app ID
         if app.appPath and app.appPath:find(appId, 1, true) then
             targetApp = app
             targetEnv = sys.environments[pid]
             break
         end
     end
 
     -- If app is not running, launch it
     if not targetApp then
         if osprint then
             osprint("[sys.openFile] App " .. appId .. " not running, launching...\n")
         end
 
         -- Use the run module to launch the app
         if _G.run and _G.run.execute then
             local success, app = _G.run.execute(appId, _G.fsRoot)
             if success and app then
                 targetApp = app
                 targetEnv = sys.environments[app.pid]
             else
                 return false, "Failed to launch app: " .. appId
             end
         else
             return false, "Run module not available to launch app"
         end
     end
 
     -- Now call the registered function on the app's environment
     if targetEnv then
         local func = targetEnv[functionName]
         if func and type(func) == "function" then
             local success, err = pcall(func, filepath)
             if not success then
                 return false, "Handler function error: " .. tostring(err)
             end
             return true
         else
             return false, "Function '" .. functionName .. "' not found or not a function in app " .. appId
         end
     else
         return false, "Could not get environment for app " .. appId
     end
 end
 
 -- Browser interface for HTML windows
 -- Loaded on demand when first accessed
 sys.browser = {
     _htmlWindowModule = nil,
 
     -- Load HTMLWindow module on demand
     _loadModule = function(self)
         if self._htmlWindowModule then
             return self._htmlWindowModule
         end
 
         local htmlWindowPath = "/os/libs/HTMLWindow.luac"
         local htmlWindowCode = nil
 
         if CRamdiskExists and CRamdiskExists(htmlWindowPath) then
             local handle = CRamdiskOpen(htmlWindowPath, "r")
             if handle then
                 htmlWindowCode = CRamdiskRead(handle)
                 CRamdiskClose(handle)
             end
         end
 
         if not htmlWindowCode then
             htmlWindowPath = "/os/libs/HTMLWindow.lua"
             if CRamdiskExists and CRamdiskExists(htmlWindowPath) then
                 local handle = CRamdiskOpen(htmlWindowPath, "r")
                 if handle then
                     htmlWindowCode = CRamdiskRead(handle)
                     CRamdiskClose(handle)
                 end
             end
         end
 
         if not htmlWindowCode then
             return nil, "HTMLWindow module not found"
         end
 
         local env = setmetatable({}, { __index = _G, __metatable = false })
         local func, err = loadstring(htmlWindowCode, "HTMLWindow")
         if not func then
             return nil, "Failed to compile HTMLWindow: " .. tostring(err)
         end
         setfenv(func, env)
         local ok, module = pcall(func)
         if not ok then
             return nil, "Failed to execute HTMLWindow: " .. tostring(module)
         end
 
         self._htmlWindowModule = module
         return module
     end,
 
     --- Create a new HTML window for an app
     -- @param options Table with:
     --   - app: Application instance (required)
     --   - html: HTML string to render (either html or file required)
     --   - file: Path to HTML file (either html or file required)
     --   - fs: SafeFS instance for file access
     --   - width: Window width (default 800)
     --   - height: Window height (default 600)
     --   - title: Window title
     --   - Dialog: Dialog module for alert/confirm/prompt
     --   - loadstring: loadstring function for onclick handlers
     --   - showStatusBar: Show status bar (default false)
     --   - onSubmit: Callback for form submissions
     -- @return HTMLWindow object or nil, error
     newHTMLWindow = function(self, options)
         local module, err = self:_loadModule()
         if not module then
             return nil, err
         end
         return module.new(options)
     end,
 }
 
 -- Cursor API (sys.cursor.add, sys.cursor.remove, etc.)
 sys.cursor = {
     -- Add a global cursor drawing function to the stack
     -- @param draw_func function(state, gfx) - Called with cursor state and SafeGfx for 30x30 cursor buffer
     --   state: "cursor", "left-click", "right-click", "grab", "loading", "denied"
     --   gfx: SafeGfx with clear(), fillRect(), drawRect(), drawPixel(), drawLine(), getWidth(), getHeight()
     --   Use color 0x00FF00 (green) for transparent pixels
     -- @return number Index in the cursor stack for removal
     add = function(draw_func)
         if _G._cursor_api and _G._cursor_api.add then
             return _G._cursor_api.add(draw_func)
         end
         error("Cursor API not available")
     end,
 
     -- Remove a global cursor drawing function from stack
     -- @param index number The index returned by add()
     -- @return boolean True if removed successfully
     remove = function(index)
         if _G._cursor_api and _G._cursor_api.remove then
             return _G._cursor_api.remove(index)
         end
         return false
     end,
 
     -- Pop the top global cursor from the stack
     -- @return boolean True if a cursor was popped
     pop = function()
         if _G._cursor_api and _G._cursor_api.pop then
             return _G._cursor_api.pop()
         end
         return false
     end,
 
     -- Set the current cursor mode (triggers redraw)
     -- @param mode string One of: "cursor", "left-click", "right-click", "grab", "loading", "denied"
     setMode = function(mode)
         if _G._cursor_api and _G._cursor_api.setMode then
             _G._cursor_api.setMode(mode)
         end
     end,
 
     -- Get the current cursor mode
     -- @return string Current cursor mode
     getMode = function()
         if _G.cursor_state then
             return _G.cursor_state.mode or "cursor"
         end
         return "cursor"
     end
 }
 
 return sys