@lelouchhe/webagent 0.7.0 → 0.9.0

package/lib/server.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { loadConfig } from "./config.js";
 import { setLogLevel, log } from "./log.js";
 import { AgentBridge } from "./bridge.js";
+import { agentKeyFromCommand } from "./agent-key.js";
 import { Store } from "./store.js";
 import { SessionManager } from "./session-manager.js";
 import { TitleService } from "./title-service.js";
@@ -53,7 +54,7 @@ const PKG_VERSION = (() => {
     }
 })();
 // --- Core dependencies ---
-const store = new Store(config.data_dir);
+const store = new Store(config.data_dir, agentKeyFromCommand(preflight.agentCmd));
 console.log(`[store] using ${config.data_dir}/`);
 // Pin <data_dir>/sessions realpath at boot so all later anchor checks
 // (file:// URI construction, permission interceptor) compare against the
@@ -104,31 +105,34 @@ 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 requestHandler = createRequestHandler({
+    store,
+    sessions,
+    sseManager,
+    clientRegistry,
+    titleService,
+    getBridge: () => bridge,
+    publicDir: PUBLIC_DIR,
+    dataDir: config.data_dir,
+    limits: config.limits,
+    pushService,
+    serverVersion: PKG_VERSION,
+    debugLevel: config.debug.level,
+    authStore,
+    ticketStore,
+    attachmentSecret,
+    shareConfig: config.share,
+});
 const server = createServer((req, res) => {
-    void createRequestHandler({
-        store,
-        sessions,
-        sseManager,
-        clientRegistry,
-        titleService,
-        getBridge: () => bridge,
-        publicDir: PUBLIC_DIR,
-        dataDir: config.data_dir,
-        limits: config.limits,
-        pushService,
-        serverVersion: PKG_VERSION,
-        debugLevel: config.debug.level,
-        authStore,
-        ticketStore,
-        attachmentSecret,
-        shareConfig: config.share,
-    })(req, res);
+    void requestHandler(req, res);
 });
 async function initBridge(agentCmd) {
-    const b = new AgentBridge(agentCmd);
+    const b = new AgentBridge(agentCmd, store);
     b.setAttachmentDispatcher(attachmentDispatcher);
     const eventHandlerConfig = _buildBridgeEventHandlerConfig({
         cancelTimeout: config.limits.cancel_timeout,
@@ -153,7 +157,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 +189,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

@@ -3,12 +3,14 @@ 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 { abbreviateHomePath, expandHomePath } from "./home-path.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") {
@@ -18,19 +20,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.
@@ -42,13 +48,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
@@ -76,15 +89,15 @@ 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") {
-        const sessionCwd = cwd ?? this.defaultCwd;
+    async createSession(bridge, cwd, inheritFromSessionId, source = "auto", opts) {
+        const sessionCwd = expandHomePath(cwd ?? this.defaultCwd);
         try {
             const info = await stat(sessionCwd);
             if (!info.isDirectory())
                 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);
@@ -97,33 +110,124 @@ export class SessionManager {
         const sourceSession = inheritFromSessionId
             ? this.store.getSession(inheritFromSessionId)
             : null;
-        const { sessionId } = await bridge.newSession(sessionCwd);
-        this.liveSessions.add(sessionId);
-        this.store.createSession(sessionId, sessionCwd, source);
+        const webSessionId = randomUUID();
+        const { sessionId: agentSessionId, configOptions: createdConfigOptions } = await bridge.newSession(sessionCwd, { silent: opts?.silent });
+        let configOptions = createdConfigOptions;
+        try {
+            this.store.createSession(webSessionId, sessionCwd, source, agentSessionId);
+        }
+        catch (err) {
+            slog.warn("ACP session created but local persistence failed", {
+                agentSessionId,
+                error: err,
+            });
+            bridge.discardUnboundSession?.(agentSessionId);
+            throw err;
+        }
+        this.liveSessions.add(webSessionId);
+        this.recordConfigOptions(webSessionId, createdConfigOptions);
+        bridge.sessionMapped?.(agentSessionId);
         // Inherit config options from source session
         if (sourceSession) {
+            const thinkingOption = createdConfigOptions.find((option) => "options" in option &&
+                (option.id === "reasoning_effort" ||
+                    option.id === "thought_level" ||
+                    option.category === "thought_level"));
             const inherited = [
                 { configId: "model", value: sourceSession.model },
-                { configId: "reasoning_effort", value: sourceSession.reasoning_effort },
+                {
+                    configId: thinkingOption?.id ?? "reasoning_effort",
+                    value: sourceSession.reasoning_effort,
+                },
             ];
             for (const { configId, value } of inherited) {
                 if (!value)
                     continue;
                 try {
-                    await bridge.setConfigOption(sessionId, configId, value);
-                    this.store.updateSessionConfig(sessionId, configId, value);
+                    const updatedConfigOptions = await bridge.setConfigOption(webSessionId, configId, value);
+                    if (updatedConfigOptions.length > 0) {
+                        configOptions = updatedConfigOptions;
+                        this.recordConfigOptions(webSessionId, updatedConfigOptions);
+                    }
+                    else {
+                        this.store.updateSessionConfig(webSessionId, configId, value);
+                    }
                 }
                 catch {
                     // Option may no longer be available; ignore
                 }
             }
         }
-        const session = this.store.getSession(sessionId);
+        const session = this.store.getSession(webSessionId);
         return {
-            sessionId,
-            configOptions: session ? this.buildConfigOptions(session) : [],
+            sessionId: webSessionId,
+            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);
@@ -136,6 +240,7 @@ export class SessionManager {
                 type: "session_created",
                 sessionId,
                 cwd: session.cwd,
+                cwdDisplay: abbreviateHomePath(session.cwd),
                 title: session.title,
                 configOptions,
             };
@@ -159,6 +264,7 @@ export class SessionManager {
                 type: "session_created",
                 sessionId,
                 cwd: session.cwd,
+                cwdDisplay: abbreviateHomePath(session.cwd),
                 title: session.title,
                 configOptions,
             };
@@ -179,33 +285,42 @@ export class SessionManager {
      * DB row — setConfigOption's currentValue for unrelated keys is the
      * agent's in-memory default, not the user's preference.
      *
-     * Key priority mode > reasoning_effort > model:
+     * Key priority mode > thinking aliases > model:
      *   - mode is a small stable enum, rewriting current value is idempotent.
+     *   - ACP agents use both reasoning_effort and thought_level for thinking.
      *   - model has the highest schema-drift risk (agent upgrades drop values).
      */
     async tryWarmCache(bridge, sessionId, session) {
         if (this.cachedConfigOptions.length > 0)
             return;
-        const pick = session.mode
-            ? { id: "mode", value: session.mode }
-            : session.reasoning_effort
-                ? { id: "reasoning_effort", value: session.reasoning_effort }
-                : session.model
-                    ? { id: "model", value: session.model }
-                    : null;
-        if (!pick)
+        const candidates = [];
+        if (session.mode)
+            candidates.push({ id: "mode", value: session.mode });
+        if (session.reasoning_effort) {
+            candidates.push({ id: "reasoning_effort", value: session.reasoning_effort }, { id: "thought_level", value: session.reasoning_effort });
+        }
+        if (session.model)
+            candidates.push({ id: "model", value: session.model });
+        if (candidates.length === 0)
             return;
-        try {
-            const opts = await bridge.setConfigOption(sessionId, pick.id, pick.value);
-            if (opts.length > 0) {
-                this.cachedConfigOptions = opts;
-                slog.info("warmed cache on resume", { options: opts.length });
+        let lastError = null;
+        for (const candidate of candidates) {
+            try {
+                const opts = await bridge.setConfigOption(sessionId, candidate.id, candidate.value);
+                if (opts.length > 0) {
+                    this.cachedConfigOptions = opts;
+                    slog.info("warmed cache on resume", { options: opts.length });
+                    return;
+                }
+            }
+            catch (err) {
+                lastError = err;
             }
         }
-        catch (err) {
+        if (lastError) {
             slog.warn("cache warming failed", {
                 sessionId: sessionId.slice(0, 8) + "…",
-                error: err,
+                error: lastError,
             });
         }
     }
@@ -233,14 +348,17 @@ 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,
             reasoning_effort: session.reasoning_effort,
+            thought_level: session.reasoning_effort,
         };
         return configOptions.map((opt) => {
-            const override = stored[opt.id];
+            const override = opt.category === "thought_level"
+                ? session.reasoning_effort
+                : stored[opt.id];
             if (override && "options" in opt)
                 return { ...opt, currentValue: override };
             return opt;
@@ -311,6 +429,11 @@ 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);
@@ -338,17 +461,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. */
@@ -366,12 +489,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
@@ -390,8 +553,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: {
@@ -399,6 +568,7 @@ export class SessionManager {
                     kind: kind,
                     since: current?.kind === kind ? current.since : new Date().toISOString(),
                     promptId: nextPromptId,
+                    cancelStatus: null,
                 },
             },
         });
@@ -417,13 +587,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);
         });