leduo-patrol 2.2.1 → 2.2.3

package/dist/server/acp-session.js

@@ -0,0 +1,476 @@
+import { randomUUID } from "node:crypto";
+import * as childProcess from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+import { buildSpawnFailureMessage } from "./server-helpers.js";
+export const acpSessionTestables = {
+    spawnAgent(agentBinPath, options) {
+        return childProcess.spawn(agentBinPath, [], options);
+    },
+};
+export class ClaudeAcpSession {
+    workspacePath;
+    agentBinPath;
+    claudeBin;
+    onEvent;
+    pendingPermissions = new Map();
+    pendingQuestions = new Map();
+    agentProcess = null;
+    connection = null;
+    sessionId = null;
+    activePrompt = false;
+    disposing = false;
+    connectPromise = null;
+    sessionPromise = null;
+    currentModeId = null;
+    drainTimer = null;
+    drainResolve = null;
+    static DRAIN_QUIET_MS = 200;
+    constructor(options) {
+        this.workspacePath = options.workspacePath;
+        this.agentBinPath = options.agentBinPath;
+        this.claudeBin = options.claudeBin;
+        this.onEvent = options.onEvent;
+    }
+    async connect() {
+        if (this.connectPromise) {
+            await this.connectPromise;
+            return;
+        }
+        if (this.connection) {
+            this.emitReady();
+            return;
+        }
+        this.connectPromise = (async () => {
+            await mkdir(this.workspacePath, { recursive: true });
+            const agentEnv = {
+                ...process.env,
+                ...(this.claudeBin ? { CLAUDE_CODE_EXECUTABLE: this.claudeBin } : undefined),
+            };
+            try {
+                this.agentProcess = acpSessionTestables.spawnAgent(this.agentBinPath, {
+                    cwd: this.workspacePath,
+                    env: agentEnv,
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+            }
+            catch (error) {
+                throw new Error(this.buildAgentSpawnFailureMessage(error));
+            }
+            let startupComplete = false;
+            let processHandled = false;
+            let rejectStartup = null;
+            const startupFailure = new Promise((_, reject) => {
+                rejectStartup = reject;
+            });
+            const handleAgentFailure = (error) => {
+                if (processHandled) {
+                    return;
+                }
+                processHandled = true;
+                this.connection = null;
+                this.sessionId = null;
+                this.sessionPromise = null;
+                this.connectPromise = null;
+                this.currentModeId = null;
+                this.activePrompt = false;
+                this.clearDrain();
+                this.rejectPendingPermissions(new Error("Permission request cancelled because ACP agent stopped."));
+                this.rejectPendingQuestions(new Error("Question cancelled because ACP agent stopped."));
+                this.agentProcess = null;
+                if (this.disposing) {
+                    this.disposing = false;
+                    if (!startupComplete) {
+                        rejectStartup?.(error);
+                        rejectStartup = null;
+                    }
+                    return;
+                }
+                if (!startupComplete) {
+                    rejectStartup?.(error);
+                    rejectStartup = null;
+                    return;
+                }
+                this.onEvent({
+                    type: "error",
+                    payload: { message: error.message, fatal: true },
+                });
+            };
+            this.agentProcess.stderr.on("data", (chunk) => {
+                const message = chunk.toString().trim();
+                if (!message || this.shouldIgnoreAgentStderr(message) || this.shouldIgnoreToolOutputLog(message)) {
+                    return;
+                }
+                this.onEvent({ type: "error", payload: { message, fatal: false } });
+            });
+            this.agentProcess.on("error", (error) => {
+                handleAgentFailure(new Error(this.buildAgentSpawnFailureMessage(error)));
+            });
+            this.agentProcess.on("exit", (code, signal) => {
+                handleAgentFailure(new Error(`Claude ACP agent exited (${code ?? "null"} / ${signal ?? "null"}).`));
+            });
+            const input = Writable.toWeb(this.agentProcess.stdin);
+            const output = Readable.toWeb(this.agentProcess.stdout);
+            const stream = acp.ndJsonStream(input, output);
+            const client = {
+                requestPermission: async (params) => this.handlePermissionRequest(params),
+                sessionUpdate: async (params) => {
+                    const update = params.update;
+                    if (update.sessionUpdate === "current_mode_update" && typeof update.currentModeId === "string") {
+                        this.currentModeId = update.currentModeId;
+                    }
+                    this.onEvent({ type: "session_update", payload: params.update });
+                    this.resetDrainTimer();
+                },
+                readTextFile: async (params) => this.handleReadTextFile(params),
+                writeTextFile: async (params) => this.handleWriteTextFile(params),
+                extMethod: async (method, params) => this.handleExtMethod(method, params),
+            };
+            this.connection = new acp.ClientSideConnection(() => client, stream);
+            await Promise.race([
+                this.connection.initialize({
+                    protocolVersion: acp.PROTOCOL_VERSION,
+                    clientCapabilities: {
+                        fs: { readTextFile: true, writeTextFile: true },
+                        _meta: {
+                            extensions: [
+                                {
+                                    method: "leduo/ask_question",
+                                    description: "Ask the user a question with optional multiple-choice options. " +
+                                        "Params: { question: string, options?: Array<{ id: string, label: string }>, allowCustomAnswer?: boolean }. " +
+                                        "Returns: { answer: string }.",
+                                },
+                            ],
+                        },
+                    },
+                }),
+                startupFailure,
+            ]);
+            startupComplete = true;
+            rejectStartup = null;
+            this.emitReady();
+        })();
+        try {
+            await this.connectPromise;
+        }
+        catch (error) {
+            this.connectPromise = null;
+            throw error;
+        }
+    }
+    async ensureSession() {
+        if (this.sessionPromise) {
+            return await this.sessionPromise;
+        }
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (this.sessionId || !this.connection) {
+            return this.sessionId;
+        }
+        this.sessionPromise = (async () => {
+            const response = await this.connection.newSession({
+                cwd: this.workspacePath,
+                mcpServers: [],
+            });
+            this.sessionId = response.sessionId;
+            this.currentModeId = null;
+            this.onEvent({
+                type: "session_created",
+                payload: {
+                    sessionId: response.sessionId,
+                    modes: response.modes?.availableModes.map((mode) => mode.id) ?? [],
+                    configOptions: response.configOptions ?? [],
+                },
+            });
+            return this.sessionId;
+        })();
+        try {
+            return await this.sessionPromise;
+        }
+        catch (error) {
+            this.sessionPromise = null;
+            throw error;
+        }
+    }
+    async loadSession(existingSessionId) {
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (!this.connection) {
+            throw new Error("ACP connection is not available.");
+        }
+        this.sessionId = existingSessionId;
+        this.sessionPromise = Promise.resolve(existingSessionId);
+        const response = await this.connection.loadSession({
+            sessionId: existingSessionId,
+            cwd: this.workspacePath,
+            mcpServers: [],
+        });
+        this.currentModeId = response.modes?.currentModeId ?? null;
+        this.onEvent({
+            type: "session_restored",
+            payload: {
+                sessionId: existingSessionId,
+                modes: response.modes?.availableModes.map((mode) => mode.id) ?? [],
+                configOptions: response.configOptions ?? [],
+            },
+        });
+        return existingSessionId;
+    }
+    async findRestorableSession(preferredSessionId) {
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (!this.connection) {
+            throw new Error("ACP connection is not available.");
+        }
+        const response = await this.connection.unstable_listSessions({
+            cwd: this.workspacePath,
+        });
+        if (preferredSessionId) {
+            const exactMatch = response.sessions.find((session) => session.sessionId === preferredSessionId);
+            return exactMatch?.sessionId ?? null;
+        }
+        return response.sessions[0]?.sessionId ?? null;
+    }
+    async prompt(text, images) {
+        const sessionId = await this.ensureSession();
+        if (!this.connection || !sessionId) {
+            throw new Error("ACP session is not available.");
+        }
+        if (this.activePrompt) {
+            throw new Error("Another Claude prompt is still running.");
+        }
+        this.activePrompt = true;
+        const promptId = randomUUID();
+        this.onEvent({ type: "prompt_started", payload: { promptId, text } });
+        try {
+            const promptContent = [];
+            if (images && images.length > 0) {
+                for (const img of images) {
+                    promptContent.push({ type: "image", data: img.data, mimeType: img.mimeType });
+                }
+            }
+            promptContent.push({ type: "text", text });
+            const response = await this.connection.prompt({
+                sessionId,
+                messageId: randomUUID(),
+                prompt: promptContent,
+            });
+            await this.waitForDrain();
+            this.onEvent({
+                type: "prompt_finished",
+                payload: { promptId, stopReason: response.stopReason },
+            });
+        }
+        finally {
+            this.activePrompt = false;
+        }
+    }
+    async setMode(modeId) {
+        const sessionId = await this.ensureSession();
+        if (!this.connection || !sessionId || !modeId || this.currentModeId === modeId) {
+            return;
+        }
+        await this.connection.setSessionMode({
+            sessionId,
+            modeId,
+        });
+        this.currentModeId = modeId;
+    }
+    async cancel() {
+        if (!this.connection || !this.sessionId || !this.activePrompt) {
+            return;
+        }
+        await this.connection.cancel({ sessionId: this.sessionId });
+    }
+    async resolvePermission(requestId, optionId, note) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error("Permission request was not found or already resolved.");
+        }
+        pending.resolve({
+            outcome: {
+                outcome: "selected",
+                optionId,
+                _meta: note && note.trim() ? { note: note.trim() } : undefined,
+            },
+        });
+        this.pendingPermissions.delete(requestId);
+        this.onEvent({ type: "permission_resolved", payload: { requestId, optionId } });
+    }
+    async answerQuestion(questionId, answer) {
+        const pending = this.pendingQuestions.get(questionId);
+        if (!pending) {
+            throw new Error("Question was not found or already answered.");
+        }
+        pending.resolve({ answer });
+        this.pendingQuestions.delete(questionId);
+        this.onEvent({ type: "question_answered", payload: { questionId, answer } });
+    }
+    async dispose() {
+        this.disposing = true;
+        this.clearDrain();
+        this.rejectPendingPermissions(new Error("Client disconnected."));
+        this.rejectPendingQuestions(new Error("Client disconnected."));
+        if (this.agentProcess && !this.agentProcess.killed) {
+            this.agentProcess.kill();
+        }
+        this.agentProcess = null;
+        this.connection = null;
+        this.sessionId = null;
+        this.sessionPromise = null;
+        this.connectPromise = null;
+        this.currentModeId = null;
+        this.activePrompt = false;
+    }
+    emitReady() {
+        this.onEvent({
+            type: "ready",
+            payload: { workspacePath: this.workspacePath, agentConnected: true },
+        });
+    }
+    buildAgentSpawnFailureMessage(error) {
+        const hint = (error instanceof Error
+            && "code" in error
+            && error.code === "EAGAIN")
+            ? "The OS temporarily refused to start a new process (EAGAIN). Try again and check system process/thread limits or other running agent processes."
+            : "Check that LEDUO_PATROL_AGENT_BIN points to a valid ACP agent, or that the bundled claude-code-acp agent is executable.";
+        return buildSpawnFailureMessage("Claude ACP agent", this.agentBinPath, this.workspacePath, error, hint);
+    }
+    waitForDrain() {
+        return new Promise((resolve) => {
+            this.drainResolve = resolve;
+            this.drainTimer = setTimeout(() => {
+                this.drainResolve = null;
+                this.drainTimer = null;
+                resolve();
+            }, ClaudeAcpSession.DRAIN_QUIET_MS);
+        });
+    }
+    resetDrainTimer() {
+        if (this.drainTimer && this.drainResolve) {
+            clearTimeout(this.drainTimer);
+            const resolve = this.drainResolve;
+            this.drainTimer = setTimeout(() => {
+                this.drainResolve = null;
+                this.drainTimer = null;
+                resolve();
+            }, ClaudeAcpSession.DRAIN_QUIET_MS);
+        }
+    }
+    clearDrain() {
+        if (this.drainTimer) {
+            clearTimeout(this.drainTimer);
+            this.drainTimer = null;
+        }
+        if (this.drainResolve) {
+            this.drainResolve();
+            this.drainResolve = null;
+        }
+    }
+    shouldIgnoreAgentStderr(message) {
+        return (message.includes("Error handling notification") &&
+            message.includes("method: 'session/update'") &&
+            message.includes("message: 'Invalid params'")) || isMissingPostToolHookMessage(message) || message.includes("<local-command-stdout>");
+    }
+    shouldIgnoreToolOutputLog(message) {
+        const normalized = message.trim();
+        return normalized.startsWith('[{"index":') || normalized.startsWith("[{\"index\":");
+    }
+    async handlePermissionRequest(params) {
+        const requestId = randomUUID();
+        this.onEvent({
+            type: "permission_requested",
+            payload: {
+                requestId,
+                toolCall: params.toolCall,
+                options: params.options,
+            },
+        });
+        return await new Promise((resolve, reject) => {
+            this.pendingPermissions.set(requestId, { resolve, reject });
+        });
+    }
+    rejectPendingPermissions(reason) {
+        for (const pending of this.pendingPermissions.values()) {
+            pending.reject(reason);
+        }
+        this.pendingPermissions.clear();
+    }
+    rejectPendingQuestions(reason) {
+        for (const pending of this.pendingQuestions.values()) {
+            pending.reject(reason);
+        }
+        this.pendingQuestions.clear();
+    }
+    async handleExtMethod(method, params) {
+        if (method === "leduo/ask_question") {
+            return await this.handleAskQuestion(params);
+        }
+        throw new Error(`Unknown extension method: ${method}`);
+    }
+    async handleAskQuestion(params) {
+        const questionId = randomUUID();
+        const question = typeof params.question === "string" ? params.question : "";
+        const rawOptions = Array.isArray(params.options) ? params.options : [];
+        const options = rawOptions
+            .map((opt) => {
+            if (opt && typeof opt === "object" && !Array.isArray(opt)) {
+                const record = opt;
+                return {
+                    id: typeof record.id === "string" ? record.id : "",
+                    label: typeof record.label === "string" ? record.label : "",
+                };
+            }
+            return null;
+        })
+            .filter((opt) => opt !== null && opt.id !== "" && opt.label !== "");
+        const allowCustomAnswer = params.allowCustomAnswer === true;
+        this.onEvent({
+            type: "question_requested",
+            payload: { questionId, question, options, allowCustomAnswer },
+        });
+        return await new Promise((resolve, reject) => {
+            this.pendingQuestions.set(questionId, { resolve, reject });
+        });
+    }
+    resolveWorkspacePath(targetPath) {
+        const absolutePath = path.resolve(this.workspacePath, targetPath);
+        const relativePath = path.relative(this.workspacePath, absolutePath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error(`Refusing to access file outside workspace: ${targetPath}`);
+        }
+        return absolutePath;
+    }
+    async handleReadTextFile(params) {
+        const filePath = path.isAbsolute(params.path)
+            ? params.path
+            : this.resolveWorkspacePath(params.path);
+        const content = await readFile(filePath, "utf8");
+        if (params.line != null || params.limit != null) {
+            const lines = content.split("\n");
+            const offset = (params.line ?? 1) - 1;
+            const limit = params.limit ?? lines.length;
+            const start = Math.max(0, offset);
+            const end = Math.min(lines.length, start + limit);
+            return { content: lines.slice(start, end).join("\n") };
+        }
+        return { content };
+    }
+    async handleWriteTextFile(params) {
+        const filePath = path.isAbsolute(params.path)
+            ? params.path
+            : this.resolveWorkspacePath(params.path);
+        const dirName = path.dirname(filePath);
+        await mkdir(dirName, { recursive: true });
+        await writeFile(filePath, params.content, "utf8");
+        return {};
+    }
+}
+function isMissingPostToolHookMessage(message) {
+    return message.includes("No onPostToolUseHook found for tool use ID:");
+}

package/dist/server/activity-monitor.js

@@ -10,6 +10,15 @@ const POLL_INTERVAL_MS = 2000;
 const ACTIVITY_TYPES = new Set(["assistant", "user", "progress"]);
 /** Types to skip when scanning for the last meaningful entry. */
 const SKIP_TYPES = new Set(["last-prompt", "system", "file-history-snapshot", "queue-operation"]);
+function extractAssistantContentTypes(entry) {
+    const content = entry.message?.content;
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    return content
+        .map((block) => (block && typeof block === "object" ? block.type : undefined))
+        .filter((type) => typeof type === "string");
+}
 /**
  * Detect if a user entry represents a local CLI command (not a real user message to Claude).
  * Local commands have content containing `<command-name>`, `<local-command-stdout>`, or `<local-command-caveat>`.
@@ -58,9 +67,10 @@ export function detectClearCommand(entry) {
  * Given a parsed JSONL entry, return the activity state.
  *
  * Rules:
- *   assistant + no stop_reason (null / undefined)     → running
- *   assistant + stop_reason "tool_use"                → pending
- *   assistant + stop_reason "end_turn"|"stop_sequence" → completed
+ *   assistant + tool_use content / stop_reason        → pending
+ *   assistant + thinking content only                 → running
+ *   assistant + text content only                     → completed
+ *   assistant + explicit terminal stop_reason         → completed
  *   user (local command / meta)                       → completed
  *   user (real message)                               → running
  *   system + subtype "local_command"                  → completed
@@ -70,13 +80,18 @@ export function detectClearCommand(entry) {
 export function determineActivityState(entry) {
     const { type } = entry;
     if (type === "assistant") {
+        const contentTypes = extractAssistantContentTypes(entry);
         const stopReason = entry.message?.stop_reason;
-        if (stopReason == null)
-            return "running";
-        if (stopReason === "tool_use")
+        if (stopReason === "tool_use" || contentTypes.includes("tool_use"))
             return "pending";
+        if (stopReason != null)
+            return "completed";
+        if (contentTypes.includes("thinking"))
+            return "running";
+        if (contentTypes.includes("text"))
+            return "completed";
         // end_turn, stop_sequence, max_tokens, etc. – treat as completed
-        return "completed";
+        return "running";
     }
     if (type === "user") {
         // Local CLI commands (/mcp, /status, /clear, etc.) are already finished

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";
@@ -35,6 +36,7 @@ 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 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";
@@ -44,6 +46,7 @@ const wss = new WebSocketServer({ server, path: "/ws" });
 const sessionManager = new SessionManager({
     allowedRoots,
     claudeBin,
+    agentBinPath,
     allowSkipPermissions,
 });
 await sessionManager.initialize();
@@ -87,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 : "";
@@ -197,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);
@@ -331,3 +370,17 @@ function parseBooleanFlag(rawValue, defaultValue) {
     }
     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;
+    }
+}