@lelouchhe/webagent 0.2.6 → 0.4.0

package/lib/bridge.js

@@ -1,8 +1,10 @@
-import { spawn, ChildProcess } from "node:child_process";
+import { spawn } from "node:child_process";
 import { Writable, Readable } from "node:stream";
 import { EventEmitter } from "node:events";
 import * as acp from "@agentclientprotocol/sdk";
 import { interruptBashProc } from "./session-manager.js";
+import { log } from "./log.js";
+const blog = log.scope("bridge");
 export class AgentBridge extends EventEmitter {
     proc = null;
     conn = null;
@@ -10,37 +12,76 @@ export class AgentBridge extends EventEmitter {
     permissionRequestSessions = new Map();
     silentSessions = new Set(); // Sessions that don't emit events
     silentBuffers = new Map(); // Text buffers for silent sessions
+    pendingAborts = new Map();
+    deadReason = null;
+    stderrTail = "";
     agentCmd;
     reloading = false;
+    attachmentDispatcher = null;
     constructor(agentCmd) {
         super();
         this.agentCmd = agentCmd;
     }
+    /**
+     * Inject the dispatcher used to translate client attachment refs into
+     * ACP prompt blocks. Set once at server boot; staying optional so unit
+     * tests that don't exercise attachments can construct a bare bridge.
+     */
+    setAttachmentDispatcher(dispatcher) {
+        this.attachmentDispatcher = dispatcher;
+    }
     async start() {
         const [cmd, ...args] = this.agentCmd.split(/\s+/);
         this.proc = spawn(cmd, args, {
-            stdio: ["pipe", "pipe", "inherit"],
+            stdio: ["pipe", "pipe", "pipe"],
         });
-        if (!this.proc.stdin || !this.proc.stdout) {
+        if (!this.proc.stdin || !this.proc.stdout || !this.proc.stderr) {
             throw new Error(`Failed to start: ${this.agentCmd}`);
         }
+        // Reset dead state for fresh start, and capture stderr for diagnostics.
+        this.deadReason = null;
+        this.stderrTail = "";
+        this.proc.stderr.on("data", (chunk) => {
+            process.stderr.write(chunk);
+            this.stderrTail = (this.stderrTail + chunk.toString()).slice(-4096);
+        });
+        // Detect unexpected agent death. restart() and shutdown() set
+        // `reloading=true` so they own the lifecycle and we skip auto-marking.
+        const proc = this.proc;
+        proc.on("exit", (code, signal) => {
+            if (this.reloading)
+                return;
+            if (proc !== this.proc)
+                return; // already replaced
+            const tail = this.stderrTail.trim().split("\n").slice(-3).join("\n");
+            const why = signal ? `signal=${signal}` : `code=${code}`;
+            const reason = `Agent process exited unexpectedly (${why}).` +
+                (tail ? `\nLast stderr:\n${tail}` : "") +
+                `\nCheck '${this.agentCmd}' is properly configured (e.g. authenticated).`;
+            this.markAgentDead(reason);
+        });
+        proc.on("error", (err) => {
+            if (this.reloading)
+                return;
+            if (proc !== this.proc)
+                return;
+            this.markAgentDead(`Agent process error: ${err.message}`);
+        });
         const input = Writable.toWeb(this.proc.stdin);
         const output = Readable.toWeb(this.proc.stdout);
         const stream = acp.ndJsonStream(input, output);
         const client = {
             requestPermission: async (params) => this.handlePermission(params),
             sessionUpdate: async (params) => this.handleSessionUpdate(params),
-            readTextFile: async (params) => this.handleReadFile(params),
-            writeTextFile: async (params) => this.handleWriteFile(params),
         };
         this.conn = new acp.ClientSideConnection((_agent) => client, stream);
-        const init = await this.conn.initialize({
+        const init = (await this.conn.initialize({
             protocolVersion: acp.PROTOCOL_VERSION,
             clientCapabilities: {
-                fs: { readTextFile: true, writeTextFile: true },
+                fs: { readTextFile: false, writeTextFile: false },
                 terminal: true,
             },
-        });
+        }));
         const agentInfo = init.agentInfo;
         this.emit("event", {
             type: "connected",
@@ -54,50 +95,103 @@ export class AgentBridge extends EventEmitter {
     async newSession(cwd, opts) {
         if (!this.conn)
             throw new Error("Not connected");
-        const session = await this.conn.newSession({ cwd, mcpServers: [] });
+        const session = (await this.conn.newSession({
+            cwd,
+            mcpServers: [],
+        }));
+        const configOptions = (session.configOptions ??
+            []);
         if (!opts?.silent) {
             this.emit("event", {
                 type: "session_created",
                 sessionId: session.sessionId,
                 cwd,
-                configOptions: session.configOptions ?? [],
+                configOptions,
             });
         }
-        return session.sessionId;
+        return { sessionId: session.sessionId, configOptions };
     }
     async loadSession(sessionId, cwd) {
         if (!this.conn)
             throw new Error("Not connected");
-        const session = await this.conn.loadSession({ sessionId, cwd, mcpServers: [] });
+        let session;
+        try {
+            session = (await this.conn.loadSession({
+                sessionId,
+                cwd,
+                mcpServers: [],
+            }));
+        }
+        catch (err) {
+            // -32002 = Resource not found. Some agents (e.g. claude-agent-acp) don't
+            // persist sessions across process restarts, so a session in our DB may
+            // be unknown to the live agent. Translate the JSON-RPC error into a
+            // user-actionable message; routes returns it as 500 / SSE 'error' event.
+            const code = err.code;
+            if (code === -32002) {
+                throw new Error(`The agent no longer remembers session ${sessionId.slice(0, 8)}… ` +
+                    `(it may not persist sessions across restarts). Use /new to start a fresh one.`, { cause: err });
+            }
+            throw err;
+        }
+        const configOptions = (session.configOptions ??
+            []);
         this.emit("event", {
             type: "session_created",
-            sessionId: session.sessionId,
+            sessionId,
             cwd,
-            configOptions: session.configOptions ?? [],
+            configOptions,
         });
-        return { sessionId: session.sessionId, configOptions: session.configOptions ?? [] };
+        return { sessionId, configOptions };
     }
     async setConfigOption(sessionId, configId, value) {
         if (!this.conn)
             throw new Error("Not connected");
-        const result = await this.conn.setSessionConfigOption({ sessionId, configId, value });
-        return result.configOptions ?? [];
+        const result = (await this.conn.setSessionConfigOption({
+            sessionId,
+            configId,
+            value,
+        }));
+        return result.configOptions;
     }
-    async prompt(sessionId, text, images) {
+    async prompt(sessionId, text, attachments) {
+        if (this.deadReason) {
+            this.emit("event", {
+                type: "error",
+                sessionId,
+                message: this.deadReason,
+            });
+            return;
+        }
         if (!this.conn)
             throw new Error("Not connected");
+        let abortReject = () => { };
+        const abortPromise = new Promise((_, rej) => {
+            abortReject = rej;
+        });
+        this.pendingAborts.set(sessionId, abortReject);
         try {
             const promptParts = [];
-            if (images) {
-                for (const img of images) {
-                    promptParts.push({ type: "image", data: img.data, mimeType: img.mimeType });
+            if (attachments && attachments.length > 0) {
+                if (!this.attachmentDispatcher) {
+                    // Misconfiguration: routes accepted attachments but bridge has no
+                    // dispatcher wired. Fail loud so tests / dev catch it; production
+                    // server.ts always calls setAttachmentDispatcher().
+                    throw new Error("attachment dispatcher not configured");
+                }
+                for (const ref of attachments) {
+                    const block = await this.attachmentDispatcher.dispatch(sessionId, ref);
+                    promptParts.push(block);
                 }
             }
             promptParts.push({ type: "text", text });
-            const result = await this.conn.prompt({
-                sessionId,
-                prompt: promptParts,
-            });
+            const result = (await Promise.race([
+                this.conn.prompt({
+                    sessionId,
+                    prompt: promptParts,
+                }),
+                abortPromise,
+            ]));
             this.emit("event", {
                 type: "prompt_done",
                 sessionId,
@@ -105,7 +199,11 @@ export class AgentBridge extends EventEmitter {
             });
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
+            const message = err instanceof Error
+                ? err.message
+                : typeof err === "string"
+                    ? err
+                    : JSON.stringify(err);
             if (/cancel/i.test(message)) {
                 this.emit("event", {
                     type: "prompt_done",
@@ -114,29 +212,79 @@ export class AgentBridge extends EventEmitter {
                 });
                 return;
             }
-            this.emit("event", { type: "error", sessionId, message });
+            this.emit("event", {
+                type: "error",
+                sessionId,
+                message,
+            });
+        }
+        finally {
+            this.pendingAborts.delete(sessionId);
         }
     }
     async cancel(sessionId) {
-        for (const [requestId, requestSessionId] of this.permissionRequestSessions) {
+        for (const [requestId, requestSessionId] of this
+            .permissionRequestSessions) {
             if (requestSessionId === sessionId) {
                 this.denyPermission(requestId);
             }
         }
         await this.conn?.cancel({ sessionId });
     }
+    /**
+     * Mark the agent subprocess as dead. Rejects in-flight prompts and emits
+     * an `error` event for each so the frontend can exit the busy state and
+     * show a useful message instead of hanging forever.
+     *
+     * Called from `start()`'s `proc.on("exit"|"error")` handlers when the
+     * subprocess dies outside of `restart()` / `shutdown()` (which set
+     * `reloading=true` to claim the lifecycle). Does NOT auto-restart — for
+     * config errors like missing auth, restart would loop into the same
+     * failure. User fixes the config and runs `/reload`.
+     */
+    markAgentDead(reason) {
+        if (this.deadReason)
+            return;
+        this.deadReason = reason;
+        blog.error("agent subprocess dead", { reason });
+        const aborts = [...this.pendingAborts.entries()];
+        this.pendingAborts.clear();
+        for (const [sessionId, abort] of aborts) {
+            this.emit("event", {
+                type: "error",
+                sessionId,
+                message: reason,
+            });
+            abort(new Error(reason));
+        }
+        this.conn = null;
+    }
     /** Send a prompt and collect the full text response without emitting events. */
     async promptForText(sessionId, text) {
+        if (this.deadReason)
+            throw new Error(this.deadReason);
         if (!this.conn)
             throw new Error("Not connected");
         this.silentSessions.add(sessionId);
         this.silentBuffers.set(sessionId, "");
+        let abortReject = () => { };
+        const abortPromise = new Promise((_, rej) => {
+            abortReject = rej;
+        });
+        this.pendingAborts.set(sessionId, abortReject);
         try {
-            await this.conn.prompt({ sessionId, prompt: [{ type: "text", text }] });
+            await Promise.race([
+                this.conn.prompt({ sessionId, prompt: [{ type: "text", text }] }),
+                abortPromise,
+            ]);
             return this.silentBuffers.get(sessionId) ?? "";
         }
         catch (err) {
-            const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
+            const message = err instanceof Error
+                ? err.message
+                : typeof err === "string"
+                    ? err
+                    : JSON.stringify(err);
             if (/cancel/i.test(message)) {
                 return "";
             }
@@ -145,6 +293,7 @@ export class AgentBridge extends EventEmitter {
         finally {
             this.silentSessions.delete(sessionId);
             this.silentBuffers.delete(sessionId);
+            this.pendingAborts.delete(sessionId);
         }
     }
     resolvePermission(requestId, optionId) {
@@ -173,7 +322,7 @@ export class AgentBridge extends EventEmitter {
             throw new Error("Already reloading");
         this.reloading = true;
         this.emit("event", { type: "agent_reloading" });
-        console.log("[bridge] reloading agent...");
+        blog.info("reloading agent...");
         try {
             // 1. Cancel all active prompts + kill bash procs
             for (const sessionId of [...sessions.activePrompts]) {
@@ -185,7 +334,9 @@ export class AgentBridge extends EventEmitter {
                 try {
                     await this.cancel(sessionId);
                 }
-                catch { /* best-effort */ }
+                catch {
+                    /* best-effort */
+                }
             }
             // 2. Flush buffers to persist partial content
             for (const sessionId of sessions.liveSessions) {
@@ -193,6 +344,9 @@ export class AgentBridge extends EventEmitter {
             }
             // 3. Clean up SessionManager state
             sessions.pendingPermissions.clear();
+            for (const id of sessions.activePrompts) {
+                sessions.state.patch(id, { runtime: { busy: null } });
+            }
             sessions.activePrompts.clear();
             // 4. Clean up bridge-side silent session state
             this.silentSessions.clear();
@@ -201,6 +355,10 @@ export class AgentBridge extends EventEmitter {
             titleService.invalidate();
             // 5. Clear liveSessions so ensureResumed() will re-register on next access
             sessions.liveSessions.clear();
+            // Also clear the global configOptions cache — a restarted agent may
+            // speak a different schema (e.g. agent upgrade removed a model). The
+            // next resumeSession will warm it from the user's stored config.
+            sessions.cachedConfigOptions = [];
             // 6. Shutdown old process
             await this.shutdown();
             // 7. Start new process with retry (exponential backoff, max 3 attempts)
@@ -213,17 +371,20 @@ export class AgentBridge extends EventEmitter {
                 }
                 catch (err) {
                     lastError = err;
-                    console.error(`[bridge] start attempt ${i + 1} failed:`, err);
+                    blog.error("start attempt failed", { attempt: i + 1, error: err });
                     if (i < 2)
                         await new Promise((r) => setTimeout(r, 1000 * 2 ** i));
                 }
             }
             if (lastError || !this.conn) {
                 const msg = lastError instanceof Error ? lastError.message : String(lastError);
-                this.emit("event", { type: "agent_reloading_failed", error: msg });
+                this.emit("event", {
+                    type: "agent_reloading_failed",
+                    error: msg,
+                });
                 throw lastError;
             }
-            console.log("[bridge] agent reloaded successfully");
+            blog.info("agent reloaded successfully");
         }
         finally {
             this.reloading = false;
@@ -231,12 +392,12 @@ export class AgentBridge extends EventEmitter {
     }
     async shutdown() {
         // Reject all pending permissions
-        for (const [id, resolve] of this.permissionResolvers) {
+        for (const [_id, resolve] of this.permissionResolvers) {
             resolve({ outcome: { outcome: "cancelled" } });
         }
         this.permissionResolvers.clear();
         this.permissionRequestSessions.clear();
-        if (this.proc && this.proc.exitCode === null) {
+        if (this.proc?.exitCode === null) {
             const proc = this.proc;
             await new Promise((resolve) => {
                 const timer = setTimeout(() => {
@@ -256,8 +417,12 @@ export class AgentBridge extends EventEmitter {
     // --- ACP Client callbacks ---
     handlePermission(params) {
         const requestId = crypto.randomUUID();
-        const title = params.toolCall?.title ?? "Permission requested";
-        const toolCallId = params.toolCall?.toolCallId ?? null;
+        const toolCall = params.toolCall;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- toolCall may be undefined in practice
+        const title = toolCall?.title ?? "Permission requested";
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- toolCall may be undefined in practice
+        const toolCallId = toolCall?.toolCallId;
+        const tc = toolCall;
         return new Promise((resolve) => {
             // Register resolver BEFORE emitting, so synchronous auto-approve can find it
             this.permissionResolvers.set(requestId, resolve);
@@ -269,85 +434,71 @@ export class AgentBridge extends EventEmitter {
                 title,
                 toolCallId,
                 options: params.options,
+                toolKind: tc?.kind,
+                toolName: tc?.name,
+                locations: tc?.locations,
+                rawInput: tc?.rawInput,
             });
         });
     }
     handleSessionUpdate(params) {
         const update = params.update;
         const sessionId = params.sessionId;
-        // Silent sessions: only buffer text, don't emit events
         if (this.silentSessions.has(sessionId)) {
-            if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-                const buf = (this.silentBuffers.get(sessionId) ?? "") + update.content.text;
-                this.silentBuffers.set(sessionId, buf);
-            }
+            this.captureSilentText(sessionId, update);
             return Promise.resolve();
         }
+        const event = this.sessionUpdateToEvent(sessionId, update);
+        if (event)
+            this.emit("event", event);
+        return Promise.resolve();
+    }
+    captureSilentText(sessionId, update) {
+        if (update.sessionUpdate === "agent_message_chunk" &&
+            update.content.type === "text") {
+            const buf = (this.silentBuffers.get(sessionId) ?? "") + update.content.text;
+            this.silentBuffers.set(sessionId, buf);
+        }
+    }
+    sessionUpdateToEvent(sessionId, update) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- only handles events with UI effects
         switch (update.sessionUpdate) {
             case "agent_message_chunk":
-                if (update.content.type === "text") {
-                    this.emit("event", {
-                        type: "message_chunk",
-                        sessionId,
-                        text: update.content.text,
-                    });
-                }
-                break;
+                return update.content.type === "text"
+                    ? { type: "message_chunk", sessionId, text: update.content.text }
+                    : null;
             case "agent_thought_chunk":
-                if (update.content.type === "text") {
-                    this.emit("event", {
-                        type: "thought_chunk",
-                        sessionId,
-                        text: update.content.text,
-                    });
-                }
-                break;
+                return update.content.type === "text"
+                    ? { type: "thought_chunk", sessionId, text: update.content.text }
+                    : null;
             case "tool_call":
-                this.emit("event", {
+                return {
                     type: "tool_call",
                     sessionId,
-                    id: update.toolCallId ?? "",
-                    title: update.title ?? "",
+                    id: update.toolCallId,
+                    title: update.title,
                     kind: update.kind ?? "unknown",
                     rawInput: update.rawInput,
-                });
-                break;
+                };
             case "tool_call_update":
-                this.emit("event", {
+                return {
                     type: "tool_call_update",
                     sessionId,
-                    id: update.toolCallId ?? "",
+                    id: update.toolCallId,
                     status: update.status ?? "",
-                    content: update.content ?? undefined,
-                });
-                break;
+                    content: (update.content ?? undefined),
+                };
             case "plan":
-                this.emit("event", {
-                    type: "plan",
-                    sessionId,
-                    entries: update.entries ?? [],
-                });
-                break;
+                return { type: "plan", sessionId, entries: update.entries };
             case "config_option_update":
-                this.emit("event", {
+                return {
                     type: "config_option_update",
                     sessionId,
-                    configOptions: update.configOptions ?? [],
-                });
-                break;
+                    configOptions: update
+                        .configOptions ?? [],
+                };
+            default:
+                return null;
         }
-        return Promise.resolve();
-    }
-    async handleReadFile(params) {
-        const { readFile } = await import("node:fs/promises");
-        const content = await readFile(params.path, "utf-8");
-        return { content };
-    }
-    async handleWriteFile(params) {
-        const { writeFile, mkdir } = await import("node:fs/promises");
-        const { dirname } = await import("node:path");
-        await mkdir(dirname(params.path), { recursive: true });
-        await writeFile(params.path, params.content);
-        return {};
     }
 }

package/lib/client-registry.js

@@ -0,0 +1,60 @@
+/**
+ * ClientRegistry — in-memory tracking of connected clients.
+ *
+ * Tracks per-client metadata that survives SSE disconnect:
+ *   - capabilities advertised by the client on /hello.
+ *   - focus: clientId's current sessionId (set via /focus). Used by push
+ *     visibility suppression to know which session each client is viewing.
+ *
+ * Lifecycle: clients call /hello on SSE connect (register) and /focus when
+ * they switch sessions. SSE disconnect does not remove a client — it stays
+ * in the registry until an explicit /goodbye or TTL eviction (caller's
+ * responsibility). This lets visibility state outlive transient drops.
+ */
+export class ClientRegistry {
+    clients = new Map();
+    register(id, data) {
+        const existing = this.clients.get(id);
+        if (existing) {
+            existing.capabilities = data.capabilities;
+            existing.lastSeen = Date.now();
+            return existing;
+        }
+        const entry = {
+            id,
+            capabilities: data.capabilities,
+            focus: null,
+            lastSeen: Date.now(),
+        };
+        this.clients.set(id, entry);
+        return entry;
+    }
+    remove(id) {
+        this.clients.delete(id);
+    }
+    setFocus(id, sessionId) {
+        const entry = this.clients.get(id);
+        if (!entry)
+            return;
+        entry.focus = sessionId;
+        entry.lastSeen = Date.now();
+    }
+    updateCapabilities(id, caps) {
+        const entry = this.clients.get(id);
+        if (!entry)
+            return;
+        entry.capabilities = caps;
+        entry.lastSeen = Date.now();
+    }
+    touch(id) {
+        const entry = this.clients.get(id);
+        if (entry)
+            entry.lastSeen = Date.now();
+    }
+    get(id) {
+        return this.clients.get(id);
+    }
+    list() {
+        return Array.from(this.clients.values());
+    }
+}