leduo-patrol 2.0.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/claude-cli-session.js

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { buildSpawnFailureMessage, ensureDirectoryExistsSync } from "./server-helpers.js";
+import { ensureNodePtySpawnHelperExecutable } from "./pty-runtime.js";
 /**
  * A PTY-backed session that runs the native Claude Code CLI.
  *
@@ -19,6 +20,7 @@ export class ClaudeCliSession extends EventEmitter {
         super();
         this.sessionId = opts.sessionId;
         ensureDirectoryExistsSync(opts.workspacePath, "Session workspace");
+        ensureNodePtySpawnHelperExecutable();
         const bin = resolveClaudeBin(opts.claudeBin);
         const args = opts.resume
             ? ["--resume", opts.sessionId]
@@ -26,21 +28,24 @@ export class ClaudeCliSession extends EventEmitter {
         if (opts.allowSkipPermissions) {
             args.push("--allow-dangerously-skip-permissions");
         }
+        const env = {
+            ...process.env,
+            TERM: "xterm-256color",
+            COLORTERM: "truecolor",
+        };
         try {
-            this.pty = spawn(bin, args, {
-                name: "xterm-256color",
-                cols: opts.cols ?? 80,
-                rows: opts.rows ?? 24,
-                cwd: opts.workspacePath,
-                env: {
-                    ...process.env,
-                    TERM: "xterm-256color",
-                    COLORTERM: "truecolor",
-                },
-            });
+            this.pty = spawnClaudePty(buildDirectClaudeLaunch(bin, args), opts.workspacePath, opts.cols ?? 80, opts.rows ?? 24, env);
         }
         catch (error) {
-            throw new Error(buildSpawnFailureMessage("Claude CLI", bin, opts.workspacePath, error, "Check that the command is installed correctly, or override it with LEDUO_PATROL_CLAUDE_BIN."));
+            if (!shouldRetryClaudeSpawnWithShell(error)) {
+                throw new Error(buildSpawnFailureMessage("Claude CLI", bin, opts.workspacePath, error, "Check that the command is installed correctly, or override it with LEDUO_PATROL_CLAUDE_BIN."));
+            }
+            try {
+                this.pty = spawnClaudePty(buildShellWrappedClaudeLaunch(bin, args), opts.workspacePath, opts.cols ?? 80, opts.rows ?? 24, env);
+            }
+            catch (fallbackError) {
+                throw new Error(buildSpawnFailureMessage("Claude CLI", bin, opts.workspacePath, fallbackError, "Direct PTY spawn also failed, even after retrying through a shell wrapper. Check that Claude Code is installed correctly, or override it with LEDUO_PATROL_CLAUDE_BIN."));
+            }
         }
         this.pty.onData((data) => {
             this.emit("output", data);
@@ -70,6 +75,42 @@ export class ClaudeCliSession extends EventEmitter {
         }
     }
 }
+function spawnClaudePty(launch, workspacePath, cols, rows, env) {
+    return spawn(launch.command, launch.args, {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: workspacePath,
+        env,
+    });
+}
+function buildDirectClaudeLaunch(bin, args) {
+    return {
+        command: bin,
+        args,
+    };
+}
+function buildShellWrappedClaudeLaunch(bin, args, shellExists = existsSync) {
+    return {
+        command: resolveClaudeWrapperShell(shellExists),
+        args: ["-c", 'exec "$0" "$@"', bin, ...args],
+    };
+}
+function resolveClaudeWrapperShell(shellExists = existsSync) {
+    const candidates = ["/bin/sh", "/bin/bash", "/bin/zsh", "/usr/bin/sh"];
+    for (const candidate of candidates) {
+        if (shellExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("No compatible shell was found for Claude CLI fallback launch.");
+}
+function shouldRetryClaudeSpawnWithShell(error) {
+    if (process.platform === "win32") {
+        return false;
+    }
+    return error instanceof Error && /posix_spawnp failed/i.test(error.message);
+}
 function findExecutableOnPath(command, envPath = process.env.PATH) {
     if (!envPath)
         return null;
@@ -102,6 +143,10 @@ function resolveClaudeBin(configuredBin, env = process.env) {
     throw new Error(`Claude CLI "${candidate}" was not found in PATH. Install Claude Code first, or set LEDUO_PATROL_CLAUDE_BIN=/absolute/path/to/claude.`);
 }
 export const claudeCliSessionTestables = {
+    buildDirectClaudeLaunch,
+    buildShellWrappedClaudeLaunch,
     findExecutableOnPath,
     resolveClaudeBin,
+    resolveClaudeWrapperShell,
+    shouldRetryClaudeSpawnWithShell,
 };