@lelouchhe/webagent 0.2.6 → 0.4.0

package/lib/server.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadConfig } from "./config.js";
+import { setLogLevel, log } from "./log.js";
 import { AgentBridge } from "./bridge.js";
 import { Store } from "./store.js";
 import { SessionManager } from "./session-manager.js";
@@ -11,12 +12,40 @@ import { createRequestHandler } from "./routes.js";
 import { handleAgentEvent } from "./event-handler.js";
 import { PushService } from "./push-service.js";
 import { SseManager } from "./sse-manager.js";
+import { TicketStore } from "./sse-ticket.js";
+import { randomBytes } from "node:crypto";
+import { ClientRegistry } from "./client-registry.js";
+import { startMessageCleanup } from "./message-cleanup.js";
+import { startSharePreviewCleanup, } from "./share/cleanup.js";
+import { AuthStore } from "./auth-store.js";
+import { join as pathJoin } from "node:path";
+import { resolveSessionsAnchor } from "./sessions-anchor.js";
+import { runStartupChecks } from "./startup-checks.js";
+import { AttachmentDispatcher } from "./attachment-dispatch.js";
+import { createCounters as createAttachmentInterceptorCounters, } from "./attachment-interceptor.js";
+// Prefix all console output with ISO-ish timestamps (YYYY-MM-DD HH:MM:SS)
+for (const method of ["log", "error", "warn"]) {
+    const orig = console[method].bind(console);
+    console[method] = (...args) => {
+        const ts = new Date()
+            .toLocaleString("sv-SE", { hour12: false })
+            .replace(",", "");
+        orig(ts, ...args);
+    };
+}
 const config = loadConfig();
+setLogLevel(config.debug.level);
+// Unified startup gate: preflight (node, data_dir, agent, port) + auth
+// bootstrap (mint or refuse). Skipped via WEBAGENT_STARTUP_CHECKED=1
+// when a parent process (daemon supervisor) already ran the gate in
+// the operator's foreground TTY before forking.
+const preflight = await runStartupChecks(config);
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const PUBLIC_DIR = join(__dirname, "..", config.public_dir);
 const PKG_VERSION = (() => {
     try {
-        return JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version ?? "unknown";
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        return pkg.version ?? "unknown";
     }
     catch {
         return "unknown";
@@ -25,31 +54,100 @@ const PKG_VERSION = (() => {
 // --- Core dependencies ---
 const store = new Store(config.data_dir);
 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
+// same canonical path. Defends against macOS /var → /private/var.
+const sessionsAnchor = resolveSessionsAnchor(config.data_dir);
+const attachmentDispatcher = new AttachmentDispatcher(store, sessionsAnchor, {
+    warn: (msg) => {
+        console.warn(msg);
+    },
+});
+// Counters + once-per-process schemaDrift signal for the permission
+// auto-approve interceptor (uploads-plan v2.6 §1.4 F7). Dumped hourly.
+const attachmentInterceptorCounters = createAttachmentInterceptorCounters();
+let lastSchemaDriftAt = 0;
+const SCHEMA_DRIFT_THROTTLE_MS = 24 * 60 * 60 * 1000;
+const ATTACHMENT_INTERCEPTOR_DUMP_MS = 60 * 60 * 1000;
+setInterval(() => {
+    log
+        .scope("attachment-interceptor")
+        .info("counters", { ...attachmentInterceptorCounters });
+}, ATTACHMENT_INTERCEPTOR_DUMP_MS).unref();
 const sessions = new SessionManager(store, config.default_cwd, config.data_dir);
-const titleService = new TitleService(store, sessions, config.default_cwd);
-const pushService = new PushService(store, config.data_dir, config.push.vapid_subject);
+const titleService = new TitleService(store, sessions, config.default_cwd, config.title.model);
+const pushService = new PushService(store, config.data_dir, config.push.vapid_subject, {
+    globalVisibilitySuppression: config.push.global_visibility_suppression,
+});
 console.log(`[push] VAPID public key ready`);
 const sseManager = new SseManager();
-sseManager.onRemove((clientId) => pushService.removeClient(clientId));
+const clientRegistry = new ClientRegistry();
+sseManager.onRemove((clientId) => {
+    pushService.removeClient(clientId);
+    clientRegistry.remove(clientId);
+});
 sseManager.startHeartbeat();
+const authStore = new AuthStore(pathJoin(config.data_dir, "auth.json"));
+const ticketStore = new TicketStore();
+// In-memory image signing secret; regenerated on every restart so previously
+// leaked URLs become invalid the moment the server is bounced.
+const attachmentSecret = randomBytes(32);
+// SSE heartbeat re-checks token revocation; revoked → connection closed
+// within one heartbeat interval (≤15s).
+sseManager.setRevocationCheck((tokenName) => !authStore.hasTokenName(tokenName));
+sseManager.setAttachmentSecret(attachmentSecret);
+sseManager.setLabelMapProvider((sessionId) => sessions.getLabelMap(sessionId));
+// Broadcast runtime state patches to all SSE clients interested in the session.
+sessions.state.onPatch((event) => {
+    sseManager.broadcast(event);
+});
 let bridge = null;
+let messageCleanup = null;
+let sharePreviewCleanup = null;
 // --- HTTP server ---
-const server = createServer(createRequestHandler({
-    store,
-    sessions,
-    sseManager,
-    titleService,
-    getBridge: () => bridge,
-    publicDir: PUBLIC_DIR,
-    dataDir: config.data_dir,
-    limits: config.limits,
-    pushService,
-    serverVersion: PKG_VERSION,
-}));
-async function initBridge() {
-    const b = new AgentBridge(config.agent_cmd);
+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);
+});
+async function initBridge(agentCmd) {
+    const b = new AgentBridge(agentCmd);
+    b.setAttachmentDispatcher(attachmentDispatcher);
     b.on("event", (event) => {
-        handleAgentEvent(event, sessions, store, b, { cancelTimeout: config.limits.cancel_timeout }, sseManager, pushService);
+        handleAgentEvent(event, sessions, store, b, {
+            cancelTimeout: config.limits.cancel_timeout,
+            recentPathsLimit: config.limits.recent_paths,
+            attachmentInterceptor: {
+                counters: attachmentInterceptorCounters,
+                logger: log.scope("attachment-interceptor"),
+                onSchemaDrift: (ctx) => {
+                    const now = Date.now();
+                    if (now - lastSchemaDriftAt < SCHEMA_DRIFT_THROTTLE_MS)
+                        return;
+                    lastSchemaDriftAt = now;
+                    log
+                        .scope("attachment-interceptor")
+                        .error("schema drift detected — rawInput has no known path key", {
+                        ctx,
+                    });
+                },
+            },
+        }, sseManager, pushService, clientRegistry);
     });
     await b.start();
     bridge = b;
@@ -59,24 +157,53 @@ async function initBridge() {
 async function shutdown() {
     console.log("\n[server] shutting down...");
     sseManager.stopHeartbeat();
+    messageCleanup?.stop();
+    sharePreviewCleanup?.stop();
     sessions.killAllBashProcs();
     await bridge?.shutdown();
+    await authStore.close();
     store.close();
     server.close();
     process.exit(0);
 }
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+process.on("SIGINT", () => {
+    void shutdown();
+});
+process.on("SIGTERM", () => {
+    void shutdown();
+});
+// SIGHUP: reload auth.json without restarting (e.g. after CLI revoked a token)
+process.on("SIGHUP", () => {
+    authStore.reload().then(() => {
+        console.log("[auth] reloaded auth.json");
+    }, (err) => {
+        console.error("[auth] reload failed:", err);
+    });
+});
 // --- Start ---
-server.listen(config.port, "0.0.0.0", async () => {
-    console.log(`[server] listening on http://localhost:${config.port}`);
-    console.log(`[bridge] starting: ${config.agent_cmd}...`);
-    try {
-        await initBridge();
-        console.log(`[bridge] ready`);
-        sessions.hydrate();
-    }
-    catch (err) {
-        console.error(`[bridge] failed to start:`, err);
-    }
+server.listen(config.port, "0.0.0.0", () => {
+    void (async () => {
+        // The auth gate already ran in runStartupChecks (above) — either in
+        // this process or in a parent that handed off via WEBAGENT_STARTUP_
+        // CHECKED. Just open the AuthStore handle the rest of the server
+        // 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)`);
+        }
+        // agent_cmd resolved by preflight (handles the "auto" sentinel).
+        const agentCmd = preflight.agentCmd;
+        console.log(`[bridge] starting: ${agentCmd}...`);
+        try {
+            await initBridge(agentCmd);
+            console.log(`[bridge] ready`);
+            sessions.hydrate();
+        }
+        catch (err) {
+            console.error(`[bridge] failed to start:`, err);
+        }
+    })();
 });

package/lib/session-manager.js

@@ -2,6 +2,10 @@ import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
+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) {
     if (!proc)
@@ -23,7 +27,7 @@ export function interruptBashProc(proc) {
     proc.kill("SIGINT");
 }
 /** Known config option IDs that we persist per-session. */
-const PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
+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;
 /**
@@ -40,8 +44,17 @@ export class SessionManager {
     runningBashProcs = new Map();
     /** 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();
+    /**
+     * 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();
     cachedConfigOptions = [];
     agentInfo = null;
     store;
@@ -75,11 +88,11 @@ export class SessionManager {
         for (const id of cleaned)
             this.liveSessions.delete(id);
         if (cleaned.length > 0)
-            console.log(`[session] cleaned ${cleaned.length} empty session(s)`);
+            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 } = await bridge.newSession(sessionCwd);
         this.liveSessions.add(sessionId);
         this.store.createSession(sessionId, sessionCwd, source);
         // Inherit config options from source session
@@ -120,35 +133,77 @@ export class SessionManager {
                 cwd: session.cwd,
                 title: session.title,
                 configOptions,
-                busyKind: this.getBusyKind(sessionId) ?? undefined,
             };
         }
         // Restore via ACP
         this.restoringSessions.add(sessionId);
         try {
-            const restored = await bridge.loadSession(sessionId, session.cwd);
+            await bridge.loadSession(sessionId, session.cwd);
             this.liveSessions.add(sessionId);
             if (session.title)
                 this.sessionHasTitle.add(sessionId);
-            const configOptions = this.applyStoredConfig(restored.configOptions, session);
-            console.log(`[session] restored: ${sessionId.slice(0, 8)}…`);
+            // 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,
                 title: session.title,
                 configOptions,
-                busyKind: this.getBusyKind(sessionId) ?? undefined,
             };
         }
         catch (err) {
-            console.error(`[session] restore failed:`, 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 > reasoning_effort > model:
+     *   - mode is a small stable enum, rewriting current value is idempotent.
+     *   - 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)
+            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 });
+            }
+        }
+        catch (err) {
+            slog.warn("cache warming failed", {
+                sessionId: sessionId.slice(0, 8) + "…",
+                error: err,
+            });
+        }
+    }
     /**
      * Ensure a session is resumed (live in ACP). Deduplicates concurrent calls.
      * Unlike resumeSession(), this is fire-and-forget safe — callers that only
@@ -186,22 +241,52 @@ export class SessionManager {
             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);
+    }
     /** Delete a session from store and clean up all state (including images). */
     deleteSession(sessionId) {
-        this.store.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);
         this.runningBashProcs.delete(sessionId);
+        this.attachmentLabelCache.delete(sessionId);
         // Clean pending permissions for this session
         for (const [reqId, perm] of this.pendingPermissions) {
             if (perm.sessionId === sessionId)
                 this.pendingPermissions.delete(reqId);
         }
-        // Remove uploaded images for this session
-        rm(join(this.dataDir, "images", sessionId), { recursive: true, force: true }).catch(() => { });
+        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) {
@@ -212,7 +297,7 @@ export class SessionManager {
     flushAssistantBuffer(sessionId) {
         const assistant = this.assistantBuffers.get(sessionId);
         if (assistant) {
-            this.store.saveEvent(sessionId, "assistant_message", { text: assistant });
+            this.store.saveEvent(sessionId, "assistant_message", { text: assistant }, { from_ref: "agent" });
             this.assistantBuffers.delete(sessionId);
         }
     }
@@ -220,7 +305,7 @@ export class SessionManager {
     flushThinkingBuffer(sessionId) {
         const thinking = this.thinkingBuffers.get(sessionId);
         if (thinking) {
-            this.store.saveEvent(sessionId, "thinking", { text: thinking });
+            this.store.saveEvent(sessionId, "thinking", { text: thinking }, { from_ref: "agent" });
             this.thinkingBuffers.delete(sessionId);
         }
     }
@@ -245,6 +330,37 @@ export class SessionManager {
             return "agent";
         return null;
     }
+    /**
+     * 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?.promptId ?? null) : null;
+        if (current?.kind === kind && current.promptId === nextPromptId)
+            return;
+        this.state.patch(sessionId, {
+            runtime: {
+                busy: {
+                    kind: kind,
+                    since: current?.kind === kind ? current.since : new Date().toISOString(),
+                    promptId: nextPromptId,
+                },
+            },
+        });
+    }
     /**
      * 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.
@@ -254,18 +370,48 @@ export class SessionManager {
             return false;
         if (!this.store.hasInterruptedTurn(sessionId))
             return false;
-        console.log(`[session] auto-retrying interrupted turn for ${sessionId.slice(0, 8)}…`);
+        slog.info("auto-retrying interrupted turn", {
+            sessionId: sessionId.slice(0, 8) + "…",
+        });
         this.activePrompts.add(sessionId);
-        bridge.prompt(sessionId, "Continue your previous response — it was interrupted mid-way.").catch((err) => {
-            console.error(`[session] auto-retry failed for ${sessionId.slice(0, 8)}…:`, err);
+        this.syncBusy(sessionId);
+        bridge
+            .prompt(sessionId, "Continue your previous response — it was interrupted mid-way.")
+            .catch((err) => {
+            slog.error("auto-retry failed", {
+                sessionId: sessionId.slice(0, 8) + "…",
+                error: err,
+            });
             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;
+        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() {