@lelouchhe/webagent 0.6.0 → 0.8.0

package/lib/server.js

@@ -104,7 +104,9 @@ sessions.state.onPatch((event) => {
     sseManager.broadcast(event);
 });
 let bridge = null;
-let messageCleanup = null;
+const messageCleanup = startMessageCleanup(store, config.messages.unprocessed_ttl_days, (pendingCount) => {
+    sseManager.broadcastGlobal({ type: "inbox_count_changed", pendingCount });
+});
 let sharePreviewCleanup = null;
 // --- HTTP server ---
 const server = createServer((req, res) => {
@@ -153,7 +155,7 @@ async function initBridge(agentCmd) {
 async function shutdown() {
     console.log("\n[server] shutting down...");
     sseManager.stopHeartbeat();
-    messageCleanup?.stop();
+    messageCleanup.stop();
     sharePreviewCleanup?.stop();
     sessions.killAllBashProcs();
     await bridge?.shutdown();
@@ -185,7 +187,6 @@ server.listen(config.port, config.host, () => {
         // will use. If the gate ran, auth.json exists and has ≥ 1 token.
         await authStore.load();
         console.log(`[server] listening on http://localhost:${config.port}`);
-        messageCleanup = startMessageCleanup(store, config.messages.unprocessed_ttl_days);
         if (config.share.enabled) {
             sharePreviewCleanup = startSharePreviewCleanup(store);
             console.log(`[share] preview gc armed (24h interval)`);

package/lib/session-manager.js

@@ -1,13 +1,15 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { rm } from "node:fs/promises";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
+import { MessageNotFoundError } from "./store.js";
 import { SessionStateManager } from "./session-state.js";
 import { buildLabelMap } from "./attachment-labels.js";
 import { log } from "./log.js";
 const slog = log.scope("session");
 const IS_WIN = process.platform === "win32";
-export function interruptBashProc(proc) {
+export function interruptBashProc(proc, force = false) {
     if (!proc)
         return;
     if (IS_WIN && typeof proc.pid === "number") {
@@ -17,19 +19,23 @@ export function interruptBashProc(proc) {
     }
     if (typeof proc.pid === "number") {
         try {
-            process.kill(-proc.pid, "SIGINT");
+            process.kill(-proc.pid, force ? "SIGKILL" : "SIGINT");
             return;
         }
         catch {
             // Fall through to direct child kill when the process is not a group leader.
         }
     }
-    proc.kill("SIGINT");
+    proc.kill(force ? "SIGKILL" : "SIGINT");
 }
-/** Known config option IDs that we persist per-session. */
-const _PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
 /** Minimum age (seconds) before an empty session is eligible for cleanup. */
 const EMPTY_SESSION_MIN_AGE_S = 60;
+export class InvalidSessionDirectoryError extends Error {
+    constructor(cwd) {
+        super(`Directory does not exist: ${cwd}`);
+        this.name = "InvalidSessionDirectoryError";
+    }
+}
 /**
  * Centralizes all session-related state that was previously scattered
  * across module-level variables in server.ts.
@@ -41,13 +47,20 @@ export class SessionManager {
     assistantBuffers = new Map();
     thinkingBuffers = new Map();
     activePrompts = new Set();
+    pendingPromptSubmissions = new Map();
+    cancelledPromptSubmissions = new Set();
     runningBashProcs = new Map();
+    interruptedBashProcs = new WeakSet();
     /** Pending permission requests keyed by requestId. */
     pendingPermissions = new Map();
     /** Per-session runtime state (busy/streaming/permissions snapshots + patches). */
     state = new SessionStateManager();
     /** Deduplicates concurrent resume calls for the same session. */
     pendingResumes = new Map();
+    nextPromptNumber = 0;
+    nextPromptSubmissionNumber = 0;
+    /** Deduplicates concurrent attempts to materialize one inbox message. */
+    pendingMessageConsumes = new Map();
     /**
      * Per-session attachment label map (CLAUDE.md "Attachment label
      * egress rewrite"). Built lazily from the `attachments` table on
@@ -55,6 +68,8 @@ export class SessionManager {
      * DELETE. Lookup is cheap (Map.get); rebuild is one SQLite query.
      */
     attachmentLabelCache = new Map();
+    agentCommandSnapshots = new Map();
+    agentCommandEpoch = randomUUID();
     cachedConfigOptions = [];
     agentInfo = null;
     store;
@@ -73,7 +88,7 @@ export class SessionManager {
         }
     }
     /** Create a new session in both bridge and store, inheriting the source session's config. */
-    async createSession(bridge, cwd, inheritFromSessionId, source = "auto") {
+    async createSession(bridge, cwd, inheritFromSessionId, source = "auto", opts) {
         const sessionCwd = cwd ?? this.defaultCwd;
         try {
             const info = await stat(sessionCwd);
@@ -81,20 +96,33 @@ export class SessionManager {
                 throw new Error("not a directory");
         }
         catch {
-            throw new Error(`Directory does not exist: ${sessionCwd}`);
+            throw new InvalidSessionDirectoryError(sessionCwd);
         }
         // Clean up empty sessions (no events) older than the threshold
         const cleaned = this.store.deleteEmptySessions(EMPTY_SESSION_MIN_AGE_S);
-        for (const id of cleaned)
+        for (const id of cleaned) {
             this.liveSessions.delete(id);
+            this.agentCommandSnapshots.delete(id);
+        }
         if (cleaned.length > 0)
             slog.info("cleaned empty session(s)", { count: cleaned.length });
         const sourceSession = inheritFromSessionId
             ? this.store.getSession(inheritFromSessionId)
             : null;
-        const { sessionId } = await bridge.newSession(sessionCwd);
+        const { sessionId, configOptions: createdConfigOptions } = await bridge.newSession(sessionCwd, { silent: opts?.silent });
+        let configOptions = createdConfigOptions;
+        try {
+            this.store.createSession(sessionId, sessionCwd, source);
+        }
+        catch (err) {
+            slog.warn("ACP session created but local persistence failed", {
+                sessionId,
+                error: err,
+            });
+            throw err;
+        }
         this.liveSessions.add(sessionId);
-        this.store.createSession(sessionId, sessionCwd, source);
+        this.recordConfigOptions(sessionId, createdConfigOptions);
         // Inherit config options from source session
         if (sourceSession) {
             const inherited = [
@@ -105,8 +133,14 @@ export class SessionManager {
                 if (!value)
                     continue;
                 try {
-                    await bridge.setConfigOption(sessionId, configId, value);
-                    this.store.updateSessionConfig(sessionId, configId, value);
+                    const updatedConfigOptions = await bridge.setConfigOption(sessionId, configId, value);
+                    if (updatedConfigOptions.length > 0) {
+                        configOptions = updatedConfigOptions;
+                        this.recordConfigOptions(sessionId, updatedConfigOptions);
+                    }
+                    else {
+                        this.store.updateSessionConfig(sessionId, configId, value);
+                    }
                 }
                 catch {
                     // Option may no longer be available; ignore
@@ -116,9 +150,73 @@ export class SessionManager {
         const session = this.store.getSession(sessionId);
         return {
             sessionId,
-            configOptions: session ? this.buildConfigOptions(session) : [],
+            configOptions: session
+                ? this.applyStoredConfig(configOptions, session)
+                : [],
         };
     }
+    /** Cache the ACP config schema and persist this session's current values. */
+    recordConfigOptions(sessionId, configOptions) {
+        if (configOptions.length === 0)
+            return;
+        this.cachedConfigOptions = configOptions;
+        for (const option of configOptions) {
+            if (typeof option.currentValue === "string") {
+                this.store.updateSessionConfig(sessionId, option.id, option.currentValue);
+            }
+        }
+    }
+    /**
+     * Materialize a pending inbox message as a real ACP-backed session.
+     * Returns null when the message is neither pending nor previously consumed.
+     */
+    consumeMessage(bridge, messageId, inheritFromSessionId) {
+        const pending = this.pendingMessageConsumes.get(messageId);
+        if (pending)
+            return pending;
+        const existing = this.store.findConsumedMessageSession(messageId);
+        if (existing) {
+            return Promise.resolve({
+                sessionId: existing,
+                alreadyConsumed: true,
+            });
+        }
+        const operation = this.consumePendingMessage(bridge, messageId, inheritFromSessionId).finally(() => {
+            if (this.pendingMessageConsumes.get(messageId) === operation) {
+                this.pendingMessageConsumes.delete(messageId);
+            }
+        });
+        this.pendingMessageConsumes.set(messageId, operation);
+        return operation;
+    }
+    async consumePendingMessage(bridge, messageId, inheritFromSessionId) {
+        const message = this.store.getMessage(messageId);
+        if (!message)
+            return null;
+        const { sessionId } = await this.createSession(bridge, message.cwd ?? undefined, inheritFromSessionId, "message", { silent: true });
+        try {
+            const result = this.store.consumeMessageTx(messageId, sessionId);
+            if (result.alreadyConsumed) {
+                this.deleteSession(sessionId);
+            }
+            return result;
+        }
+        catch (err) {
+            this.deleteSession(sessionId);
+            if (err instanceof MessageNotFoundError) {
+                const consumedSessionId = this.store.findConsumedMessageSession(messageId);
+                return consumedSessionId
+                    ? { sessionId: consumedSessionId, alreadyConsumed: true }
+                    : null;
+            }
+            slog.warn("message consume left an unreachable ACP session", {
+                messageId,
+                sessionId,
+                error: err,
+            });
+            throw err;
+        }
+    }
     /** Resume a session — returns event to send to the requesting client. */
     async resumeSession(bridge, sessionId) {
         const session = this.store.getSession(sessionId);
@@ -228,7 +326,7 @@ export class SessionManager {
     /** Override currentValue in configOptions with stored session values. */
     applyStoredConfig(configOptions, session) {
         if (!configOptions.length)
-            return this.cachedConfigOptions;
+            return configOptions;
         const stored = {
             model: session.model,
             mode: session.mode,
@@ -262,6 +360,42 @@ export class SessionManager {
     invalidateLabelCache(sessionId) {
         this.attachmentLabelCache.delete(sessionId);
     }
+    updateAgentCommands(sessionId, commands) {
+        const current = this.agentCommandSnapshots.get(sessionId);
+        const snapshot = {
+            epoch: this.agentCommandEpoch,
+            revision: (current?.revision ?? 0) + 1,
+            commands: commands.map((command) => ({
+                ...command,
+                ...(command.input ? { input: { ...command.input } } : {}),
+            })),
+        };
+        this.agentCommandSnapshots.set(sessionId, snapshot);
+        return snapshot;
+    }
+    getAgentCommands(sessionId) {
+        return (this.agentCommandSnapshots.get(sessionId) ?? {
+            epoch: this.agentCommandEpoch,
+            revision: 0,
+            commands: [],
+        });
+    }
+    clearAgentCommands() {
+        const cleared = [];
+        for (const [sessionId, current] of this.agentCommandSnapshots) {
+            const snapshot = {
+                epoch: this.agentCommandEpoch,
+                revision: current.revision + 1,
+                commands: [],
+            };
+            this.agentCommandSnapshots.set(sessionId, snapshot);
+            cleared.push({
+                sessionId,
+                ...snapshot,
+            });
+        }
+        return cleared;
+    }
     /** Delete a session from store and clean up all state (including images). */
     deleteSession(sessionId) {
         const mode = this.store.deleteSession(sessionId);
@@ -270,8 +404,14 @@ export class SessionManager {
         this.assistantBuffers.delete(sessionId);
         this.thinkingBuffers.delete(sessionId);
         this.activePrompts.delete(sessionId);
+        const pendingSubmission = this.pendingPromptSubmissions.get(sessionId);
+        this.pendingPromptSubmissions.delete(sessionId);
+        if (pendingSubmission !== undefined) {
+            this.cancelledPromptSubmissions.delete(pendingSubmission);
+        }
         this.runningBashProcs.delete(sessionId);
         this.attachmentLabelCache.delete(sessionId);
+        this.agentCommandSnapshots.delete(sessionId);
         // Clean pending permissions for this session
         for (const [reqId, perm] of this.pendingPermissions) {
             if (perm.sessionId === sessionId)
@@ -296,17 +436,17 @@ export class SessionManager {
     /** Flush only the assistant message buffer to store. */
     flushAssistantBuffer(sessionId) {
         const assistant = this.assistantBuffers.get(sessionId);
-        if (assistant) {
+        this.assistantBuffers.delete(sessionId);
+        if (assistant && this.store.getSession(sessionId)) {
             this.store.saveEvent(sessionId, "assistant_message", { text: assistant }, { from_ref: "agent" });
-            this.assistantBuffers.delete(sessionId);
         }
     }
     /** Flush only the thinking buffer to store. */
     flushThinkingBuffer(sessionId) {
         const thinking = this.thinkingBuffers.get(sessionId);
-        if (thinking) {
+        this.thinkingBuffers.delete(sessionId);
+        if (thinking && this.store.getSession(sessionId)) {
             this.store.saveEvent(sessionId, "thinking", { text: thinking }, { from_ref: "agent" });
-            this.thinkingBuffers.delete(sessionId);
         }
     }
     /** Append to assistant message buffer. */
@@ -324,12 +464,52 @@ export class SessionManager {
         return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
     }
     getBusyKind(sessionId) {
-        if (this.runningBashProcs.has(sessionId))
-            return "bash";
+        if (this.pendingPromptSubmissions.has(sessionId))
+            return "agent";
         if (this.activePrompts.has(sessionId))
             return "agent";
+        if (this.runningBashProcs.has(sessionId))
+            return "bash";
         return null;
     }
+    /**
+     * True when `promptId` still names the session's live turn. A turn can
+     * outlive its own supersession — cancelling one and immediately starting
+     * another interleaves them — and its terminal work must not clear state
+     * that now belongs to the replacement. An absent id is treated as current
+     * so callers predating turn identity keep their old behaviour.
+     */
+    isCurrentPrompt(sessionId, promptId) {
+        if (!promptId)
+            return true;
+        const current = this.state.getState(sessionId).runtime.busy?.promptId;
+        return current == null || current === promptId;
+    }
+    reservePromptSubmission(sessionId) {
+        if (this.getBusyKind(sessionId) !== null)
+            return null;
+        const submissionId = ++this.nextPromptSubmissionNumber;
+        this.pendingPromptSubmissions.set(sessionId, submissionId);
+        return submissionId;
+    }
+    cancelPendingPromptSubmission(sessionId) {
+        const submissionId = this.pendingPromptSubmissions.get(sessionId);
+        if (submissionId === undefined)
+            return false;
+        this.cancelledPromptSubmissions.add(submissionId);
+        return true;
+    }
+    isPromptSubmissionCancelled(submissionId) {
+        return this.cancelledPromptSubmissions.has(submissionId);
+    }
+    releasePromptSubmission(sessionId, submissionId, sync = true) {
+        if (this.pendingPromptSubmissions.get(sessionId) === submissionId) {
+            this.pendingPromptSubmissions.delete(sessionId);
+        }
+        this.cancelledPromptSubmissions.delete(submissionId);
+        if (sync)
+            this.syncBusy(sessionId);
+    }
     /**
      * Recompute busy from active prompts/bash procs and patch the state manager.
      * Call this immediately after mutating activePrompts / runningBashProcs so
@@ -348,8 +528,14 @@ export class SessionManager {
             this.state.clearCancelSafety(sessionId);
             return;
         }
-        const nextPromptId = kind === "agent" ? (promptId ?? current?.promptId ?? null) : null;
-        if (current?.kind === kind && current.promptId === nextPromptId)
+        const nextPromptId = kind === "agent"
+            ? (promptId ??
+                (current?.kind === "agent"
+                    ? current.promptId
+                    : `prompt-${++this.nextPromptNumber}`))
+            : null;
+        const sameWork = current?.kind === kind && current.promptId === nextPromptId;
+        if (sameWork)
             return;
         this.state.patch(sessionId, {
             runtime: {
@@ -357,6 +543,7 @@ export class SessionManager {
                     kind: kind,
                     since: current?.kind === kind ? current.since : new Date().toISOString(),
                     promptId: nextPromptId,
+                    cancelStatus: null,
                 },
             },
         });
@@ -375,13 +562,16 @@ export class SessionManager {
         });
         this.activePrompts.add(sessionId);
         this.syncBusy(sessionId);
+        const promptId = this.state.getState(sessionId).runtime.busy?.promptId ?? undefined;
         bridge
-            .prompt(sessionId, "Continue your previous response — it was interrupted mid-way.")
+            .prompt(sessionId, "Continue your previous response — it was interrupted mid-way.", undefined, promptId)
             .catch((err) => {
             slog.error("auto-retry failed", {
                 sessionId: sessionId.slice(0, 8) + "…",
                 error: err,
             });
+            if (!this.isCurrentPrompt(sessionId, promptId))
+                return;
             this.activePrompts.delete(sessionId);
             this.syncBusy(sessionId);
         });

package/lib/session-state.js

@@ -1,12 +1,14 @@
 /**
  * Per-session runtime state: single source of truth for "what state is this
- * session in right now" (busy / streaming / pending permissions).
+ * session in right now" (busy / streaming / pending permissions / plan).
  *
  * The frontend fetches a full snapshot on connect / reconnect / after long
  * backgrounding, then applies incremental `state_patch` SSE events. This
  * replaces the old "replay history + reconcile" approach which repeatedly
  * grew one-off sync paths per state field.
  */
+import { log } from "./log.js";
+const clog = log.scope("cancel");
 function defaultState() {
     return {
         seq: 0,
@@ -14,6 +16,7 @@ function defaultState() {
             busy: null,
             pendingPermissions: [],
             streaming: { assistant: false, thinking: false },
+            plan: null,
         },
     };
 }
@@ -22,7 +25,10 @@ function busyEqual(a, b) {
         return true;
     if (a === null || b === null)
         return false;
-    return a.kind === b.kind && a.since === b.since && a.promptId === b.promptId;
+    return (a.kind === b.kind &&
+        a.since === b.since &&
+        a.promptId === b.promptId &&
+        (a.cancelStatus ?? null) === (b.cancelStatus ?? null));
 }
 function permsEqual(a, b) {
     if (a.length !== b.length)
@@ -43,6 +49,13 @@ function permsEqual(a, b) {
     }
     return true;
 }
+function plansEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    return a.every((entry, index) => entry.status === b[index].status && entry.content === b[index].content);
+}
 /** True when the patch would change the current runtime state. */
 function hasRuntimeChanges(current, patch) {
     if (!patch)
@@ -53,6 +66,8 @@ function hasRuntimeChanges(current, patch) {
         patch.pendingPermissions &&
         !permsEqual(current.pendingPermissions, patch.pendingPermissions))
         return true;
+    if ("plan" in patch && !plansEqual(current.plan, patch.plan ?? null))
+        return true;
     if ("streaming" in patch && patch.streaming) {
         const s = patch.streaming;
         if (s.assistant !== undefined &&
@@ -76,6 +91,11 @@ export class SessionStateManager {
         }
         return s;
     }
+    /** Read streaming state without creating runtime state for an unseen session. */
+    peekStreaming(sessionId) {
+        const streaming = this.states.get(sessionId)?.runtime.streaming;
+        return streaming ? { ...streaming } : { assistant: false, thinking: false };
+    }
     /**
      * Merge a patch into the session's runtime state. Bumps seq and notifies
      * listeners only when the patch actually changes something (no-op patches
@@ -95,6 +115,10 @@ export class SessionStateManager {
                 state.runtime.pendingPermissions =
                     patch.runtime.pendingPermissions.slice();
             }
+            if ("plan" in patch.runtime) {
+                state.runtime.plan =
+                    patch.runtime.plan?.map((entry) => ({ ...entry })) ?? null;
+            }
             if ("streaming" in patch.runtime && patch.runtime.streaming) {
                 if (patch.runtime.streaming.assistant !== undefined) {
                     state.runtime.streaming.assistant = patch.runtime.streaming.assistant;
@@ -130,9 +154,30 @@ export class SessionStateManager {
             this.cancelTimers.delete(sessionId);
         }
     }
+    /** Clear current plans for every known session (used on bridge reload). */
+    clearPlans() {
+        for (const [sessionId, state] of this.states) {
+            if (state.runtime.plan !== null) {
+                this.patch(sessionId, { runtime: { plan: null } });
+            }
+        }
+    }
+    /** Clear active stream markers for every known session on bridge teardown. */
+    clearStreaming() {
+        for (const [sessionId, state] of this.states) {
+            if (state.runtime.streaming.assistant ||
+                state.runtime.streaming.thinking) {
+                this.patch(sessionId, {
+                    runtime: {
+                        streaming: { assistant: false, thinking: false },
+                    },
+                });
+            }
+        }
+    }
     /**
-     * Backend safety net for cancel: if busy is still set after `timeoutMs`,
-     * force-clear it. Replaces the old frontend cancel timer.
+     * Backend acknowledgement timer for cancel: if the same agent prompt is
+     * still pending after `timeoutMs`, mark the request unconfirmed.
      * A second arm on the same session replaces the existing timer.
      */
     armCancelSafety(sessionId, timeoutMs) {
@@ -143,12 +188,32 @@ export class SessionStateManager {
             clearTimeout(existing);
         const t = setTimeout(() => {
             this.cancelTimers.delete(sessionId);
-            this.patch(sessionId, { runtime: { busy: null } });
+            const busy = this.getState(sessionId).runtime.busy;
+            if (busy?.kind === "agent" && busy.cancelStatus === "requested") {
+                clog.warn("agent did not acknowledge", {
+                    sessionId: sessionId.slice(0, 8),
+                    promptId: busy.promptId,
+                });
+                this.patch(sessionId, {
+                    runtime: {
+                        busy: { ...busy, cancelStatus: "unconfirmed" },
+                    },
+                });
+            }
         }, timeoutMs);
         if (typeof t === "object" && "unref" in t)
             t.unref();
         this.cancelTimers.set(sessionId, t);
     }
+    /** Mark that a cancel notification was sent for the active agent prompt. */
+    markCancelRequested(sessionId) {
+        const busy = this.getState(sessionId).runtime.busy;
+        if (busy?.kind !== "agent")
+            return;
+        this.patch(sessionId, {
+            runtime: { busy: { ...busy, cancelStatus: "requested" } },
+        });
+    }
     /** Cancel the safety net timer (e.g. when prompt_done arrives naturally). */
     clearCancelSafety(sessionId) {
         const t = this.cancelTimers.get(sessionId);