luajitos

LAM.lua (34276B)

---

 -- LAM.lua - LuajitOS Application Manager
 -- Package and install applications in .lam format
 --
 -- LAM file format (v2 with optional signature):
 --   [4 bytes] Magic "LAM\0"
 --   [1 byte]  Has signature (0 = no, 1 = yes)
 --   If signed:
 --     [64 bytes] ED25519 signature (signs everything after this field)
 --     [2 bytes]  Developer name length
 --     [N bytes]  Developer name string
 --   [1 byte]  Null separator
 --   [4 bytes] Version (2)
 --   [4 bytes] Manifest length
 --   [N bytes] Manifest string (Lua code)
 --   [1 byte]  Null separator
 --   [4 bytes] Number of directories
 --   For each directory:
 --     [2 bytes] Path length
 --     [N bytes] Path string (relative to app root)
 --   [1 byte]  Null separator
 --   [4 bytes] Number of files
 --   For each file:
 --     [2 bytes] Path length
 --     [N bytes] Path string (relative to app root)
 --     [4 bytes] Original size
 --     [4 bytes] Compressed size
 --     [N bytes] DEFLATE compressed data
 --   [4 bytes] CRC32 checksum of entire file (excluding this field)
 
 local LAM = {}
 
 LAM.VERSION = 2
 LAM.MAGIC = "LAM\0"
 LAM.KEYS_DIR = "/keys"
 
 -- Helper: Convert number to 4 bytes (little-endian)
 local function uint32_to_bytes(n)
     return string.char(
         bit.band(n, 0xFF),
         bit.band(bit.rshift(n, 8), 0xFF),
         bit.band(bit.rshift(n, 16), 0xFF),
         bit.band(bit.rshift(n, 24), 0xFF)
     )
 end
 
 -- Helper: Convert number to 2 bytes (little-endian)
 local function uint16_to_bytes(n)
     return string.char(
         bit.band(n, 0xFF),
         bit.band(bit.rshift(n, 8), 0xFF)
     )
 end
 
 -- Helper: Read 4 bytes as uint32 (little-endian)
 local function bytes_to_uint32(str, pos)
     pos = pos or 1
     local b1, b2, b3, b4 = str:byte(pos, pos + 3)
     return b1 + b2 * 256 + b3 * 65536 + b4 * 16777216
 end
 
 -- Helper: Read 2 bytes as uint16 (little-endian)
 local function bytes_to_uint16(str, pos)
     pos = pos or 1
     local b1, b2 = str:byte(pos, pos + 1)
     return b1 + b2 * 256
 end
 
 -- Helper: Simple CRC32 calculation
 local function crc32(data)
     if _G.CRC32 then
         return _G.CRC32(data)
     end
     -- Fallback: simple checksum if CRC32 not available
     local sum = 0
     for i = 1, #data do
         sum = bit.bxor(sum, data:byte(i))
         sum = bit.band(sum * 31, 0xFFFFFFFF)
     end
     return sum
 end
 
 -- Helper: List all files and directories recursively
 local function listFilesRecursive(basePath, relativePath, files, dirs)
     files = files or {}
     dirs = dirs or {}
     relativePath = relativePath or ""
 
     local fullPath = basePath
     if relativePath ~= "" then
         fullPath = basePath .. "/" .. relativePath
     end
 
     -- List directory contents
     local contents = nil
     if _G.CRamdiskList then
         contents = _G.CRamdiskList(fullPath)
     end
 
     if not contents then
         return files, dirs
     end
 
     for _, item in ipairs(contents) do
         local itemRelPath = relativePath == "" and item.name or (relativePath .. "/" .. item.name)
 
         if item.type == "directory" then
             table.insert(dirs, itemRelPath)
             listFilesRecursive(basePath, itemRelPath, files, dirs)
         else
             table.insert(files, {
                 path = itemRelPath,
                 fullPath = fullPath .. "/" .. item.name
             })
         end
     end
 
     return files, dirs
 end
 
 -- Helper: Expand ~ to /home and normalize path
 local function normalizePath(path)
     if not path then return nil end
     -- Expand ~ to /home
     if path:sub(1, 1) == "~" then
         path = "/home" .. path:sub(2)
     end
     -- Remove trailing slash
     if path:sub(-1) == "/" and #path > 1 then
         path = path:sub(1, -2)
     end
     return path
 end
 
 -- Helper: Check if input looks like a path (contains / or starts with ~ or .)
 local function isPath(input)
     if not input then return false end
     return input:match("^/") or input:match("^~") or input:match("^%./") or input:match("^%.%./")
 end
 
 -- Base64 alphabet
 local b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 
 -- Helper: Base64 encode
 local function base64_encode(data)
     if not data then return nil end
     local result = {}
     local pad = 0
 
     for i = 1, #data, 3 do
         local b1 = data:byte(i) or 0
         local b2 = data:byte(i + 1) or 0
         local b3 = data:byte(i + 2) or 0
 
         local n = b1 * 65536 + b2 * 256 + b3
 
         table.insert(result, b64chars:sub(bit.rshift(n, 18) + 1, bit.rshift(n, 18) + 1))
         table.insert(result, b64chars:sub(bit.band(bit.rshift(n, 12), 63) + 1, bit.band(bit.rshift(n, 12), 63) + 1))
 
         if i + 1 <= #data then
             table.insert(result, b64chars:sub(bit.band(bit.rshift(n, 6), 63) + 1, bit.band(bit.rshift(n, 6), 63) + 1))
         else
             table.insert(result, "=")
         end
 
         if i + 2 <= #data then
             table.insert(result, b64chars:sub(bit.band(n, 63) + 1, bit.band(n, 63) + 1))
         else
             table.insert(result, "=")
         end
     end
 
     return table.concat(result)
 end
 
 -- Helper: Base64 decode
 local function base64_decode(data)
     if not data then return nil end
 
     -- Build reverse lookup
     local b64lookup = {}
     for i = 1, 64 do
         b64lookup[b64chars:sub(i, i)] = i - 1
     end
 
     -- Remove padding and whitespace
     data = data:gsub("[^" .. b64chars .. "]", "")
 
     local result = {}
     for i = 1, #data, 4 do
         local c1 = b64lookup[data:sub(i, i)] or 0
         local c2 = b64lookup[data:sub(i + 1, i + 1)] or 0
         local c3 = b64lookup[data:sub(i + 2, i + 2)]
         local c4 = b64lookup[data:sub(i + 3, i + 3)]
 
         local n = c1 * 262144 + c2 * 4096
         if c3 then n = n + c3 * 64 end
         if c4 then n = n + c4 end
 
         table.insert(result, string.char(bit.band(bit.rshift(n, 16), 255)))
         if c3 then
             table.insert(result, string.char(bit.band(bit.rshift(n, 8), 255)))
         end
         if c4 then
             table.insert(result, string.char(bit.band(n, 255)))
         end
     end
 
     return table.concat(result)
 end
 
 --- Create a new developer keypair
 -- @param developerName Name for the developer (used as folder name)
 -- @return true on success, nil and error message on failure
 function LAM.newDeveloper(developerName)
     if not developerName or developerName == "" then
         return nil, "Developer name required"
     end
 
     -- Sanitize name (alphanumeric, underscore, hyphen only)
     if not developerName:match("^[%w_%-]+$") then
         return nil, "Developer name can only contain letters, numbers, underscores, and hyphens"
     end
 
     -- Check if crypto is available
     if not _G.crypto or not _G.crypto.ed25519_keypair then
         return nil, "Crypto library not available (ed25519_keypair)"
     end
 
     -- Create /keys directory if it doesn't exist
     if _G.CRamdiskMkdir and not _G.CRamdiskExists(LAM.KEYS_DIR) then
         _G.CRamdiskMkdir(LAM.KEYS_DIR)
     end
 
     -- Create developer directory
     local devDir = LAM.KEYS_DIR .. "/" .. developerName
     if _G.CRamdiskExists and _G.CRamdiskExists(devDir) then
         return nil, "Developer '" .. developerName .. "' already exists"
     end
 
     if not _G.CRamdiskMkdir(devDir) then
         return nil, "Failed to create directory: " .. devDir
     end
 
     -- Generate keypair
     local publicKey, secretKey = _G.crypto.ed25519_keypair()
 
     if not publicKey or not secretKey then
         return nil, "Failed to generate keypair"
     end
 
     -- Save public key
     local pubPath = devDir .. "/public.key"
     local pubHandle = _G.CRamdiskOpen(pubPath, "w")
     if not pubHandle then
         return nil, "Failed to create public key file"
     end
     _G.CRamdiskWrite(pubHandle, publicKey)
     _G.CRamdiskClose(pubHandle)
 
     -- Save secret key
     local secPath = devDir .. "/secret.key"
     local secHandle = _G.CRamdiskOpen(secPath, "w")
     if not secHandle then
         return nil, "Failed to create secret key file"
     end
     _G.CRamdiskWrite(secHandle, secretKey)
     _G.CRamdiskClose(secHandle)
 
     return true, {
         name = developerName,
         path = devDir,
         publicKey = publicKey
     }
 end
 
 --- Load developer keys
 -- @param developerName Name of the developer
 -- @return publicKey, secretKey (base64) or nil, error
 function LAM.loadDeveloperKeys(developerName)
     if not developerName then
         return nil, nil, "Developer name required"
     end
 
     local devDir = LAM.KEYS_DIR .. "/" .. developerName
 
     if not _G.CRamdiskExists or not _G.CRamdiskExists(devDir) then
         return nil, nil, "Developer not found: " .. developerName
     end
 
     -- Load public key
     local pubPath = devDir .. "/public.key"
     local pubHandle = _G.CRamdiskOpen(pubPath, "r")
     if not pubHandle then
         return nil, nil, "Failed to open public key"
     end
     local publicKey = _G.CRamdiskRead(pubHandle)
     _G.CRamdiskClose(pubHandle)
 
     -- Load secret key
     local secPath = devDir .. "/secret.key"
     local secHandle = _G.CRamdiskOpen(secPath, "r")
     if not secHandle then
         return nil, nil, "Failed to open secret key"
     end
     local secretKey = _G.CRamdiskRead(secHandle)
     _G.CRamdiskClose(secHandle)
 
     return publicKey, secretKey
 end
 
 --- List all developers
 -- @return Table of developer names
 function LAM.listDevelopers()
     local developers = {}
 
     if not _G.CRamdiskList or not _G.CRamdiskExists(LAM.KEYS_DIR) then
         return developers
     end
 
     local contents = _G.CRamdiskList(LAM.KEYS_DIR)
     if contents then
         for _, item in ipairs(contents) do
             if item.type == "directory" then
                 -- Check if it has key files
                 local pubPath = LAM.KEYS_DIR .. "/" .. item.name .. "/public.key"
                 if _G.CRamdiskExists(pubPath) then
                     table.insert(developers, item.name)
                 end
             end
         end
     end
 
     return developers
 end
 
 --- Package an application into a .lam file
 -- @param appIdOrPath Application ID (e.g., "com.luajitos.moonbrowser") or path (e.g., "~/Documents/myapp/")
 -- @param outputPath Output file path (e.g., "/home/moonbrowser.lam")
 -- @param options Optional table with:
 --   - developer: Developer name to sign the package with
 -- @return true on success, nil and error message on failure
 function LAM.package(appIdOrPath, outputPath, options)
     options = options or {}
     if not appIdOrPath then
         return nil, "Application ID or path required"
     end
 
     local appPath
     local appId
 
     -- Check if input is a path or an app ID
     if isPath(appIdOrPath) then
         -- It's a path - normalize it
         appPath = normalizePath(appIdOrPath)
 
         -- Check if path exists
         if not _G.CRamdiskExists or not _G.CRamdiskExists(appPath) then
             return nil, "Directory not found: " .. appPath
         end
 
         -- Extract app name from path for output filename
         appId = appPath:match("([^/]+)$") or "app"
     else
         -- It's an app ID
         appId = appIdOrPath
 
         -- Add prefix if needed
         if not appId:match("%.") then
             appId = "com.luajitos." .. appId
         end
 
         appPath = "/apps/" .. appId
 
         -- Check if app exists
         if not _G.CRamdiskExists or not _G.CRamdiskExists(appPath) then
             return nil, "Application not found: " .. appPath
         end
     end
 
     -- Read manifest
     local manifestPath = appPath .. "/manifest.lua"
     if not _G.CRamdiskExists(manifestPath) then
         return nil, "Manifest not found: " .. manifestPath
     end
 
     local manifestHandle = _G.CRamdiskOpen(manifestPath, "r")
     if not manifestHandle then
         return nil, "Failed to open manifest"
     end
     local manifestContent = _G.CRamdiskRead(manifestHandle)
     _G.CRamdiskClose(manifestHandle)
 
     if not manifestContent then
         return nil, "Failed to read manifest"
     end
 
     -- List all files and directories
     local files, dirs = listFilesRecursive(appPath, "")
 
     -- Load developer keys if signing is requested
     local developerName = options.developer
     local publicKey, secretKey
     if developerName then
         publicKey, secretKey = LAM.loadDeveloperKeys(developerName)
         if not publicKey or not secretKey then
             return nil, "Failed to load developer keys for: " .. developerName
         end
     end
 
     -- Build the package content (everything after signature header)
     local contentParts = {}
 
     -- Null separator after signature header
     table.insert(contentParts, "\0")
 
     -- Version
     table.insert(contentParts, uint32_to_bytes(LAM.VERSION))
 
     -- Manifest
     table.insert(contentParts, uint32_to_bytes(#manifestContent))
     table.insert(contentParts, manifestContent)
     table.insert(contentParts, "\0")  -- Null separator
 
     -- Directories
     table.insert(contentParts, uint32_to_bytes(#dirs))
     for _, dirPath in ipairs(dirs) do
         table.insert(contentParts, uint16_to_bytes(#dirPath))
         table.insert(contentParts, dirPath)
     end
     table.insert(contentParts, "\0")  -- Null separator
 
     -- Files
     table.insert(contentParts, uint32_to_bytes(#files))
     for _, file in ipairs(files) do
         -- Read file content
         local fileHandle = _G.CRamdiskOpen(file.fullPath, "r")
         if not fileHandle then
             return nil, "Failed to open file: " .. file.fullPath
         end
         local fileContent = _G.CRamdiskRead(fileHandle)
         _G.CRamdiskClose(fileHandle)
 
         if not fileContent then
             return nil, "Failed to read file: " .. file.fullPath
         end
 
         -- Compress file content
         local compressed = fileContent
         local originalSize = #fileContent
 
         if _G.DeflateCompress and originalSize > 0 then
             local result = _G.DeflateCompress(fileContent, 6)  -- Level 6 compression
             if result and #result < originalSize then
                 compressed = result
             end
         end
 
         -- Write file entry
         table.insert(contentParts, uint16_to_bytes(#file.path))
         table.insert(contentParts, file.path)
         table.insert(contentParts, uint32_to_bytes(originalSize))
         table.insert(contentParts, uint32_to_bytes(#compressed))
         table.insert(contentParts, compressed)
     end
 
     -- Combine content parts
     local contentData = table.concat(contentParts)
 
     -- Build final package with header
     local headerParts = {}
 
     -- Magic
     table.insert(headerParts, LAM.MAGIC)
 
     -- Has signature flag
     if developerName then
         table.insert(headerParts, string.char(1))  -- Has signature
 
         -- Sign the content data
         local secretKeyRaw = base64_decode(secretKey)
         if not secretKeyRaw or #secretKeyRaw ~= 64 then
             return nil, "Invalid secret key format"
         end
 
         local signature
         if _G.crypto and _G.crypto.ed25519_sign then
             local sigB64 = _G.crypto.ed25519_sign(contentData, secretKeyRaw)
             signature = base64_decode(sigB64)
         end
 
         if not signature or #signature ~= 64 then
             return nil, "Failed to sign package"
         end
 
         table.insert(headerParts, signature)  -- 64-byte signature
 
         -- Developer name
         table.insert(headerParts, uint16_to_bytes(#developerName))
         table.insert(headerParts, developerName)
     else
         table.insert(headerParts, string.char(0))  -- No signature
     end
 
     -- Combine header and content
     local packageData = table.concat(headerParts) .. contentData
 
     -- Calculate and append checksum
     local checksum = crc32(packageData)
     packageData = packageData .. uint32_to_bytes(checksum)
 
     -- Write to output file
     if not outputPath then
         outputPath = "/home/" .. appId:match("([^.]+)$") .. ".lam"
     end
 
     local outHandle = _G.CRamdiskOpen(outputPath, "w")
     if not outHandle then
         return nil, "Failed to create output file: " .. outputPath
     end
 
     _G.CRamdiskWrite(outHandle, packageData)
     _G.CRamdiskClose(outHandle)
 
     return true, {
         path = outputPath,
         size = #packageData,
         files = #files,
         dirs = #dirs,
         manifest = manifestContent
     }
 end
 
 --- Install an application from a .lam file
 -- @param lamPath Path to the .lam file
 -- @param options Optional table with:
 --   - force: Overwrite existing installation
 --   - skipPostInstall: Don't run post-install script
 --   - requireSignature: Fail if package is not signed
 -- @return true on success, nil and error message on failure
 function LAM.install(lamPath, options)
     options = options or {}
 
     if not lamPath then
         return nil, "LAM file path required"
     end
 
     -- Read the package file
     if not _G.CRamdiskExists or not _G.CRamdiskExists(lamPath) then
         return nil, "File not found: " .. lamPath
     end
 
     local handle = _G.CRamdiskOpen(lamPath, "r")
     if not handle then
         return nil, "Failed to open file: " .. lamPath
     end
     local data = _G.CRamdiskRead(handle)
     _G.CRamdiskClose(handle)
 
     if not data then
         return nil, "Failed to read file"
     end
 
     local pos = 1
 
     -- Verify magic
     if data:sub(pos, pos + 3) ~= LAM.MAGIC then
         return nil, "Invalid LAM file (bad magic)"
     end
     pos = pos + 4
 
     -- Verify checksum first
     local storedChecksum = bytes_to_uint32(data, #data - 3)
     local calculatedChecksum = crc32(data:sub(1, #data - 4))
     if storedChecksum ~= calculatedChecksum then
         return nil, "Checksum mismatch (file may be corrupted)"
     end
 
     -- Read signature flag
     local hasSig = data:byte(pos) == 1
     pos = pos + 1
 
     local signature, developerName, signatureValid
     local contentStart
 
     if hasSig then
         -- Read signature (64 bytes)
         signature = data:sub(pos, pos + 63)
         pos = pos + 64
 
         -- Read developer name
         local devNameLen = bytes_to_uint16(data, pos)
         pos = pos + 2
         developerName = data:sub(pos, pos + devNameLen - 1)
         pos = pos + devNameLen
 
         -- Content starts after developer name (at the null separator)
         contentStart = pos
 
         -- Verify signature
         local contentData = data:sub(contentStart, #data - 4)  -- Exclude checksum
         local publicKey, _ = LAM.loadDeveloperKeys(developerName)
 
         if publicKey then
             local publicKeyRaw = base64_decode(publicKey)
             if publicKeyRaw and #publicKeyRaw == 32 and _G.crypto and _G.crypto.ed25519_verify then
                 signatureValid = _G.crypto.ed25519_verify(contentData, signature, publicKeyRaw)
             end
         end
 
         if not signatureValid then
             print("WARNING: Package signature could not be verified for developer: " .. developerName)
             if options.requireSignature then
                 return nil, "Signature verification failed"
             end
         else
             print("Package signed by: " .. developerName .. " (verified)")
         end
     else
         contentStart = pos
         if options.requireSignature then
             return nil, "Package is not signed (signature required)"
         end
     end
 
     -- Skip null separator
     pos = pos + 1
 
     -- Read version
     local version = bytes_to_uint32(data, pos)
     pos = pos + 4
     if version > LAM.VERSION then
         return nil, "Unsupported LAM version: " .. version
     end
 
     -- Read manifest
     local manifestLen = bytes_to_uint32(data, pos)
     pos = pos + 4
     local manifestContent = data:sub(pos, pos + manifestLen - 1)
     pos = pos + manifestLen
 
     -- Skip null separator
     pos = pos + 1
 
     -- Parse manifest to get app ID
     local manifestFunc, err = loadstring("return " .. manifestContent, "manifest")
     if not manifestFunc then
         -- Try without "return"
         manifestFunc, err = loadstring(manifestContent, "manifest")
     end
 
     if not manifestFunc then
         return nil, "Failed to parse manifest: " .. tostring(err)
     end
 
     local ok, manifest = pcall(manifestFunc)
     if not ok then
         return nil, "Failed to execute manifest: " .. tostring(manifest)
     end
 
     -- Determine app ID from manifest or filename
     local appId = manifest.id or manifest.name
     if not appId then
         -- Try to extract from filename
         appId = lamPath:match("([^/]+)%.lam$")
     end
     if not appId then
         return nil, "Could not determine application ID"
     end
 
     -- If appId doesn't have dots, assume com.luajitos prefix
     if not appId:match("%.") then
         appId = "com.luajitos." .. appId
     end
 
     local appPath = "/apps/" .. appId
 
     -- Check if already installed
     if _G.CRamdiskExists(appPath) and not options.force then
         return nil, "Application already installed: " .. appId .. " (use force=true to overwrite)"
     end
 
     -- Create app directory
     if not _G.CRamdiskExists(appPath) then
         _G.CRamdiskMkdir(appPath)
     end
 
     -- Read directories
     local numDirs = bytes_to_uint32(data, pos)
     pos = pos + 4
 
     local dirs = {}
     for i = 1, numDirs do
         local pathLen = bytes_to_uint16(data, pos)
         pos = pos + 2
         local dirPath = data:sub(pos, pos + pathLen - 1)
         pos = pos + pathLen
         table.insert(dirs, dirPath)
     end
 
     -- Skip null separator
     pos = pos + 1
 
     -- Create directories
     for _, dirPath in ipairs(dirs) do
         local fullPath = appPath .. "/" .. dirPath
         if not _G.CRamdiskExists(fullPath) then
             _G.CRamdiskMkdir(fullPath)
         end
     end
 
     -- Read files
     local numFiles = bytes_to_uint32(data, pos)
     pos = pos + 4
 
     local installedFiles = {}
     for i = 1, numFiles do
         local pathLen = bytes_to_uint16(data, pos)
         pos = pos + 2
         local filePath = data:sub(pos, pos + pathLen - 1)
         pos = pos + pathLen
 
         local originalSize = bytes_to_uint32(data, pos)
         pos = pos + 4
         local compressedSize = bytes_to_uint32(data, pos)
         pos = pos + 4
 
         local compressedData = data:sub(pos, pos + compressedSize - 1)
         pos = pos + compressedSize
 
         -- Decompress if needed
         local fileContent
         if compressedSize < originalSize and _G.DeflateDecompress then
             fileContent = _G.DeflateDecompress(compressedData)
             if not fileContent then
                 return nil, "Failed to decompress file: " .. filePath
             end
         else
             fileContent = compressedData
         end
 
         -- Write file
         local fullPath = appPath .. "/" .. filePath
 
         -- Ensure parent directory exists
         local parentDir = fullPath:match("(.*/)[^/]+$")
         if parentDir and not _G.CRamdiskExists(parentDir) then
             _G.CRamdiskMkdir(parentDir)
         end
 
         local fileHandle = _G.CRamdiskOpen(fullPath, "w")
         if not fileHandle then
             return nil, "Failed to create file: " .. fullPath
         end
         _G.CRamdiskWrite(fileHandle, fileContent)
         _G.CRamdiskClose(fileHandle)
 
         table.insert(installedFiles, filePath)
     end
 
     -- Write manifest (it's stored in package but needs to be written to disk)
     local manifestHandle = _G.CRamdiskOpen(appPath .. "/manifest.lua", "w")
     if manifestHandle then
         _G.CRamdiskWrite(manifestHandle, manifestContent)
         _G.CRamdiskClose(manifestHandle)
     end
 
     -- Run post-install script if specified
     if manifest.postInstall and not options.skipPostInstall then
         local postInstallPath = appPath .. "/src/" .. manifest.postInstall
         if _G.CRamdiskExists(postInstallPath) then
             -- Run the post-install script in the app's sandbox
             if _G.run and _G.run.execute then
                 local success, result = pcall(function()
                     return _G.run.execute(appId, _G.fsRoot)
                 end)
                 if not success then
                     print("Warning: Post-install script failed: " .. tostring(result))
                 end
             end
         end
     end
 
     return true, {
         appId = appId,
         path = appPath,
         files = #installedFiles,
         dirs = #dirs,
         manifest = manifest
     }
 end
 
 --- List installed applications
 -- @return Table of installed app IDs
 function LAM.list()
     local apps = {}
 
     if not _G.CRamdiskList then
         return apps
     end
 
     local contents = _G.CRamdiskList("/apps")
     if contents then
         for _, item in ipairs(contents) do
             if item.type == "directory" then
                 -- Check if it has a manifest
                 local manifestPath = "/apps/" .. item.name .. "/manifest.lua"
                 if _G.CRamdiskExists(manifestPath) then
                     table.insert(apps, item.name)
                 end
             end
         end
     end
 
     return apps
 end
 
 --- Get information about an installed application
 -- @param appId Application ID
 -- @return Manifest table or nil
 function LAM.info(appId)
     if not appId then
         return nil, "Application ID required"
     end
 
     local manifestPath = "/apps/" .. appId .. "/manifest.lua"
 
     if not _G.CRamdiskExists or not _G.CRamdiskExists(manifestPath) then
         return nil, "Application not found: " .. appId
     end
 
     local handle = _G.CRamdiskOpen(manifestPath, "r")
     if not handle then
         return nil, "Failed to open manifest"
     end
     local content = _G.CRamdiskRead(handle)
     _G.CRamdiskClose(handle)
 
     local func, err = loadstring("return " .. content, "manifest")
     if not func then
         func, err = loadstring(content, "manifest")
     end
 
     if not func then
         return nil, "Failed to parse manifest: " .. tostring(err)
     end
 
     local ok, manifest = pcall(func)
     if not ok then
         return nil, "Failed to execute manifest: " .. tostring(manifest)
     end
 
     return manifest
 end
 
 --- Uninstall an application
 -- @param appId Application ID
 -- @return true on success, nil and error message on failure
 function LAM.uninstall(appId)
     if not appId then
         return nil, "Application ID required"
     end
 
     local appPath = "/apps/" .. appId
 
     if not _G.CRamdiskExists or not _G.CRamdiskExists(appPath) then
         return nil, "Application not found: " .. appId
     end
 
     -- Get manifest to check for preUninstall script
     local manifest = LAM.info(appId)
 
     -- Run pre-uninstall script if specified
     if manifest and manifest.preUninstall then
         local preUninstallPath = appPath .. "/src/" .. manifest.preUninstall
         if _G.CRamdiskExists(preUninstallPath) then
             -- Could run the script here
             print("Running pre-uninstall script...")
         end
     end
 
     -- Remove all files and directories recursively
     local function removeRecursive(path)
         local contents = _G.CRamdiskList(path)
         if contents then
             for _, item in ipairs(contents) do
                 local fullPath = path .. "/" .. item.name
                 if item.type == "directory" then
                     removeRecursive(fullPath)
                 else
                     _G.CRamdiskRemove(fullPath)
                 end
             end
         end
         _G.CRamdiskRemove(path)
     end
 
     removeRecursive(appPath)
 
     return true
 end
 
 --- CLI interface for LAM
 -- @param args Command line arguments
 function LAM.cli(args)
     if not args or #args == 0 then
         print("LuajitOS Application Manager (LAM)")
         print("")
         print("Usage:")
         print("  lam package <appId|path> [output] [--sign <dev>]")
         print("                                    - Package an app into a .lam file")
         print("  lam install <file.lam> [--force]  - Install an app from a .lam file")
         print("  lam uninstall <appId>             - Uninstall an application")
         print("  lam list                          - List installed applications")
         print("  lam info <appId>                  - Show app information")
         print("  lam new-developer <name>          - Create a new developer keypair")
         print("  lam list-developers               - List all developers")
         print("")
         print("Examples:")
         print("  lam package moonbrowser           - Package installed app (unsigned)")
         print("  lam package moonbrowser --sign me - Package and sign with 'me' key")
         print("  lam package ~/Documents/myapp/    - Package from directory")
         print("  lam new-developer myname          - Create keypair in /keys/myname/")
         print("")
         return
     end
 
     local cmd = args[1]
 
     if cmd == "new-developer" then
         local devName = args[2]
 
         if not devName then
             print("Error: Developer name required")
             print("Usage: lam new-developer <name>")
             return
         end
 
         print("Creating developer keypair for: " .. devName)
         local ok, result = LAM.newDeveloper(devName)
 
         if ok then
             print("Developer created: " .. result.name)
             print("  Path: " .. result.path)
             print("  Public key: " .. result.publicKey)
             print("")
             print("Keep your secret key safe! It's stored at:")
             print("  " .. result.path .. "/secret.key")
         else
             print("Error: " .. tostring(result))
         end
 
     elseif cmd == "list-developers" then
         local developers = LAM.listDevelopers()
 
         if #developers == 0 then
             print("No developers registered")
             print("Use 'lam new-developer <name>' to create a keypair")
         else
             print("Registered developers:")
             for _, name in ipairs(developers) do
                 local pubKey, _ = LAM.loadDeveloperKeys(name)
                 print("  " .. name)
                 if pubKey then
                     print("    Public key: " .. pubKey:sub(1, 20) .. "...")
                 end
             end
         end
 
     elseif cmd == "package" then
         local appIdOrPath = args[2]
         local outputPath = nil
         local developer = nil
 
         -- Parse remaining args for output path and --sign
         local i = 3
         while i <= #args do
             if args[i] == "--sign" and args[i + 1] then
                 developer = args[i + 1]
                 i = i + 2
             elseif not outputPath and not args[i]:match("^%-") then
                 outputPath = args[i]
                 i = i + 1
             else
                 i = i + 1
             end
         end
 
         if not appIdOrPath then
             print("Error: Application ID or path required")
             print("Usage: lam package <appId|path> [outputPath] [--sign <developer>]")
             return
         end
 
         if developer then
             print("Packaging " .. appIdOrPath .. " (signed by " .. developer .. ")...")
         else
             print("Packaging " .. appIdOrPath .. " (unsigned)...")
         end
 
         local ok, result = LAM.package(appIdOrPath, outputPath, { developer = developer })
 
         if ok then
             print("Package created: " .. result.path)
             print("  Size: " .. result.size .. " bytes")
             print("  Files: " .. result.files)
             print("  Directories: " .. result.dirs)
         else
             print("Error: " .. tostring(result))
         end
 
     elseif cmd == "install" then
         local lamPath = args[2]
         local force = args[3] == "--force" or args.force
 
         if not lamPath then
             print("Error: LAM file path required")
             print("Usage: lam install <file.lam> [--force]")
             return
         end
 
         print("Installing from " .. lamPath .. "...")
         local ok, result = LAM.install(lamPath, { force = force })
 
         if ok then
             print("Installed: " .. result.appId)
             print("  Path: " .. result.path)
             print("  Files: " .. result.files)
             print("  Directories: " .. result.dirs)
         else
             print("Error: " .. tostring(result))
         end
 
     elseif cmd == "uninstall" then
         local appId = args[2]
 
         if not appId then
             print("Error: Application ID required")
             print("Usage: lam uninstall <appId>")
             return
         end
 
         -- Add prefix if needed
         if not appId:match("%.") then
             appId = "com.luajitos." .. appId
         end
 
         print("Uninstalling " .. appId .. "...")
         local ok, err = LAM.uninstall(appId)
 
         if ok then
             print("Uninstalled: " .. appId)
         else
             print("Error: " .. tostring(err))
         end
 
     elseif cmd == "list" then
         local apps = LAM.list()
 
         if #apps == 0 then
             print("No applications installed")
         else
             print("Installed applications:")
             for _, appId in ipairs(apps) do
                 local manifest = LAM.info(appId)
                 local name = manifest and manifest.name or appId
                 local version = manifest and manifest.version or "?"
                 print("  " .. appId .. " (" .. name .. " v" .. version .. ")")
             end
         end
 
     elseif cmd == "info" then
         local appId = args[2]
 
         if not appId then
             print("Error: Application ID required")
             print("Usage: lam info <appId>")
             return
         end
 
         -- Add prefix if needed
         if not appId:match("%.") then
             appId = "com.luajitos." .. appId
         end
 
         local manifest, err = LAM.info(appId)
 
         if manifest then
             print("Application: " .. appId)
             print("  Name: " .. (manifest.name or "?"))
             print("  Version: " .. (manifest.version or "?"))
             print("  Developer: " .. (manifest.developer or "?"))
             print("  Description: " .. (manifest.description or "?"))
             print("  Entry: " .. (manifest.entry or "init.lua"))
             print("  Type: " .. (manifest.type or "gui"))
             if manifest.permissions then
                 print("  Permissions: " .. table.concat(manifest.permissions, ", "))
             end
         else
             print("Error: " .. tostring(err))
         end
 
     else
         print("Unknown command: " .. cmd)
         print("Run 'lam' without arguments for usage")
     end
 end
 
 return LAM