@lelouchhe/webagent 0.7.0 → 0.9.0

package/lib/bridge.js

@@ -3,6 +3,7 @@ import { Writable, Readable } from "node:stream";
 import { EventEmitter } from "node:events";
 import * as acp from "@agentclientprotocol/sdk";
 import { interruptBashProc } from "./session-manager.js";
+import { abbreviateHomePath } from "./home-path.js";
 import { log } from "./log.js";
 const blog = log.scope("bridge");
 export class AgentBridge extends EventEmitter {
@@ -12,15 +13,27 @@ 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
+    pendingNewSessions = 0;
+    unboundNewSessionIds = new Set();
+    pendingSessionUpdates = new Map();
     pendingAborts = new Map();
     deadReason = null;
     stderrTail = "";
+    closedProcesses = new WeakSet();
     agentCmd;
+    sessionIds;
     reloading = false;
     attachmentDispatcher = null;
-    constructor(agentCmd) {
+    constructor(agentCmd, sessionIds) {
         super();
         this.agentCmd = agentCmd;
+        this.sessionIds = sessionIds;
+    }
+    agentSessionId(webSessionId) {
+        const id = this.sessionIds.getAgentSessionId(webSessionId);
+        if (!id)
+            throw new Error(`Session is not available for the current agent: ${webSessionId}`);
+        return id;
     }
     /**
      * Inject the dispatcher used to translate client attachment refs into
@@ -60,6 +73,9 @@ export class AgentBridge extends EventEmitter {
                 `\nCheck '${this.agentCmd}' is properly configured (e.g. authenticated).`;
             this.markAgentDead(reason);
         });
+        proc.once("close", () => {
+            this.closedProcesses.add(proc);
+        });
         proc.on("error", (err) => {
             if (this.reloading)
                 return;
@@ -95,29 +111,57 @@ 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 configOptions = (session.configOptions ??
-            []);
-        if (!opts?.silent) {
-            this.emit("event", {
-                type: "session_created",
-                sessionId: session.sessionId,
+        this.pendingNewSessions++;
+        try {
+            const session = await this.conn.newSession({
                 cwd,
-                configOptions,
+                mcpServers: [],
             });
+            if (opts?.silent) {
+                this.pendingSessionUpdates.delete(session.sessionId);
+                this.silentSessions.add(session.sessionId);
+            }
+            else {
+                this.unboundNewSessionIds.add(session.sessionId);
+            }
+            const configOptions = (session.configOptions ??
+                []);
+            return { sessionId: session.sessionId, configOptions };
         }
-        return { sessionId: session.sessionId, configOptions };
+        finally {
+            this.pendingNewSessions--;
+            if (this.pendingNewSessions === 0) {
+                for (const sessionId of this.pendingSessionUpdates.keys()) {
+                    if (!this.unboundNewSessionIds.has(sessionId)) {
+                        this.pendingSessionUpdates.delete(sessionId);
+                        blog.warn("discarded update for unrelated unmapped ACP session", {
+                            sessionId,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    sessionMapped(agentSessionId) {
+        this.unboundNewSessionIds.delete(agentSessionId);
+        const updates = this.pendingSessionUpdates.get(agentSessionId) ?? [];
+        this.pendingSessionUpdates.delete(agentSessionId);
+        for (const update of updates) {
+            void this.handleSessionUpdate({ sessionId: agentSessionId, update });
+        }
+    }
+    discardUnboundSession(agentSessionId) {
+        this.unboundNewSessionIds.delete(agentSessionId);
+        this.pendingSessionUpdates.delete(agentSessionId);
     }
     async loadSession(sessionId, cwd) {
         if (!this.conn)
             throw new Error("Not connected");
+        const agentSessionId = this.agentSessionId(sessionId);
         let session;
         try {
             session = await this.conn.loadSession({
-                sessionId,
+                sessionId: agentSessionId,
                 cwd,
                 mcpServers: [],
             });
@@ -140,6 +184,7 @@ export class AgentBridge extends EventEmitter {
             type: "session_created",
             sessionId,
             cwd,
+            cwdDisplay: abbreviateHomePath(cwd),
             configOptions,
         });
         return { sessionId, configOptions };
@@ -148,7 +193,19 @@ export class AgentBridge extends EventEmitter {
         if (!this.conn)
             throw new Error("Not connected");
         const result = await this.conn.setSessionConfigOption({
-            sessionId,
+            sessionId: this.agentSessionId(sessionId),
+            configId,
+            ...(typeof value === "boolean"
+                ? { type: "boolean", value }
+                : { value }),
+        });
+        return result.configOptions;
+    }
+    async setAgentConfigOption(agentSessionId, configId, value) {
+        if (!this.conn)
+            throw new Error("Not connected");
+        const result = await this.conn.setSessionConfigOption({
+            sessionId: agentSessionId,
             configId,
             ...(typeof value === "boolean"
                 ? { type: "boolean", value }
@@ -156,7 +213,10 @@ export class AgentBridge extends EventEmitter {
         });
         return result.configOptions;
     }
-    async prompt(sessionId, text, attachments) {
+    async prompt(sessionId, text, attachments, 
+    /** Turn identity echoed back on this prompt's terminal event, so a
+     *  completion that outlives its turn can be told apart from the live one. */
+    promptId) {
         if (this.deadReason) {
             this.emit("event", {
                 type: "error",
@@ -189,7 +249,7 @@ export class AgentBridge extends EventEmitter {
             promptParts.push({ type: "text", text });
             const result = (await Promise.race([
                 this.conn.prompt({
-                    sessionId,
+                    sessionId: this.agentSessionId(sessionId),
                     prompt: promptParts,
                 }),
                 abortPromise,
@@ -198,6 +258,7 @@ export class AgentBridge extends EventEmitter {
                 type: "prompt_done",
                 sessionId,
                 stopReason: result.stopReason ?? "end_turn",
+                ...(promptId ? { promptId } : {}),
             });
         }
         catch (err) {
@@ -211,6 +272,7 @@ export class AgentBridge extends EventEmitter {
                     type: "prompt_done",
                     sessionId,
                     stopReason: "cancelled",
+                    ...(promptId ? { promptId } : {}),
                 });
                 return;
             }
@@ -218,6 +280,7 @@ export class AgentBridge extends EventEmitter {
                 type: "error",
                 sessionId,
                 message,
+                ...(promptId ? { promptId } : {}),
             });
         }
         finally {
@@ -231,7 +294,10 @@ export class AgentBridge extends EventEmitter {
                 this.denyPermission(requestId);
             }
         }
-        await this.conn?.cancel({ sessionId });
+        await this.conn?.cancel({ sessionId: this.agentSessionId(sessionId) });
+    }
+    async cancelAgentSession(agentSessionId) {
+        await this.conn?.cancel({ sessionId: agentSessionId });
     }
     /**
      * Mark the agent subprocess as dead. Rejects in-flight prompts and emits
@@ -324,6 +390,7 @@ export class AgentBridge extends EventEmitter {
         if (this.reloading)
             throw new Error("Already reloading");
         this.reloading = true;
+        const liveSessionIds = [...sessions.liveSessions];
         this.emit("event", { type: "agent_reloading" });
         blog.info("reloading agent...");
         try {
@@ -342,18 +409,29 @@ export class AgentBridge extends EventEmitter {
                 }
             }
             // 2. Flush buffers to persist partial content
-            for (const sessionId of sessions.liveSessions) {
+            for (const sessionId of liveSessionIds) {
                 sessions.flushBuffers(sessionId);
             }
             // 3. Clean up SessionManager state
             sessions.pendingPermissions.clear();
-            for (const id of sessions.activePrompts) {
+            sessions.state.clearPlans();
+            const busySessionIds = new Set([
+                ...sessions.activePrompts,
+                ...sessions.pendingPromptSubmissions.keys(),
+            ]);
+            for (const id of busySessionIds) {
                 sessions.state.patch(id, { runtime: { busy: null } });
             }
+            for (const submissionId of sessions.pendingPromptSubmissions.values()) {
+                sessions.cancelledPromptSubmissions.add(submissionId);
+            }
             sessions.activePrompts.clear();
+            sessions.pendingPromptSubmissions.clear();
             // 4. Clean up bridge-side silent session state
             this.silentSessions.clear();
             this.silentBuffers.clear();
+            this.unboundNewSessionIds.clear();
+            this.pendingSessionUpdates.clear();
             // 5. Invalidate title service session
             titleService.invalidate();
             // 5. Clear liveSessions so ensureResumed() will re-register on next access
@@ -364,6 +442,13 @@ export class AgentBridge extends EventEmitter {
             sessions.cachedConfigOptions = [];
             // 6. Shutdown old process
             await this.shutdown();
+            // Cancellation is asynchronous: the old agent may emit final chunks
+            // before shutdown completes. Persist that tail and make the terminal
+            // stream state authoritative before starting the replacement process.
+            for (const sessionId of liveSessionIds) {
+                sessions.flushBuffers(sessionId);
+            }
+            sessions.state.clearStreaming();
             // 7. Start new process with retry (exponential backoff, max 3 attempts)
             let lastError;
             for (let i = 0; i < 3; i++) {
@@ -400,17 +485,28 @@ export class AgentBridge extends EventEmitter {
         }
         this.permissionResolvers.clear();
         this.permissionRequestSessions.clear();
-        if (this.proc?.exitCode === null) {
-            const proc = this.proc;
+        const proc = this.proc;
+        if (proc && !this.closedProcesses.has(proc)) {
             await new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    proc.kill(process.platform === "win32" ? undefined : "SIGKILL");
+                let settled = false;
+                const finish = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    this.closedProcesses.add(proc);
+                    clearTimeout(killTimer);
+                    clearTimeout(drainTimer);
+                    proc.off("close", finish);
                     resolve();
+                };
+                const killTimer = setTimeout(() => {
+                    proc.kill(process.platform === "win32" ? undefined : "SIGKILL");
                 }, 5000);
-                proc.on("exit", () => {
-                    clearTimeout(timer);
-                    resolve();
-                });
+                // `close` follows `exit` after stdio has drained. Keep a bounded
+                // fallback for pathological child-process implementations that never
+                // deliver close even after SIGKILL.
+                const drainTimer = setTimeout(finish, 6000);
+                proc.once("close", finish);
                 proc.kill();
             });
         }
@@ -419,6 +515,10 @@ export class AgentBridge extends EventEmitter {
     }
     // --- ACP Client callbacks ---
     handlePermission(params) {
+        const webSessionId = this.sessionIds.getWebSessionId(params.sessionId);
+        if (!webSessionId) {
+            return Promise.resolve({ outcome: { outcome: "cancelled" } });
+        }
         const requestId = crypto.randomUUID();
         const toolCall = params.toolCall;
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- toolCall may be undefined in practice
@@ -429,11 +529,11 @@ export class AgentBridge extends EventEmitter {
         return new Promise((resolve) => {
             // Register resolver BEFORE emitting, so synchronous auto-approve can find it
             this.permissionResolvers.set(requestId, resolve);
-            this.permissionRequestSessions.set(requestId, params.sessionId);
+            this.permissionRequestSessions.set(requestId, webSessionId);
             this.emit("event", {
                 type: "permission_request",
                 requestId,
-                sessionId: params.sessionId,
+                sessionId: webSessionId,
                 title,
                 toolCallId,
                 options: params.options,
@@ -446,9 +546,23 @@ export class AgentBridge extends EventEmitter {
     }
     handleSessionUpdate(params) {
         const update = params.update;
-        const sessionId = params.sessionId;
-        if (this.silentSessions.has(sessionId)) {
-            this.captureSilentText(sessionId, update);
+        const agentSessionId = params.sessionId;
+        if (this.silentSessions.has(agentSessionId)) {
+            this.captureSilentText(agentSessionId, update);
+            return Promise.resolve();
+        }
+        const sessionId = this.sessionIds.getWebSessionId(agentSessionId);
+        if (!sessionId) {
+            if (this.pendingNewSessions > 0 ||
+                this.unboundNewSessionIds.has(agentSessionId)) {
+                const updates = this.pendingSessionUpdates.get(agentSessionId) ?? [];
+                updates.push(update);
+                this.pendingSessionUpdates.set(agentSessionId, updates);
+                return Promise.resolve();
+            }
+            blog.warn("ignored event for unmapped ACP session", {
+                sessionId: agentSessionId,
+            });
             return Promise.resolve();
         }
         const event = this.sessionUpdateToEvent(sessionId, update);
@@ -490,9 +604,26 @@ export class AgentBridge extends EventEmitter {
                     id: update.toolCallId,
                     status: update.status ?? "",
                     content: (update.content ?? undefined),
+                    ...(typeof update.title === "string" ? { title: update.title } : {}),
+                    ...(typeof update.kind === "string" ? { kind: update.kind } : {}),
+                    ...(update.rawInput ? { rawInput: update.rawInput } : {}),
+                    ...(Object.hasOwn(update, "rawOutput")
+                        ? { rawOutput: update.rawOutput }
+                        : {}),
+                    ...(Array.isArray(update.locations)
+                        ? { locations: update.locations }
+                        : {}),
                 };
             case "plan":
                 return { type: "plan", sessionId, entries: update.entries };
+            case "usage_update":
+                return {
+                    type: "usage_update",
+                    sessionId,
+                    used: update.used,
+                    size: update.size,
+                    cost: update.cost,
+                };
             case "config_option_update":
                 return {
                     type: "config_option_update",

package/lib/event-handler.js

@@ -3,6 +3,7 @@ import { log } from "./log.js";
 import { isAutopilotMode } from "./mode-bucket.js";
 const ailog = log.scope("attachment-interceptor");
 const plog = log.scope("push");
+const clog = log.scope("cancel");
 function handleConnected(event, sessions, config) {
     event.cancelTimeout = config.cancelTimeout;
     event.recentPathsLimit = config.recentPathsLimit;
@@ -10,14 +11,8 @@ function handleConnected(event, sessions, config) {
     if (event.agent)
         sessions.agentInfo = event.agent;
 }
-function handleConfigLikeEvent(event, sessions, store) {
-    if (event.configOptions.length)
-        sessions.cachedConfigOptions = event.configOptions;
-    for (const opt of event.configOptions) {
-        if (typeof opt.currentValue === "string") {
-            store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-        }
-    }
+function handleConfigLikeEvent(event, sessions) {
+    sessions.recordConfigOptions(event.sessionId, event.configOptions);
 }
 function handleMessageChunk(event, sessions) {
     sessions.flushThinkingBuffer(event.sessionId);
@@ -45,10 +40,27 @@ function handleToolCall(event, sessions, store) {
         rawInput: event.rawInput,
     }, { from_ref: "agent" });
 }
+function handleUsageUpdate(event, sessions) {
+    sessions.state.patch(event.sessionId, {
+        runtime: {
+            contextUsage: {
+                used: event.used,
+                size: event.size,
+                ...(event.cost !== undefined ? { cost: event.cost } : {}),
+            },
+        },
+    });
+}
 function handlePlan(event, sessions, store) {
     sessions.flushBuffers(event.sessionId);
     sessions.state.patch(event.sessionId, {
-        runtime: { streaming: { assistant: false, thinking: false } },
+        runtime: {
+            streaming: { assistant: false, thinking: false },
+            plan: event.entries.length > 0 &&
+                !event.entries.every((entry) => entry.status === "completed")
+                ? event.entries
+                : null,
+        },
     });
     store.saveEvent(event.sessionId, event.type, { entries: event.entries }, { from_ref: "agent" });
 }
@@ -144,18 +156,61 @@ function handlePermissionRequest(event, sessions, store, bridge, sseManager, con
     return false;
 }
 function handlePromptDone(event, sessions, store) {
-    sessions.activePrompts.delete(event.sessionId);
-    sessions.syncBusy(event.sessionId);
+    const cancelStatus = sessions.state.getState(event.sessionId).runtime.busy?.cancelStatus ?? null;
+    if (cancelStatus !== null) {
+        clog.info("agent completed after request", {
+            sessionId: event.sessionId.slice(0, 8),
+            requestedStatus: cancelStatus,
+            stopReason: event.stopReason,
+        });
+    }
+    // The tail this turn buffered must always land, even when the turn has
+    // already been superseded — it is the only copy of that text.
+    const isCurrent = sessions.isCurrentPrompt(event.sessionId, event.promptId);
+    if (isCurrent) {
+        sessions.activePrompts.delete(event.sessionId);
+        sessions.syncBusy(event.sessionId);
+    }
+    else {
+        clog.info("completion from a superseded turn", {
+            sessionId: event.sessionId.slice(0, 8),
+            promptId: event.promptId,
+            stopReason: event.stopReason,
+        });
+    }
     sessions.flushBuffers(event.sessionId);
     sessions.state.patch(event.sessionId, {
         runtime: { streaming: { assistant: false, thinking: false } },
     });
-    store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason }, { from_ref: "agent" });
+    store.saveEvent(event.sessionId, event.type, {
+        stopReason: event.stopReason,
+        // Replay must be able to make the same judgement the live path does.
+        ...(event.promptId ? { promptId: event.promptId } : {}),
+    }, { from_ref: "agent" });
 }
-function handleError(event, sessions) {
+function handleError(event, sessions, store) {
     if (event.sessionId) {
-        sessions.activePrompts.delete(event.sessionId);
-        sessions.syncBusy(event.sessionId);
+        // Same attribution as a completion: a superseded turn failing late must
+        // not end the turn that replaced it. The buffered tail still flushes.
+        if (sessions.isCurrentPrompt(event.sessionId, event.promptId)) {
+            sessions.activePrompts.delete(event.sessionId);
+            sessions.syncBusy(event.sessionId);
+        }
+        else {
+            clog.info("failure from a superseded turn", {
+                sessionId: event.sessionId.slice(0, 8),
+                promptId: event.promptId,
+                message: event.message,
+            });
+        }
+        sessions.flushBuffers(event.sessionId);
+        sessions.state.patch(event.sessionId, {
+            runtime: { streaming: { assistant: false, thinking: false } },
+        });
+        store.saveEvent(event.sessionId, event.type, {
+            message: event.message,
+            ...(event.promptId ? { promptId: event.promptId } : {}),
+        }, { from_ref: "agent" });
     }
 }
 function dispatchAgentEvent(event, sessions, store, bridge, config, sseManager) {
@@ -166,7 +221,7 @@ function dispatchAgentEvent(event, sessions, store, bridge, config, sseManager)
             return false;
         case "session_created":
         case "config_option_update":
-            handleConfigLikeEvent(event, sessions, store);
+            handleConfigLikeEvent(event, sessions);
             return false;
         case "message_chunk":
             handleMessageChunk(event, sessions);
@@ -178,7 +233,15 @@ function dispatchAgentEvent(event, sessions, store, bridge, config, sseManager)
             handleToolCall(event, sessions, store);
             return false;
         case "tool_call_update":
-            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content }, { from_ref: "agent" });
+            store.saveEvent(event.sessionId, event.type, {
+                id: event.id,
+                status: event.status,
+                content: event.content,
+                title: event.title,
+                kind: event.kind,
+                rawInput: event.rawInput,
+                locations: event.locations,
+            }, { from_ref: "agent" });
             return false;
         case "plan":
             handlePlan(event, sessions, store);
@@ -189,7 +252,7 @@ function dispatchAgentEvent(event, sessions, store, bridge, config, sseManager)
             handlePromptDone(event, sessions, store);
             return false;
         case "error":
-            handleError(event, sessions);
+            handleError(event, sessions, store);
             return false;
     }
     return false;
@@ -213,6 +276,10 @@ function maybePushNotify(event, pushService) {
     });
 }
 export function handleAgentEvent(event, sessions, store, bridge, config, sseManager, pushService, _clientRegistry) {
+    if (event.type === "usage_update") {
+        handleUsageUpdate(event, sessions);
+        return;
+    }
     if (event.type === "available_commands_update") {
         const snapshot = sessions.updateAgentCommands(event.sessionId, event.commands);
         if (sessions.restoringSessions.has(event.sessionId))
@@ -221,6 +288,12 @@ export function handleAgentEvent(event, sessions, store, bridge, config, sseMana
         return;
     }
     if (event.type === "agent_reloading" || event.type === "agent_disconnected") {
+        for (const sessionId of sessions.liveSessions) {
+            sessions.flushBuffers(sessionId);
+        }
+        sessions.state.clearStreaming();
+        sessions.state.clearPlans();
+        sessions.state.clearContextUsage();
         for (const snapshot of sessions.clearAgentCommands()) {
             sseManager.broadcast({
                 type: "available_commands_update",

package/lib/files/limits.js

@@ -0,0 +1,15 @@
+/**
+ * File viewer size limits.
+ *
+ * Kept as plain exported constants for now so the routes have a single,
+ * testable knob; wiring these into `[limits]` config is a later milestone.
+ * Values stay in the same order of magnitude as attachment limits and keep
+ * rendered previews bounded. Files outside preview limits stream as downloads
+ * instead of being buffered in server or browser memory.
+ */
+/** Directory listings cap — beyond this the response is truncated + flagged. */
+export const MAX_LIST_ITEMS = 2000;
+/** Text/Markdown/code preview + highlight cap; larger files download. */
+export const MAX_TEXT_PREVIEW_BYTES = 1024 * 1024; // 1 MiB
+/** Image render cap — larger images stream as downloads. */
+export const MAX_IMAGE_BYTES = 20 * 1024 * 1024; // 20 MB