@lelouchhe/webagent 0.9.0 → 0.10.0

package/lib/session-manager.js

@@ -1,638 +0,0 @@
-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 { 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, force = false) {
-    if (!proc)
-        return;
-    if (IS_WIN && typeof proc.pid === "number") {
-        // Windows: kill entire process tree since there are no process groups
-        spawn("taskkill", ["/T", "/F", "/PID", String(proc.pid)]).unref();
-        return;
-    }
-    if (typeof proc.pid === "number") {
-        try {
-            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(force ? "SIGKILL" : "SIGINT");
-}
-/** 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.
- */
-export class SessionManager {
-    liveSessions = new Set();
-    restoringSessions = new Set();
-    sessionHasTitle = new Set();
-    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
-     * first read; invalidated on attachment INSERT and session
-     * DELETE. Lookup is cheap (Map.get); rebuild is one SQLite query.
-     */
-    attachmentLabelCache = new Map();
-    agentCommandSnapshots = new Map();
-    agentCommandEpoch = randomUUID();
-    cachedConfigOptions = [];
-    agentInfo = null;
-    store;
-    defaultCwd;
-    dataDir;
-    constructor(store, defaultCwd, dataDir) {
-        this.store = store;
-        this.defaultCwd = defaultCwd;
-        this.dataDir = dataDir;
-    }
-    /** Populate sessionHasTitle from existing DB sessions on startup. */
-    hydrate() {
-        for (const s of this.store.listSessions()) {
-            if (s.title)
-                this.sessionHasTitle.add(s.id);
-        }
-    }
-    /** Create a new session in both bridge and store, inheriting the source session's config. */
-    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 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) {
-            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 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: thinkingOption?.id ?? "reasoning_effort",
-                    value: sourceSession.reasoning_effort,
-                },
-            ];
-            for (const { configId, value } of inherited) {
-                if (!value)
-                    continue;
-                try {
-                    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(webSessionId);
-        return {
-            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);
-        if (!session)
-            throw new Error("Session not found");
-        if (this.liveSessions.has(sessionId)) {
-            // Session already live — build configOptions with stored overrides
-            const configOptions = this.buildConfigOptions(session);
-            return {
-                type: "session_created",
-                sessionId,
-                cwd: session.cwd,
-                cwdDisplay: abbreviateHomePath(session.cwd),
-                title: session.title,
-                configOptions,
-            };
-        }
-        // Restore via ACP
-        this.restoringSessions.add(sessionId);
-        try {
-            await bridge.loadSession(sessionId, session.cwd);
-            this.liveSessions.add(sessionId);
-            if (session.title)
-                this.sessionHasTitle.add(sessionId);
-            // Piggyback a cache-warming setConfigOption on the user's own resume
-            // when the global cache is empty (typical after bridge.restart). Uses
-            // the session's own stored value — idempotent, no side effect. Failure
-            // is swallowed: the resume still succeeds and the frontend falls back
-            // to snapshot-based mode/model display (see public/js/state.ts).
-            await this.tryWarmCache(bridge, sessionId, session);
-            const configOptions = this.applyStoredConfig(this.cachedConfigOptions, session);
-            slog.info("restored", { sessionId: sessionId.slice(0, 8) + "…" });
-            return {
-                type: "session_created",
-                sessionId,
-                cwd: session.cwd,
-                cwdDisplay: abbreviateHomePath(session.cwd),
-                title: session.title,
-                configOptions,
-            };
-        }
-        catch (err) {
-            slog.error("restore failed", { error: err });
-            throw err;
-        }
-        finally {
-            this.restoringSessions.delete(sessionId);
-        }
-    }
-    /**
-     * When cachedConfigOptions is empty, use the session's own stored config
-     * value to trigger a setConfigOption. The agent's response carries the
-     * full ConfigOption[] schema (options lists + in-memory currentValues),
-     * which we cache. Writes **only** the global cache, never the session's
-     * DB row — setConfigOption's currentValue for unrelated keys is the
-     * agent's in-memory default, not the user's preference.
-     *
-     * 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 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;
-        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;
-            }
-        }
-        if (lastError) {
-            slog.warn("cache warming failed", {
-                sessionId: sessionId.slice(0, 8) + "…",
-                error: lastError,
-            });
-        }
-    }
-    /**
-     * Ensure a session is resumed (live in ACP). Deduplicates concurrent calls.
-     * Unlike resumeSession(), this is fire-and-forget safe — callers that only
-     * need the session alive (but not the event payload) can await this.
-     */
-    async ensureResumed(bridge, sessionId) {
-        if (this.liveSessions.has(sessionId))
-            return;
-        const existing = this.pendingResumes.get(sessionId);
-        if (existing)
-            return existing;
-        const p = this.resumeSession(bridge, sessionId)
-            .then(() => { })
-            .finally(() => this.pendingResumes.delete(sessionId));
-        this.pendingResumes.set(sessionId, p);
-        return p;
-    }
-    /** Build configOptions from cache, overriding currentValue with stored session values. */
-    buildConfigOptions(session) {
-        return this.applyStoredConfig(this.cachedConfigOptions, session);
-    }
-    /** Override currentValue in configOptions with stored session values. */
-    applyStoredConfig(configOptions, session) {
-        if (!configOptions.length)
-            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 = opt.category === "thought_level"
-                ? session.reasoning_effort
-                : stored[opt.id];
-            if (override && "options" in opt)
-                return { ...opt, currentValue: override };
-            return opt;
-        });
-    }
-    /**
-     * Lazy-build and return the attachment label map for a session.
-     * Used by both egress chokepoints (SSE broadcast + replay helper)
-     * to translate uuid paths into `<name> [#<id4>]` labels.
-     *
-     * Cached; call `invalidateLabelCache(sid)` after any attachments
-     * INSERT/DELETE to force rebuild. Restart-safe: empty on cold
-     * start, rebuilt on first egress per session.
-     */
-    getLabelMap(sessionId) {
-        const hit = this.attachmentLabelCache.get(sessionId);
-        if (hit)
-            return hit;
-        const map = buildLabelMap(this.store.listAttachmentLabels(sessionId));
-        this.attachmentLabelCache.set(sessionId, map);
-        return map;
-    }
-    /** Invalidate label cache for a session (call after attachment write). */
-    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);
-        this.liveSessions.delete(sessionId);
-        this.sessionHasTitle.delete(sessionId);
-        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)
-                this.pendingPermissions.delete(reqId);
-        }
-        this.state.delete(sessionId);
-        if (mode === "hard") {
-            // Tombstoned sessions keep their attachments alive for the share viewer
-            // (shared files still resolve via /s/:token/attachments/...). The reap
-            // path in share/routes.ts removes them once the last share is gone.
-            rm(join(this.dataDir, "sessions", sessionId), {
-                recursive: true,
-                force: true,
-            }).catch(() => { });
-        }
-    }
-    /** Flush assistant/thinking buffers to store. */
-    flushBuffers(sessionId) {
-        this.flushAssistantBuffer(sessionId);
-        this.flushThinkingBuffer(sessionId);
-    }
-    /** Flush only the assistant message buffer to store. */
-    flushAssistantBuffer(sessionId) {
-        const assistant = this.assistantBuffers.get(sessionId);
-        this.assistantBuffers.delete(sessionId);
-        if (assistant && this.store.getSession(sessionId)) {
-            this.store.saveEvent(sessionId, "assistant_message", { text: assistant }, { from_ref: "agent" });
-        }
-    }
-    /** Flush only the thinking buffer to store. */
-    flushThinkingBuffer(sessionId) {
-        const thinking = this.thinkingBuffers.get(sessionId);
-        this.thinkingBuffers.delete(sessionId);
-        if (thinking && this.store.getSession(sessionId)) {
-            this.store.saveEvent(sessionId, "thinking", { text: thinking }, { from_ref: "agent" });
-        }
-    }
-    /** Append to assistant message buffer. */
-    appendAssistant(sessionId, text) {
-        const buf = (this.assistantBuffers.get(sessionId) ?? "") + text;
-        this.assistantBuffers.set(sessionId, buf);
-    }
-    /** Append to thinking buffer. */
-    appendThinking(sessionId, text) {
-        const buf = (this.thinkingBuffers.get(sessionId) ?? "") + text;
-        this.thinkingBuffers.set(sessionId, buf);
-    }
-    /** Get CWD for a session (falls back to default). */
-    getSessionCwd(sessionId) {
-        return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
-    }
-    getBusyKind(sessionId) {
-        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
-     * the frontend snapshot stays in sync via `state_patch` broadcast.
-     *
-     * `promptId` attaches to an agent busy transition (ignored otherwise). If
-     * omitted when staying agent-busy, the existing promptId is preserved.
-     */
-    syncBusy(sessionId, promptId) {
-        const kind = this.getBusyKind(sessionId);
-        const current = this.state.getState(sessionId).runtime.busy;
-        if (kind === null) {
-            if (current !== null)
-                this.state.patch(sessionId, { runtime: { busy: null } });
-            // Also clear any pending cancel safety net now that we are idle.
-            this.state.clearCancelSafety(sessionId);
-            return;
-        }
-        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: {
-                busy: {
-                    kind: kind,
-                    since: current?.kind === kind ? current.since : new Date().toISOString(),
-                    promptId: nextPromptId,
-                    cancelStatus: null,
-                },
-            },
-        });
-    }
-    /**
-     * If the session's last turn was interrupted (user_message without prompt_done),
-     * auto-retry by prompting the agent to continue. Returns true if retrying.
-     */
-    autoRetryIfNeeded(bridge, sessionId) {
-        if (this.activePrompts.has(sessionId))
-            return false;
-        if (!this.store.hasInterruptedTurn(sessionId))
-            return false;
-        slog.info("auto-retrying interrupted turn", {
-            sessionId: sessionId.slice(0, 8) + "…",
-        });
-        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.", 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);
-        });
-        return true;
-    }
-    /** Get pending permission requests for a session (or all sessions if no id). */
-    getPendingPermissions(sessionId) {
-        const perms = [...this.pendingPermissions.values()];
-        return sessionId ? perms.filter((p) => p.sessionId === sessionId) : perms;
-    }
-    /**
-     * Re-derive runtime.pendingPermissions from the Map and push via state_patch.
-     * Call this after every mutation of `pendingPermissions` so the frontend
-     * snapshot stays authoritative.
-     */
-    syncPendingPermissions(sessionId) {
-        const forSession = [...this.pendingPermissions.values()]
-            .filter((p) => p.sessionId === sessionId)
-            .map((p) => ({
-            requestId: p.requestId,
-            toolName: "",
-            title: p.title,
-            options: p.options.map((o) => ({
-                optionId: o.optionId,
-                label: o.label,
-            })),
-        }));
-        this.state.patch(sessionId, {
-            runtime: { pendingPermissions: forSession },
-        });
-    }
-    /** Kill all running bash processes (for shutdown). */
-    killAllBashProcs() {
-        const forceSignal = process.platform === "win32" ? undefined : "SIGKILL";
-        for (const [, proc] of this.runningBashProcs)
-            proc.kill(forceSignal);
-        this.runningBashProcs.clear();
-    }
-}