lunel-cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -5,55 +5,158 @@ import Ignore from "ignore";
 const ignore = Ignore.default;
 import * as fs from "fs/promises";
 import * as path from "path";
-const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://proxy-1.lunel.dev";
+import * as os from "os";
+import { spawn, execSync } from "child_process";
+import { createServer } from "net";
+const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
+const VERSION = "0.1.3";
 // Root directory - sandbox all file operations to this
 const ROOT_DIR = process.cwd();
-// Validate and resolve path within sandbox
+// Terminal sessions
+const terminals = new Map();
+const processes = new Map();
+const processOutputBuffers = new Map();
+// CPU usage tracking
+let lastCpuInfo = null;
+// ============================================================================
+// Path Safety
+// ============================================================================
 function resolveSafePath(requestedPath) {
-    // Resolve the requested path relative to ROOT_DIR
     const resolved = path.resolve(ROOT_DIR, requestedPath);
-    // Ensure the resolved path is within ROOT_DIR
     if (!resolved.startsWith(ROOT_DIR)) {
         return null;
     }
     return resolved;
 }
-// Handle ls command
-async function handleLs(requestedPath) {
+function assertSafePath(requestedPath) {
     const safePath = resolveSafePath(requestedPath);
     if (!safePath) {
-        throw new Error("Access denied: path outside root directory");
+        const error = new Error("Access denied: path outside root directory");
+        error.code = "EACCES";
+        throw error;
     }
-    const entries = await fs.readdir(safePath, { withFileTypes: true });
-    return entries.map((entry) => ({
-        name: entry.name,
-        type: entry.isDirectory() ? "directory" : "file",
-    }));
+    return safePath;
 }
-// Handle read command
-async function handleRead(requestedPath) {
-    const safePath = resolveSafePath(requestedPath);
-    if (!safePath) {
-        throw new Error("Access denied: path outside root directory");
+// ============================================================================
+// File System Handlers
+// ============================================================================
+async function handleFsLs(payload) {
+    const reqPath = payload.path || ".";
+    const safePath = assertSafePath(reqPath);
+    const entries = await fs.readdir(safePath, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+        const item = {
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file",
+        };
+        // Try to get size and mtime for files
+        if (entry.isFile()) {
+            try {
+                const stat = await fs.stat(path.join(safePath, entry.name));
+                item.size = stat.size;
+                item.mtime = stat.mtimeMs;
+            }
+            catch {
+                // Ignore stat errors
+            }
+        }
+        result.push(item);
     }
-    const content = await fs.readFile(safePath, "utf-8");
-    return content;
+    return { path: reqPath, entries: result };
 }
-// Handle write command
-async function handleWrite(requestedPath, content) {
-    const safePath = resolveSafePath(requestedPath);
-    if (!safePath) {
-        throw new Error("Access denied: path outside root directory");
+async function handleFsStat(payload) {
+    const reqPath = payload.path;
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
+    const stat = await fs.stat(safePath);
+    const result = {
+        path: reqPath,
+        type: stat.isDirectory() ? "directory" : "file",
+        size: stat.size,
+        mtime: stat.mtimeMs,
+        mode: stat.mode,
+    };
+    return result;
+}
+async function handleFsRead(payload) {
+    const reqPath = payload.path;
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
+    // Check if binary
+    const stat = await fs.stat(safePath);
+    const content = await fs.readFile(safePath);
+    // Try to detect if binary
+    const isBinary = content.includes(0x00);
+    if (isBinary) {
+        return {
+            path: reqPath,
+            content: content.toString("base64"),
+            encoding: "base64",
+            size: stat.size,
+        };
     }
-    // Ensure parent directory exists
+    return {
+        path: reqPath,
+        content: content.toString("utf-8"),
+        encoding: "utf8",
+        size: stat.size,
+    };
+}
+async function handleFsWrite(payload) {
+    const reqPath = payload.path;
+    const content = payload.content;
+    const encoding = payload.encoding || "utf8";
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    if (typeof content !== "string")
+        throw Object.assign(new Error("content is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
     const parentDir = path.dirname(safePath);
     await fs.mkdir(parentDir, { recursive: true });
-    await fs.writeFile(safePath, content, "utf-8");
+    if (encoding === "base64") {
+        await fs.writeFile(safePath, Buffer.from(content, "base64"));
+    }
+    else {
+        await fs.writeFile(safePath, content, "utf-8");
+    }
+    return { path: reqPath };
 }
-// Load gitignore patterns from a directory
+async function handleFsMkdir(payload) {
+    const reqPath = payload.path;
+    const recursive = payload.recursive !== false;
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
+    await fs.mkdir(safePath, { recursive });
+    return { path: reqPath };
+}
+async function handleFsRm(payload) {
+    const reqPath = payload.path;
+    const recursive = payload.recursive === true;
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
+    await fs.rm(safePath, { recursive, force: false });
+    return { path: reqPath };
+}
+async function handleFsMv(payload) {
+    const from = payload.from;
+    const to = payload.to;
+    if (!from)
+        throw Object.assign(new Error("from is required"), { code: "EINVAL" });
+    if (!to)
+        throw Object.assign(new Error("to is required"), { code: "EINVAL" });
+    const safeFrom = assertSafePath(from);
+    const safeTo = assertSafePath(to);
+    await fs.rename(safeFrom, safeTo);
+    return { from, to };
+}
+// Load gitignore patterns
 async function loadGitignore(dirPath) {
     const ig = ignore();
-    // Always ignore .git directory
     ig.add(".git");
     try {
         const gitignorePath = path.join(dirPath, ".gitignore");
@@ -61,20 +164,20 @@ async function loadGitignore(dirPath) {
         ig.add(content);
     }
     catch {
-        // No .gitignore file, that's fine
+        // No .gitignore
     }
     return ig;
 }
-// Handle grep command - search for pattern in files
-async function handleGrep(requestedPath, pattern, options = {}) {
-    const safePath = resolveSafePath(requestedPath);
-    if (!safePath) {
-        throw new Error("Access denied: path outside root directory");
-    }
-    const { caseSensitive = true, maxResults = 100 } = options;
+async function handleFsGrep(payload) {
+    const reqPath = payload.path || ".";
+    const pattern = payload.pattern;
+    const caseSensitive = payload.caseSensitive !== false;
+    const maxResults = payload.maxResults || 100;
+    if (!pattern)
+        throw Object.assign(new Error("pattern is required"), { code: "EINVAL" });
+    const safePath = assertSafePath(reqPath);
     const matches = [];
     const regex = new RegExp(pattern, caseSensitive ? "g" : "gi");
-    // Load root gitignore
     const rootIgnore = await loadGitignore(ROOT_DIR);
     async function searchFile(filePath, relativePath) {
         if (matches.length >= maxResults)
@@ -87,21 +190,19 @@ async function handleGrep(requestedPath, pattern, options = {}) {
                     matches.push({
                         file: relativePath,
                         line: i + 1,
-                        content: lines[i].substring(0, 500), // Limit line length
+                        content: lines[i].substring(0, 500),
                     });
                 }
-                // Reset regex lastIndex for global flag
                 regex.lastIndex = 0;
             }
         }
         catch {
-            // Skip files that can't be read (binary, permissions, etc.)
+            // Skip unreadable files
         }
     }
     async function searchDir(dirPath, relativePath, ig) {
         if (matches.length >= maxResults)
             return;
-        // Check for local .gitignore and merge with parent
         const localIgnore = ignore().add(ig);
         try {
             const localGitignorePath = path.join(dirPath, ".gitignore");
@@ -116,12 +217,9 @@ async function handleGrep(requestedPath, pattern, options = {}) {
             if (matches.length >= maxResults)
                 break;
             const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-            // Check if ignored by gitignore
-            // For directories, append / to match gitignore patterns correctly
             const checkPath = entry.isDirectory() ? `${relPath}/` : relPath;
-            if (localIgnore.ignores(checkPath)) {
+            if (localIgnore.ignores(checkPath))
                 continue;
-            }
             const fullPath = path.join(dirPath, entry.name);
             if (entry.isDirectory()) {
                 await searchDir(fullPath, relPath, localIgnore);
@@ -133,141 +231,1005 @@ async function handleGrep(requestedPath, pattern, options = {}) {
     }
     const stat = await fs.stat(safePath);
     if (stat.isDirectory()) {
-        await searchDir(safePath, requestedPath === "." ? "" : requestedPath, rootIgnore);
+        await searchDir(safePath, reqPath === "." ? "" : reqPath, rootIgnore);
     }
     else {
-        await searchFile(safePath, requestedPath);
+        await searchFile(safePath, reqPath);
     }
-    return matches;
+    return { matches };
 }
-// Handle replace command - find and replace in a file
-async function handleReplace(requestedPath, search, replace, options = {}) {
-    const safePath = resolveSafePath(requestedPath);
-    if (!safePath) {
-        throw new Error("Access denied: path outside root directory");
-    }
-    const { caseSensitive = true, replaceAll = true } = options;
-    const content = await fs.readFile(safePath, "utf-8");
-    const flags = replaceAll ? (caseSensitive ? "g" : "gi") : (caseSensitive ? "" : "i");
-    const regex = new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
-    // Count replacements
-    const matchCount = (content.match(regex) || []).length;
-    if (matchCount === 0) {
-        return { file: requestedPath, replacements: 0 };
-    }
-    const newContent = content.replace(regex, replace);
-    await fs.writeFile(safePath, newContent, "utf-8");
-    return { file: requestedPath, replacements: matchCount };
-}
-// Process incoming request from app
-async function processRequest(message) {
-    const { id, action, payload } = message;
+async function handleFsCreate(payload) {
+    const reqPath = payload.path;
+    const type = payload.type;
+    if (!reqPath)
+        throw Object.assign(new Error("path is required"), { code: "EINVAL" });
+    if (!type || (type !== "file" && type !== "directory")) {
+        throw Object.assign(new Error("type must be 'file' or 'directory'"), { code: "EINVAL" });
+    }
+    const safePath = assertSafePath(reqPath);
+    if (type === "directory") {
+        await fs.mkdir(safePath, { recursive: true });
+    }
+    else {
+        // Create parent directories if needed
+        const parentDir = path.dirname(safePath);
+        await fs.mkdir(parentDir, { recursive: true });
+        // Create empty file
+        await fs.writeFile(safePath, "");
+    }
+    return { path: reqPath };
+}
+// ============================================================================
+// Git Handlers
+// ============================================================================
+async function runGit(args) {
+    return new Promise((resolve) => {
+        const proc = spawn("git", args, { cwd: ROOT_DIR });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => (stdout += data.toString()));
+        proc.stderr.on("data", (data) => (stderr += data.toString()));
+        proc.on("close", (code) => {
+            resolve({ stdout, stderr, code: code || 0 });
+        });
+        proc.on("error", (err) => {
+            resolve({ stdout: "", stderr: err.message, code: 1 });
+        });
+    });
+}
+async function handleGitStatus() {
+    // Get branch
+    const branchResult = await runGit(["branch", "--show-current"]);
+    const branch = branchResult.stdout.trim();
+    // Get status
+    const statusResult = await runGit(["status", "--porcelain", "-uall"]);
+    const lines = statusResult.stdout.trim().split("\n").filter(Boolean);
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    for (const line of lines) {
+        const index = line[0];
+        const worktree = line[1];
+        const filepath = line.substring(3);
+        if (index === "?" && worktree === "?") {
+            untracked.push(filepath);
+        }
+        else {
+            if (index !== " " && index !== "?") {
+                staged.push({ path: filepath, status: index });
+            }
+            if (worktree !== " " && worktree !== "?") {
+                unstaged.push({ path: filepath, status: worktree });
+            }
+        }
+    }
+    // Get ahead/behind
+    const aheadBehind = await runGit(["rev-list", "--left-right", "--count", "@{u}...HEAD"]);
+    let ahead = 0;
+    let behind = 0;
+    if (aheadBehind.code === 0) {
+        const parts = aheadBehind.stdout.trim().split(/\s+/);
+        behind = parseInt(parts[0]) || 0;
+        ahead = parseInt(parts[1]) || 0;
+    }
+    return { branch, ahead, behind, staged, unstaged, untracked };
+}
+async function handleGitStage(payload) {
+    const paths = payload.paths;
+    if (!paths || !paths.length)
+        throw Object.assign(new Error("paths is required"), { code: "EINVAL" });
+    const result = await runGit(["add", ...paths]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git add failed"), { code: "EGIT" });
+    }
+    return {};
+}
+async function handleGitUnstage(payload) {
+    const paths = payload.paths;
+    if (!paths || !paths.length)
+        throw Object.assign(new Error("paths is required"), { code: "EINVAL" });
+    const result = await runGit(["reset", "HEAD", ...paths]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git reset failed"), { code: "EGIT" });
+    }
+    return {};
+}
+async function handleGitCommit(payload) {
+    const message = payload.message;
+    if (!message)
+        throw Object.assign(new Error("message is required"), { code: "EINVAL" });
+    const result = await runGit(["commit", "-m", message]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git commit failed"), { code: "EGIT" });
+    }
+    // Get the commit hash
+    const hashResult = await runGit(["rev-parse", "HEAD"]);
+    const hash = hashResult.stdout.trim().substring(0, 7);
+    return { hash, message };
+}
+async function handleGitLog(payload) {
+    const limit = payload.limit || 20;
+    const result = await runGit([
+        "log",
+        `-${limit}`,
+        "--pretty=format:%H|%s|%an|%at",
+    ]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git log failed"), { code: "EGIT" });
+    }
+    const commits = result.stdout
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        const [hash, message, author, timestamp] = line.split("|");
+        return {
+            hash: hash.substring(0, 7),
+            message,
+            author,
+            date: parseInt(timestamp) * 1000,
+        };
+    });
+    return { commits };
+}
+async function handleGitDiff(payload) {
+    const filepath = payload.path;
+    const staged = payload.staged === true;
+    const args = ["diff"];
+    if (staged)
+        args.push("--staged");
+    if (filepath)
+        args.push(filepath);
+    const result = await runGit(args);
+    return { diff: result.stdout };
+}
+async function handleGitBranches() {
+    const result = await runGit(["branch", "-a"]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git branch failed"), { code: "EGIT" });
+    }
+    const lines = result.stdout.trim().split("\n");
+    let current = "";
+    const branches = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("* ")) {
+            current = trimmed.substring(2);
+            branches.push(current);
+        }
+        else if (!trimmed.startsWith("remotes/")) {
+            branches.push(trimmed);
+        }
+    }
+    return { current, branches };
+}
+async function handleGitCheckout(payload) {
+    const branch = payload.branch;
+    const create = payload.create === true;
+    if (!branch)
+        throw Object.assign(new Error("branch is required"), { code: "EINVAL" });
+    const args = create ? ["checkout", "-b", branch] : ["checkout", branch];
+    const result = await runGit(args);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git checkout failed"), { code: "EGIT" });
+    }
+    return { branch };
+}
+async function handleGitPull() {
+    const result = await runGit(["pull"]);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git pull failed"), { code: "EGIT" });
+    }
+    return { success: true, summary: result.stdout.trim() || result.stderr.trim() };
+}
+async function handleGitPush(payload) {
+    const setUpstream = payload.setUpstream === true;
+    const args = ["push"];
+    if (setUpstream) {
+        // Get current branch name
+        const branchResult = await runGit(["branch", "--show-current"]);
+        const branch = branchResult.stdout.trim();
+        args.push("-u", "origin", branch);
+    }
+    const result = await runGit(args);
+    if (result.code !== 0) {
+        throw Object.assign(new Error(result.stderr || "git push failed"), { code: "EGIT" });
+    }
+    return { success: true };
+}
+async function handleGitDiscard(payload) {
+    const paths = payload.paths;
+    const all = payload.all === true;
+    if (!paths && !all) {
+        throw Object.assign(new Error("paths or all is required"), { code: "EINVAL" });
+    }
+    if (all) {
+        // Discard all changes
+        const result = await runGit(["checkout", "--", "."]);
+        if (result.code !== 0) {
+            throw Object.assign(new Error(result.stderr || "git checkout failed"), { code: "EGIT" });
+        }
+        // Also clean untracked files
+        await runGit(["clean", "-fd"]);
+    }
+    else if (paths && paths.length > 0) {
+        const result = await runGit(["checkout", "--", ...paths]);
+        if (result.code !== 0) {
+            throw Object.assign(new Error(result.stderr || "git checkout failed"), { code: "EGIT" });
+        }
+    }
+    return {};
+}
+// ============================================================================
+// Terminal Handlers
+// ============================================================================
+let dataChannel = null;
+function handleTerminalSpawn(payload) {
+    const shell = payload.shell || process.env.SHELL || "/bin/sh";
+    const cols = payload.cols || 80;
+    const rows = payload.rows || 24;
+    const terminalId = `term-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    const proc = spawn(shell, [], {
+        cwd: ROOT_DIR,
+        env: {
+            ...process.env,
+            TERM: "xterm-256color",
+            COLUMNS: cols.toString(),
+            LINES: rows.toString(),
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    terminals.set(terminalId, proc);
+    // Stream output to app via data channel
+    const sendOutput = (data) => {
+        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+            const msg = {
+                v: 1,
+                id: `evt-${Date.now()}`,
+                ns: "terminal",
+                action: "output",
+                payload: { terminalId, data: data.toString() },
+            };
+            dataChannel.send(JSON.stringify(msg));
+        }
+    };
+    proc.stdout?.on("data", sendOutput);
+    proc.stderr?.on("data", sendOutput);
+    proc.on("close", (code) => {
+        terminals.delete(terminalId);
+        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+            const msg = {
+                v: 1,
+                id: `evt-${Date.now()}`,
+                ns: "terminal",
+                action: "exit",
+                payload: { terminalId, code },
+            };
+            dataChannel.send(JSON.stringify(msg));
+        }
+    });
+    return { terminalId };
+}
+function handleTerminalWrite(payload) {
+    const terminalId = payload.terminalId;
+    const data = payload.data;
+    if (!terminalId)
+        throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
+    if (typeof data !== "string")
+        throw Object.assign(new Error("data is required"), { code: "EINVAL" });
+    const proc = terminals.get(terminalId);
+    if (!proc)
+        throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
+    proc.stdin?.write(data);
+    return {};
+}
+function handleTerminalResize(payload) {
+    const terminalId = payload.terminalId;
+    const cols = payload.cols;
+    const rows = payload.rows;
+    if (!terminalId)
+        throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
+    const proc = terminals.get(terminalId);
+    if (!proc)
+        throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
+    // Note: For proper PTY resize, you'd need node-pty
+    // This is a simplified version
+    return {};
+}
+function handleTerminalKill(payload) {
+    const terminalId = payload.terminalId;
+    if (!terminalId)
+        throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
+    const proc = terminals.get(terminalId);
+    if (!proc)
+        throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
+    proc.kill();
+    terminals.delete(terminalId);
+    return {};
+}
+// ============================================================================
+// System Handlers
+// ============================================================================
+function handleSystemCapabilities() {
+    return {
+        version: VERSION,
+        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http"],
+        platform: os.platform(),
+        rootDir: ROOT_DIR,
+        hostname: os.hostname(),
+    };
+}
+function handleSystemPing() {
+    return { pong: true, timestamp: Date.now() };
+}
+// ============================================================================
+// Processes Handlers
+// ============================================================================
+function handleProcessesList() {
+    const result = [];
+    for (const [pid, proc] of processes) {
+        result.push({
+            pid,
+            command: `${proc.command} ${proc.args.join(" ")}`.trim(),
+            startTime: proc.startTime,
+            status: proc.proc.killed ? "stopped" : "running",
+            channel: proc.channel,
+        });
+    }
+    return { processes: result };
+}
+function handleProcessesSpawn(payload) {
+    const command = payload.command;
+    const args = payload.args || [];
+    const cwd = payload.cwd;
+    const extraEnv = payload.env || {};
+    if (!command)
+        throw Object.assign(new Error("command is required"), { code: "EINVAL" });
+    const workDir = cwd ? assertSafePath(cwd) : ROOT_DIR;
+    const proc = spawn(command, args, {
+        cwd: workDir,
+        env: { ...process.env, ...extraEnv },
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true,
+    });
+    const pid = proc.pid;
+    const channel = `proc-${pid}`;
+    const managedProc = {
+        pid,
+        proc,
+        command,
+        args,
+        startTime: Date.now(),
+        output: [],
+        channel,
+    };
+    processes.set(pid, managedProc);
+    processOutputBuffers.set(channel, "");
+    // Stream output
+    const sendOutput = (stream) => (data) => {
+        const text = data.toString();
+        managedProc.output.push(text);
+        processOutputBuffers.set(channel, (processOutputBuffers.get(channel) || "") + text);
+        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+            const msg = {
+                v: 1,
+                id: `evt-${Date.now()}`,
+                ns: "processes",
+                action: "output",
+                payload: { pid, channel, stream, data: text },
+            };
+            dataChannel.send(JSON.stringify(msg));
+        }
+    };
+    proc.stdout?.on("data", sendOutput("stdout"));
+    proc.stderr?.on("data", sendOutput("stderr"));
+    proc.on("close", (code, signal) => {
+        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+            const msg = {
+                v: 1,
+                id: `evt-${Date.now()}`,
+                ns: "processes",
+                action: "exit",
+                payload: { pid, channel, code, signal },
+            };
+            dataChannel.send(JSON.stringify(msg));
+        }
+    });
+    return { pid, channel };
+}
+function handleProcessesKill(payload) {
+    const pid = payload.pid;
+    if (!pid)
+        throw Object.assign(new Error("pid is required"), { code: "EINVAL" });
+    const proc = processes.get(pid);
+    if (!proc)
+        throw Object.assign(new Error("Process not found"), { code: "ENOPROC" });
+    proc.proc.kill();
+    processes.delete(pid);
+    return {};
+}
+function handleProcessesGetOutput(payload) {
+    const channel = payload.channel;
+    if (!channel)
+        throw Object.assign(new Error("channel is required"), { code: "EINVAL" });
+    const output = processOutputBuffers.get(channel) || "";
+    return { channel, output };
+}
+function handleProcessesClearOutput(payload) {
+    const channel = payload.channel;
+    if (channel) {
+        processOutputBuffers.set(channel, "");
+    }
+    else {
+        processOutputBuffers.clear();
+    }
+    return {};
+}
+// ============================================================================
+// Ports Handlers
+// ============================================================================
+function handlePortsList() {
+    const platform = os.platform();
+    const ports = [];
     try {
-        switch (action) {
-            case "ls": {
-                const reqPath = payload.path || ".";
-                const entries = await handleLs(reqPath);
-                return {
-                    id,
-                    type: "response",
-                    action: "ls",
-                    payload: { path: reqPath, entries },
-                };
+        let output;
+        if (platform === "darwin" || platform === "linux") {
+            // Use lsof on macOS/Linux
+            try {
+                output = execSync("lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null || true", {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                });
+                const lines = output.trim().split("\n").slice(1); // Skip header
+                for (const line of lines) {
+                    const parts = line.split(/\s+/);
+                    if (parts.length >= 9) {
+                        const processName = parts[0];
+                        const pid = parseInt(parts[1]);
+                        const nameField = parts[8];
+                        // Parse address:port format
+                        const match = nameField.match(/:(\d+)$/);
+                        if (match) {
+                            const port = parseInt(match[1]);
+                            const address = nameField.replace(`:${port}`, "") || "0.0.0.0";
+                            ports.push({ port, pid, process: processName, address });
+                        }
+                    }
+                }
+            }
+            catch {
+                // lsof might fail, try netstat
+                output = execSync("netstat -tlnp 2>/dev/null || netstat -an 2>/dev/null || true", {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                });
             }
-            case "read": {
-                const reqPath = payload.path;
-                if (!reqPath) {
-                    throw new Error("path is required");
+        }
+        else if (platform === "win32") {
+            output = execSync("netstat -ano | findstr LISTENING", {
+                encoding: "utf-8",
+                timeout: 5000,
+            });
+            const lines = output.trim().split("\n");
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 5) {
+                    const localAddr = parts[1];
+                    const pid = parseInt(parts[4]);
+                    const match = localAddr.match(/:(\d+)$/);
+                    if (match) {
+                        const port = parseInt(match[1]);
+                        const address = localAddr.replace(`:${port}`, "");
+                        ports.push({ port, pid, process: "unknown", address });
+                    }
                 }
-                const content = await handleRead(reqPath);
-                return {
-                    id,
-                    type: "response",
-                    action: "read",
-                    payload: { path: reqPath, content },
-                };
             }
-            case "write": {
-                const reqPath = payload.path;
-                const content = payload.content;
-                if (!reqPath) {
-                    throw new Error("path is required");
+        }
+    }
+    catch {
+        // Return empty list on error
+    }
+    return { ports };
+}
+function handlePortsIsAvailable(payload) {
+    const port = payload.port;
+    if (!port)
+        throw Object.assign(new Error("port is required"), { code: "EINVAL" });
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+                resolve({ port, available: false });
+            }
+            else {
+                resolve({ port, available: false, error: err.message });
+            }
+        });
+        server.once("listening", () => {
+            server.close(() => {
+                resolve({ port, available: true });
+            });
+        });
+        server.listen(port, "127.0.0.1");
+    });
+}
+function handlePortsKill(payload) {
+    const port = payload.port;
+    if (!port)
+        throw Object.assign(new Error("port is required"), { code: "EINVAL" });
+    const platform = os.platform();
+    try {
+        let pid = null;
+        if (platform === "darwin" || platform === "linux") {
+            const output = execSync(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf-8" });
+            const pids = output.trim().split("\n").filter(Boolean);
+            if (pids.length > 0) {
+                pid = parseInt(pids[0]);
+                execSync(`kill -9 ${pids.join(" ")}`, { encoding: "utf-8" });
+            }
+        }
+        else if (platform === "win32") {
+            const output = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+            const lines = output.trim().split("\n");
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 5) {
+                    pid = parseInt(parts[4]);
+                    execSync(`taskkill /F /PID ${pid}`, { encoding: "utf-8" });
+                    break;
                 }
-                if (typeof content !== "string") {
-                    throw new Error("content is required");
+            }
+        }
+        return { port, pid };
+    }
+    catch (err) {
+        throw Object.assign(new Error(`Failed to kill process on port ${port}`), { code: "EPERM" });
+    }
+}
+// ============================================================================
+// Monitor Handlers
+// ============================================================================
+function getCpuUsage() {
+    const cpus = os.cpus();
+    const coreUsages = [];
+    let totalIdle = 0;
+    let totalTick = 0;
+    for (let i = 0; i < cpus.length; i++) {
+        const cpu = cpus[i];
+        const total = Object.values(cpu.times).reduce((a, b) => a + b, 0);
+        const idle = cpu.times.idle;
+        if (lastCpuInfo && lastCpuInfo[i]) {
+            const deltaTotal = total - lastCpuInfo[i].total;
+            const deltaIdle = idle - lastCpuInfo[i].idle;
+            const usage = deltaTotal > 0 ? ((deltaTotal - deltaIdle) / deltaTotal) * 100 : 0;
+            coreUsages.push(Math.round(usage * 10) / 10);
+        }
+        else {
+            coreUsages.push(0);
+        }
+        totalIdle += idle;
+        totalTick += total;
+    }
+    // Update last CPU info for next calculation
+    lastCpuInfo = cpus.map((cpu) => ({
+        idle: cpu.times.idle,
+        total: Object.values(cpu.times).reduce((a, b) => a + b, 0),
+    }));
+    const avgUsage = coreUsages.length > 0
+        ? coreUsages.reduce((a, b) => a + b, 0) / coreUsages.length
+        : 0;
+    return { usage: Math.round(avgUsage * 10) / 10, cores: coreUsages };
+}
+function getMemoryInfo() {
+    const total = os.totalmem();
+    const free = os.freemem();
+    const used = total - free;
+    const usedPercent = Math.round((used / total) * 1000) / 10;
+    return { total, used, free, usedPercent };
+}
+function getDiskInfo() {
+    const platform = os.platform();
+    const disks = [];
+    try {
+        if (platform === "darwin" || platform === "linux") {
+            const output = execSync("df -k 2>/dev/null || true", { encoding: "utf-8" });
+            const lines = output.trim().split("\n").slice(1);
+            for (const line of lines) {
+                const parts = line.split(/\s+/);
+                if (parts.length >= 6) {
+                    const filesystem = parts[0];
+                    const size = parseInt(parts[1]) * 1024;
+                    const used = parseInt(parts[2]) * 1024;
+                    const free = parseInt(parts[3]) * 1024;
+                    const mount = parts[5];
+                    // Skip special filesystems
+                    if (mount.startsWith("/") && !filesystem.startsWith("devfs") && !filesystem.startsWith("map ")) {
+                        disks.push({
+                            mount,
+                            filesystem,
+                            size,
+                            used,
+                            free,
+                            usedPercent: size > 0 ? Math.round((used / size) * 1000) / 10 : 0,
+                        });
+                    }
                 }
-                await handleWrite(reqPath, content);
-                return {
-                    id,
-                    type: "response",
-                    action: "write",
-                    payload: { path: reqPath, success: true },
-                };
             }
-            case "grep": {
-                const reqPath = payload.path || ".";
-                const pattern = payload.pattern;
-                if (!pattern) {
-                    throw new Error("pattern is required");
+        }
+        else if (platform === "win32") {
+            const output = execSync("wmic logicaldisk get size,freespace,caption", { encoding: "utf-8" });
+            const lines = output.trim().split("\n").slice(1);
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 3) {
+                    const mount = parts[0];
+                    const free = parseInt(parts[1]) || 0;
+                    const size = parseInt(parts[2]) || 0;
+                    const used = size - free;
+                    if (size > 0) {
+                        disks.push({
+                            mount,
+                            filesystem: "NTFS",
+                            size,
+                            used,
+                            free,
+                            usedPercent: Math.round((used / size) * 1000) / 10,
+                        });
+                    }
                 }
-                const matches = await handleGrep(reqPath, pattern, {
-                    caseSensitive: payload.caseSensitive,
-                    maxResults: payload.maxResults,
-                });
+            }
+        }
+    }
+    catch {
+        // Return empty on error
+    }
+    return disks;
+}
+function getBatteryInfo() {
+    const platform = os.platform();
+    try {
+        if (platform === "darwin") {
+            const output = execSync("pmset -g batt 2>/dev/null || true", { encoding: "utf-8" });
+            const percentMatch = output.match(/(\d+)%/);
+            const chargingMatch = output.match(/AC Power|charging|charged/i);
+            const timeMatch = output.match(/(\d+):(\d+) remaining/);
+            if (percentMatch) {
                 return {
-                    id,
-                    type: "response",
-                    action: "grep",
-                    payload: { path: reqPath, pattern, matches },
+                    hasBattery: true,
+                    percent: parseInt(percentMatch[1]),
+                    charging: !!chargingMatch,
+                    timeRemaining: timeMatch ? parseInt(timeMatch[1]) * 60 + parseInt(timeMatch[2]) : null,
                 };
             }
-            case "replace": {
-                const reqPath = payload.path;
-                const search = payload.search;
-                const replaceWith = payload.replace;
-                if (!reqPath) {
-                    throw new Error("path is required");
-                }
-                if (!search) {
-                    throw new Error("search is required");
+        }
+        else if (platform === "linux") {
+            try {
+                const capacityPath = "/sys/class/power_supply/BAT0/capacity";
+                const statusPath = "/sys/class/power_supply/BAT0/status";
+                const capacity = parseInt(execSync(`cat ${capacityPath} 2>/dev/null || echo 0`, { encoding: "utf-8" }).trim());
+                const status = execSync(`cat ${statusPath} 2>/dev/null || echo Unknown`, { encoding: "utf-8" }).trim();
+                if (capacity > 0) {
+                    return {
+                        hasBattery: true,
+                        percent: capacity,
+                        charging: status === "Charging" || status === "Full",
+                        timeRemaining: null,
+                    };
                 }
-                if (typeof replaceWith !== "string") {
-                    throw new Error("replace is required");
+            }
+            catch {
+                // No battery
+            }
+        }
+        else if (platform === "win32") {
+            const output = execSync("WMIC Path Win32_Battery Get EstimatedChargeRemaining,BatteryStatus 2>nul || echo", { encoding: "utf-8" });
+            const lines = output.trim().split("\n").slice(1);
+            if (lines.length > 0) {
+                const parts = lines[0].trim().split(/\s+/);
+                if (parts.length >= 2) {
+                    const status = parseInt(parts[0]);
+                    const percent = parseInt(parts[1]);
+                    return {
+                        hasBattery: true,
+                        percent: percent || 0,
+                        charging: status === 2 || status === 6, // Charging or Charging High
+                        timeRemaining: null,
+                    };
                 }
-                const result = await handleReplace(reqPath, search, replaceWith, {
-                    caseSensitive: payload.caseSensitive,
-                    replaceAll: payload.replaceAll,
-                });
-                return {
-                    id,
-                    type: "response",
-                    action: "replace",
-                    payload: { ...result },
-                };
             }
+        }
+    }
+    catch {
+        // No battery or error
+    }
+    return { hasBattery: false, percent: 0, charging: false, timeRemaining: null };
+}
+function handleMonitorSystem() {
+    return {
+        cpu: getCpuUsage(),
+        memory: getMemoryInfo(),
+        disk: getDiskInfo(),
+        battery: getBatteryInfo(),
+    };
+}
+function handleMonitorCpu() {
+    const cpuInfo = getCpuUsage();
+    const cpus = os.cpus();
+    return {
+        ...cpuInfo,
+        model: cpus[0]?.model || "Unknown",
+        speed: cpus[0]?.speed || 0,
+    };
+}
+function handleMonitorMemory() {
+    return getMemoryInfo();
+}
+function handleMonitorDisk() {
+    return { disks: getDiskInfo() };
+}
+function handleMonitorBattery() {
+    return getBatteryInfo();
+}
+// ============================================================================
+// HTTP Handlers
+// ============================================================================
+async function handleHttpRequest(payload) {
+    const method = payload.method || "GET";
+    const url = payload.url;
+    const headers = payload.headers || {};
+    const body = payload.body;
+    const timeout = payload.timeout || 30000;
+    if (!url)
+        throw Object.assign(new Error("url is required"), { code: "EINVAL" });
+    const startTime = Date.now();
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body || undefined,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+            responseHeaders[key] = value;
+        });
+        const responseBody = await response.text();
+        const timing = Date.now() - startTime;
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            body: responseBody,
+            timing,
+        };
+    }
+    catch (err) {
+        const error = err;
+        if (error.name === "AbortError") {
+            throw Object.assign(new Error("Request timed out"), { code: "ETIMEOUT" });
+        }
+        throw Object.assign(new Error(error.message || "Network error"), { code: "ENETWORK" });
+    }
+}
+// ============================================================================
+// Message Router
+// ============================================================================
+async function processMessage(message) {
+    const { v, id, ns, action, payload } = message;
+    // Validate protocol version
+    if (v !== 1) {
+        return {
+            v: 1,
+            id,
+            ns,
+            action,
+            ok: false,
+            payload: {},
+            error: { code: "EPROTO", message: `Unsupported protocol version: ${v}` },
+        };
+    }
+    try {
+        let result;
+        switch (ns) {
+            case "system":
+                switch (action) {
+                    case "capabilities":
+                        result = handleSystemCapabilities();
+                        break;
+                    case "ping":
+                        result = handleSystemPing();
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "fs":
+                switch (action) {
+                    case "ls":
+                        result = await handleFsLs(payload);
+                        break;
+                    case "stat":
+                        result = await handleFsStat(payload);
+                        break;
+                    case "read":
+                        result = await handleFsRead(payload);
+                        break;
+                    case "write":
+                        result = await handleFsWrite(payload);
+                        break;
+                    case "mkdir":
+                        result = await handleFsMkdir(payload);
+                        break;
+                    case "rm":
+                        result = await handleFsRm(payload);
+                        break;
+                    case "mv":
+                        result = await handleFsMv(payload);
+                        break;
+                    case "grep":
+                        result = await handleFsGrep(payload);
+                        break;
+                    case "create":
+                        result = await handleFsCreate(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "git":
+                switch (action) {
+                    case "status":
+                        result = await handleGitStatus();
+                        break;
+                    case "stage":
+                        result = await handleGitStage(payload);
+                        break;
+                    case "unstage":
+                        result = await handleGitUnstage(payload);
+                        break;
+                    case "commit":
+                        result = await handleGitCommit(payload);
+                        break;
+                    case "log":
+                        result = await handleGitLog(payload);
+                        break;
+                    case "diff":
+                        result = await handleGitDiff(payload);
+                        break;
+                    case "branches":
+                        result = await handleGitBranches();
+                        break;
+                    case "checkout":
+                        result = await handleGitCheckout(payload);
+                        break;
+                    case "pull":
+                        result = await handleGitPull();
+                        break;
+                    case "push":
+                        result = await handleGitPush(payload);
+                        break;
+                    case "discard":
+                        result = await handleGitDiscard(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "terminal":
+                switch (action) {
+                    case "spawn":
+                        result = handleTerminalSpawn(payload);
+                        break;
+                    case "write":
+                        result = handleTerminalWrite(payload);
+                        break;
+                    case "resize":
+                        result = handleTerminalResize(payload);
+                        break;
+                    case "kill":
+                        result = handleTerminalKill(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "processes":
+                switch (action) {
+                    case "list":
+                        result = handleProcessesList();
+                        break;
+                    case "spawn":
+                        result = handleProcessesSpawn(payload);
+                        break;
+                    case "kill":
+                        result = handleProcessesKill(payload);
+                        break;
+                    case "getOutput":
+                        result = handleProcessesGetOutput(payload);
+                        break;
+                    case "clearOutput":
+                        result = handleProcessesClearOutput(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "ports":
+                switch (action) {
+                    case "list":
+                        result = handlePortsList();
+                        break;
+                    case "isAvailable":
+                        result = await handlePortsIsAvailable(payload);
+                        break;
+                    case "kill":
+                        result = handlePortsKill(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "monitor":
+                switch (action) {
+                    case "system":
+                        result = handleMonitorSystem();
+                        break;
+                    case "cpu":
+                        result = handleMonitorCpu();
+                        break;
+                    case "memory":
+                        result = handleMonitorMemory();
+                        break;
+                    case "disk":
+                        result = handleMonitorDisk();
+                        break;
+                    case "battery":
+                        result = handleMonitorBattery();
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
+            case "http":
+                switch (action) {
+                    case "request":
+                        result = await handleHttpRequest(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
             default:
-                throw new Error(`Unknown action: ${action}`);
+                throw Object.assign(new Error(`Unknown namespace: ${ns}`), { code: "EINVAL" });
         }
+        return { v: 1, id, ns, action, ok: true, payload: result };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        const err = error;
         return {
+            v: 1,
             id,
-            type: "error",
+            ns,
             action,
-            payload: {
-                code: error.code || "ERROR",
-                message: errorMessage,
+            ok: false,
+            payload: {},
+            error: {
+                code: err.code || "ERROR",
+                message: err.message || "Unknown error",
             },
         };
     }
 }
+// ============================================================================
+// WebSocket Connection
+// ============================================================================
 async function createSession() {
     const response = await fetch(`${PROXY_URL}/v1/session`, {
         method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
+        headers: { "Content-Type": "application/json" },
     });
     if (!response.ok) {
         throw new Error(`Failed to create session: ${response.status}`);
@@ -286,13 +1248,29 @@ function displayQR(code) {
     });
 }
 function connectWebSocket(code) {
-    const wsUrl = PROXY_URL.replace(/^http/, "ws") + `/v1/ws/cli?code=${code}`;
+    const wsBase = PROXY_URL.replace(/^http/, "ws");
+    const controlUrl = `${wsBase}/v1/ws/cli/control?code=${code}`;
+    const dataUrl = `${wsBase}/v1/ws/cli/data?code=${code}`;
     console.log("Connecting to proxy...");
-    const ws = new WebSocket(wsUrl);
-    ws.on("open", () => {
-        console.log("Connected to proxy. Waiting for app...\n");
+    // Control channel
+    const controlWs = new WebSocket(controlUrl);
+    let controlConnected = false;
+    // Data channel
+    const dataWs = new WebSocket(dataUrl);
+    let dataConnected = false;
+    // Store data channel reference for terminal output
+    dataChannel = dataWs;
+    function checkFullyConnected() {
+        if (controlConnected && dataConnected) {
+            console.log("Connected to proxy (control + data channels). Waiting for app...\n");
+        }
+    }
+    // Control channel handlers
+    controlWs.on("open", () => {
+        controlConnected = true;
+        checkFullyConnected();
     });
-    ws.on("message", async (data) => {
+    controlWs.on("message", async (data) => {
         try {
             const message = JSON.parse(data.toString());
             // Handle system messages
@@ -307,38 +1285,76 @@ function connectWebSocket(code) {
                 console.log("App disconnected.\n");
                 return;
             }
-            // Handle file operation requests
-            if (message.type === "request") {
-                const response = await processRequest(message);
-                ws.send(JSON.stringify(response));
+            // Handle v1 protocol messages
+            if (message.v === 1) {
+                const response = await processMessage(message);
+                controlWs.send(JSON.stringify(response));
             }
-            // Handle proxy errors
-            if (message.type === "error" && !("action" in message)) {
-                console.error("Proxy error:", message.payload?.message);
+        }
+        catch (error) {
+            console.error("Error processing control message:", error);
+        }
+    });
+    controlWs.on("close", (code, reason) => {
+        console.log(`\nControl channel disconnected (${code}: ${reason.toString()})`);
+        dataWs.close();
+        process.exit(0);
+    });
+    controlWs.on("error", (error) => {
+        console.error("Control WebSocket error:", error.message);
+    });
+    // Data channel handlers
+    dataWs.on("open", () => {
+        dataConnected = true;
+        checkFullyConnected();
+    });
+    dataWs.on("message", async (data) => {
+        try {
+            const message = JSON.parse(data.toString());
+            // Handle system messages
+            if (message.type === "connected") {
                 return;
             }
+            // Handle v1 protocol messages
+            if (message.v === 1) {
+                const response = await processMessage(message);
+                dataWs.send(JSON.stringify(response));
+            }
         }
         catch (error) {
-            console.error("Error processing message:", error);
+            console.error("Error processing data message:", error);
         }
     });
-    ws.on("close", (code, reason) => {
-        console.log(`\nDisconnected from proxy (${code}: ${reason.toString()})`);
+    dataWs.on("close", (code, reason) => {
+        console.log(`\nData channel disconnected (${code}: ${reason.toString()})`);
+        controlWs.close();
         process.exit(0);
     });
-    ws.on("error", (error) => {
-        console.error("WebSocket error:", error.message);
+    dataWs.on("error", (error) => {
+        console.error("Data WebSocket error:", error.message);
     });
     // Handle graceful shutdown
     process.on("SIGINT", () => {
         console.log("\nShutting down...");
-        ws.close();
+        // Kill all terminals
+        for (const [id, proc] of terminals) {
+            proc.kill();
+        }
+        terminals.clear();
+        // Kill all managed processes
+        for (const [pid, managedProc] of processes) {
+            managedProc.proc.kill();
+        }
+        processes.clear();
+        processOutputBuffers.clear();
+        controlWs.close();
+        dataWs.close();
         process.exit(0);
     });
 }
 async function main() {
-    console.log("Lunel CLI");
-    console.log("=========\n");
+    console.log("Lunel CLI v" + VERSION);
+    console.log("=".repeat(20) + "\n");
     try {
         const code = await createSession();
         displayQR(code);