leduo-patrol 2.0.1 → 2.2.3

package/dist/server/index.js

@@ -2,6 +2,7 @@
 import express from "express";
 import { access, readdir } from "node:fs/promises";
 import path from "node:path";
+import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 import { userInfo } from "node:os";
@@ -10,9 +11,10 @@ import { SessionManager } from "./session-manager.js";
 import { formatError, resolveAllowedPath } from "./server-helpers.js";
 import { ShellSession } from "./shell-session.js";
 import { buildSingleFileDiff, buildWorkspaceDiffFilesSnapshot } from "./git-diff.js";
-import { buildAccessCookie, createAccessKey, hasAuthorizedAccessCookie, isAccessKeyAuthorized } from "./access-key.js";
+import { buildAccessCookie, hasAuthorizedAccessCookie, isAccessKeyAuthorized } from "./access-key.js";
 import { findAvailablePort, pickPreferredLanIp } from "./network.js";
 import { resolveBindMode } from "./launch-mode.js";
+import { resolveAccessKey } from "./access-key-prompt.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const launchCwd = process.cwd();
 const defaultWorkspacePath = process.env.LEDUO_PATROL_WORKSPACE_PATH ?? launchCwd;
@@ -34,8 +36,9 @@ const listenHost = bindMode === "local" ? "127.0.0.1" : "0.0.0.0";
 const launchHost = bindMode === "local" ? "127.0.0.1" : pickPreferredLanIp();
 const launchUser = userInfo().username;
 const claudeBin = process.env.LEDUO_PATROL_CLAUDE_BIN?.trim() || undefined;
-const accessKey = process.env.LEDUO_PATROL_ACCESS_KEY?.trim() || createAccessKey();
-const enableShell = process.env.LEDUO_ENABLE_SHELL === "true";
+const agentBinPath = resolveAgentBinPath();
+const accessKey = await resolveAccessKey();
+const enableShell = parseBooleanFlag(process.env.LEDUO_ENABLE_SHELL, true);
 const allowSkipPermissions = process.env.LEDUO_PATROL_ALLOW_SKIP_PERMISSIONS === "true";
 const app = express();
 const server = createServer(app);
@@ -43,6 +46,7 @@ const wss = new WebSocketServer({ server, path: "/ws" });
 const sessionManager = new SessionManager({
     allowedRoots,
     claudeBin,
+    agentBinPath,
     allowSkipPermissions,
 });
 await sessionManager.initialize();
@@ -86,11 +90,29 @@ app.get("/api/config", (_req, res) => {
         launchHost,
         launchUser,
         allowSkipPermissions,
+        availableSessionEngines: sessionManager.getAvailableEngines(),
+        defaultSessionEngine: "cli",
     });
 });
 app.get("/api/state", (_req, res) => {
     res.json(sessionManager.getStateSnapshot());
 });
+app.get("/api/session-history", (req, res) => {
+    try {
+        const clientSessionId = typeof req.query.clientSessionId === "string" ? req.query.clientSessionId : "";
+        const before = Number(req.query.before ?? 0);
+        const limit = Number(req.query.limit ?? 120);
+        if (!clientSessionId) {
+            throw new Error("clientSessionId is required");
+        }
+        res.json(sessionManager.getSessionHistory(clientSessionId, before, limit));
+    }
+    catch (error) {
+        res.status(400).json({
+            message: formatError(error),
+        });
+    }
+});
 app.get("/api/session-diff/files", async (req, res) => {
     try {
         const clientSessionId = typeof req.query.clientSessionId === "string" ? req.query.clientSessionId : "";
@@ -174,8 +196,17 @@ wss.on("connection", (socket, request) => {
         socket.close(1008, "Unauthorized");
         return;
     }
-    const unsubscribe = sessionManager.subscribe((event) => sendEvent(socket, event));
-    let shellSession = null;
+    const shellSessions = new Map();
+    const unsubscribe = sessionManager.subscribe((event) => {
+        if (event.type === "session_closed") {
+            const shellSession = shellSessions.get(event.payload.clientSessionId);
+            if (shellSession) {
+                shellSession.kill();
+                shellSessions.delete(event.payload.clientSessionId);
+            }
+        }
+        sendEvent(socket, event);
+    });
     socket.on("message", async (raw) => {
         try {
             const message = JSON.parse(String(raw));
@@ -187,7 +218,25 @@ wss.on("connection", (socket, request) => {
                     });
                     break;
                 case "create_session":
-                    await sessionManager.createSession(message.payload.workspacePath, message.payload.title, message.payload.allowSkipPermissions);
+                    await sessionManager.createSession(message.payload.workspacePath, message.payload.title, message.payload.allowSkipPermissions, message.payload.engine ?? "cli");
+                    break;
+                case "switch_engine":
+                    await sessionManager.switchEngine(message.payload.clientSessionId, message.payload.engine);
+                    break;
+                case "prompt":
+                    await sessionManager.prompt(message.payload.clientSessionId, message.payload.text, message.payload.modeId, message.payload.images);
+                    break;
+                case "set_mode":
+                    await sessionManager.setSessionMode(message.payload.clientSessionId, message.payload.modeId);
+                    break;
+                case "cancel":
+                    await sessionManager.cancel(message.payload.clientSessionId);
+                    break;
+                case "permission":
+                    await sessionManager.resolvePermission(message.payload.clientSessionId, message.payload.requestId, message.payload.optionId, message.payload.note);
+                    break;
+                case "answer_question":
+                    await sessionManager.answerQuestion(message.payload.clientSessionId, message.payload.questionId, message.payload.answer);
                     break;
                 case "close_session":
                     await sessionManager.closeSession(message.payload.clientSessionId);
@@ -215,40 +264,44 @@ wss.on("connection", (socket, request) => {
                     if (!enableShell) {
                         throw new Error("Shell feature is disabled. Set LEDUO_ENABLE_SHELL=true to enable it.");
                     }
-                    shellSession?.kill();
-                    shellSession = null;
+                    const clientSessionId = message.payload.clientSessionId;
+                    const existingShell = shellSessions.get(clientSessionId);
                     const cols = Math.max(2, message.payload.cols);
                     const rows = Math.max(2, message.payload.rows);
-                    const shellWorkspacePath = sessionManager.getSessionWorkspacePath(message.payload.clientSessionId);
+                    if (existingShell?.alive) {
+                        existingShell.resize(cols, rows);
+                        break;
+                    }
+                    const shellWorkspacePath = sessionManager.getSessionWorkspacePath(clientSessionId);
                     const newShell = new ShellSession(shellWorkspacePath, cols, rows);
-                    shellSession = newShell;
+                    shellSessions.set(clientSessionId, newShell);
                     newShell.on("output", (data) => {
                         if (socket.readyState === WebSocket.OPEN) {
-                            socket.send(JSON.stringify({ type: "shell_output", payload: { data } }));
+                            socket.send(JSON.stringify({ type: "shell_output", payload: { clientSessionId, data } }));
                         }
                     });
                     newShell.on("exit", (exitCode) => {
-                        if (shellSession === newShell) {
-                            shellSession = null;
+                        if (shellSessions.get(clientSessionId) === newShell) {
+                            shellSessions.delete(clientSessionId);
                         }
                         if (socket.readyState === WebSocket.OPEN) {
-                            socket.send(JSON.stringify({ type: "shell_exited", payload: { exitCode } }));
+                            socket.send(JSON.stringify({ type: "shell_exited", payload: { clientSessionId, exitCode } }));
                         }
                     });
                     break;
                 }
                 case "shell_input":
-                    if (!shellSession?.alive) {
+                    if (!shellSessions.get(message.payload.clientSessionId)?.alive) {
                         throw new Error("Shell is not running");
                     }
-                    shellSession.write(message.payload.data);
+                    shellSessions.get(message.payload.clientSessionId)?.write(message.payload.data);
                     break;
                 case "shell_resize":
-                    shellSession?.resize(message.payload.cols, message.payload.rows);
+                    shellSessions.get(message.payload.clientSessionId)?.resize(message.payload.cols, message.payload.rows);
                     break;
                 case "shell_stop":
-                    shellSession?.kill();
-                    shellSession = null;
+                    shellSessions.get(message.payload.clientSessionId)?.kill();
+                    shellSessions.delete(message.payload.clientSessionId);
                     break;
             }
         }
@@ -261,8 +314,10 @@ wss.on("connection", (socket, request) => {
     });
     socket.on("close", () => {
         unsubscribe();
-        shellSession?.kill();
-        shellSession = null;
+        for (const shellSession of shellSessions.values()) {
+            shellSession.kill();
+        }
+        shellSessions.clear();
     });
 });
 const listenPort = await findAvailablePort(requestedPort, listenHost);
@@ -286,6 +341,7 @@ else {
     console.log("Web UI is unavailable on this start because bundled assets are missing.");
 }
 console.log(`Access URL: http://${displayHost}:${accessPort}/?key=${accessKey}`);
+console.log(`Shell feature: ${enableShell ? "enabled" : "disabled"}`);
 function sendEvent(socket, event) {
     if (socket.readyState !== WebSocket.OPEN) {
         return;
@@ -301,3 +357,30 @@ async function hasReadableFile(filePath) {
         return false;
     }
 }
+function parseBooleanFlag(rawValue, defaultValue) {
+    if (rawValue == null || rawValue.trim() === "") {
+        return defaultValue;
+    }
+    const normalized = rawValue.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return defaultValue;
+}
+function resolveAgentBinPath() {
+    if (process.env.LEDUO_PATROL_AGENT_BIN?.trim()) {
+        return process.env.LEDUO_PATROL_AGENT_BIN.trim();
+    }
+    const require = createRequire(import.meta.url);
+    try {
+        const pkgPath = require.resolve("@zed-industries/claude-code-acp/package.json");
+        const pkgDir = path.dirname(pkgPath);
+        return path.join(pkgDir, "dist", "index.js");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/launch-mode.js

@@ -1,9 +1,6 @@
-import os from "node:os";
-import path from "node:path";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import readline from "node:readline/promises";
+import { loadStartupPreferences, saveStartupPreferences } from "./startup-preferences.js";
 const DEFAULT_MODE = "server";
-const PREFS_FILE_PATH = path.join(os.homedir(), ".leduo-patrol", "launch-preferences.json");
 export async function resolveBindMode(options = {}) {
     const argv = options.argv ?? process.argv.slice(2);
     const stdin = options.stdin ?? process.stdin;
@@ -41,7 +38,7 @@ function parseBindMode(raw) {
     }
     return null;
 }
-function readOptionValue(argv, optionName) {
+export function readOptionValue(argv, optionName) {
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === optionName) {
@@ -77,12 +74,8 @@ async function promptShouldRemember(stdin, stdout) {
     }
 }
 async function loadRememberedMode() {
-    if (!(await isReadable(PREFS_FILE_PATH))) {
-        return null;
-    }
     try {
-        const raw = await readFile(PREFS_FILE_PATH, "utf8");
-        const parsed = JSON.parse(raw);
+        const parsed = (await loadStartupPreferences());
         return parseBindMode(parsed.bindMode ?? "");
     }
     catch {
@@ -90,18 +83,7 @@ async function loadRememberedMode() {
     }
 }
 async function saveRememberedMode(mode) {
-    await mkdir(path.dirname(PREFS_FILE_PATH), { recursive: true });
-    const payload = { bindMode: mode };
-    await writeFile(PREFS_FILE_PATH, JSON.stringify(payload, null, 2), "utf8");
-}
-async function isReadable(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    await saveStartupPreferences({ bindMode: mode });
 }
 export const launchModeTestables = {
     parseBindMode,

package/dist/server/pty-runtime.js

@@ -0,0 +1,28 @@
+import { chmodSync, existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function ensureNodePtySpawnHelperExecutable() {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    const helperPath = resolveNodePtySpawnHelperPath();
+    if (!helperPath) {
+        return;
+    }
+    ensureExecutableBit(helperPath);
+}
+export function resolveNodePtySpawnHelperPath() {
+    const packageJsonPath = require.resolve("node-pty/package.json");
+    const packageRoot = path.dirname(packageJsonPath);
+    const helperPath = path.join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+    return existsSync(helperPath) ? helperPath : null;
+}
+export function ensureExecutableBit(filePath) {
+    const stats = statSync(filePath);
+    if ((stats.mode & 0o111) === 0o111) {
+        return false;
+    }
+    chmodSync(filePath, stats.mode | 0o755);
+    return true;
+}