@lelouchhe/webagent 0.2.6 → 0.4.0

package/lib/session-state.js

@@ -0,0 +1,160 @@
+/**
+ * Per-session runtime state: single source of truth for "what state is this
+ * session in right now" (busy / streaming / pending permissions).
+ *
+ * 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.
+ */
+function defaultState() {
+    return {
+        seq: 0,
+        runtime: {
+            busy: null,
+            pendingPermissions: [],
+            streaming: { assistant: false, thinking: false },
+        },
+    };
+}
+function busyEqual(a, b) {
+    if (a === null && b === null)
+        return true;
+    if (a === null || b === null)
+        return false;
+    return a.kind === b.kind && a.since === b.since && a.promptId === b.promptId;
+}
+function permsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i], y = b[i];
+        if (x.requestId !== y.requestId ||
+            x.toolName !== y.toolName ||
+            x.title !== y.title)
+            return false;
+        if (x.options.length !== y.options.length)
+            return false;
+        for (let j = 0; j < x.options.length; j++) {
+            if (x.options[j].optionId !== y.options[j].optionId ||
+                x.options[j].label !== y.options[j].label)
+                return false;
+        }
+    }
+    return true;
+}
+/** True when the patch would change the current runtime state. */
+function hasRuntimeChanges(current, patch) {
+    if (!patch)
+        return false;
+    if ("busy" in patch && !busyEqual(current.busy, patch.busy ?? null))
+        return true;
+    if ("pendingPermissions" in patch &&
+        patch.pendingPermissions &&
+        !permsEqual(current.pendingPermissions, patch.pendingPermissions))
+        return true;
+    if ("streaming" in patch && patch.streaming) {
+        const s = patch.streaming;
+        if (s.assistant !== undefined &&
+            s.assistant !== current.streaming.assistant)
+            return true;
+        if (s.thinking !== undefined && s.thinking !== current.streaming.thinking)
+            return true;
+    }
+    return false;
+}
+export class SessionStateManager {
+    states = new Map();
+    listeners = new Set();
+    cancelTimers = new Map();
+    /** Get current state (creates default entry on first access). */
+    getState(sessionId) {
+        let s = this.states.get(sessionId);
+        if (!s) {
+            s = defaultState();
+            this.states.set(sessionId, s);
+        }
+        return s;
+    }
+    /**
+     * Merge a patch into the session's runtime state. Bumps seq and notifies
+     * listeners only when the patch actually changes something (no-op patches
+     * are dropped silently).
+     */
+    patch(sessionId, patch) {
+        const state = this.getState(sessionId);
+        const runtimeChanged = hasRuntimeChanges(state.runtime, patch.runtime);
+        if (!runtimeChanged)
+            return;
+        if (patch.runtime) {
+            if ("busy" in patch.runtime) {
+                state.runtime.busy = patch.runtime.busy ?? null;
+            }
+            if ("pendingPermissions" in patch.runtime &&
+                patch.runtime.pendingPermissions) {
+                state.runtime.pendingPermissions =
+                    patch.runtime.pendingPermissions.slice();
+            }
+            if ("streaming" in patch.runtime && patch.runtime.streaming) {
+                if (patch.runtime.streaming.assistant !== undefined) {
+                    state.runtime.streaming.assistant = patch.runtime.streaming.assistant;
+                }
+                if (patch.runtime.streaming.thinking !== undefined) {
+                    state.runtime.streaming.thinking = patch.runtime.streaming.thinking;
+                }
+            }
+        }
+        state.seq += 1;
+        const event = {
+            type: "state_patch",
+            sessionId,
+            seq: state.seq,
+            patch,
+        };
+        for (const l of this.listeners)
+            l(event);
+    }
+    /** Subscribe to patch events. Returns an unsubscribe function. */
+    onPatch(cb) {
+        this.listeners.add(cb);
+        return () => {
+            this.listeners.delete(cb);
+        };
+    }
+    /** Clear all state for a session (call from SessionManager.deleteSession). */
+    delete(sessionId) {
+        this.states.delete(sessionId);
+        const t = this.cancelTimers.get(sessionId);
+        if (t) {
+            clearTimeout(t);
+            this.cancelTimers.delete(sessionId);
+        }
+    }
+    /**
+     * Backend safety net for cancel: if busy is still set after `timeoutMs`,
+     * force-clear it. Replaces the old frontend cancel timer.
+     * A second arm on the same session replaces the existing timer.
+     */
+    armCancelSafety(sessionId, timeoutMs) {
+        if (timeoutMs <= 0)
+            return;
+        const existing = this.cancelTimers.get(sessionId);
+        if (existing)
+            clearTimeout(existing);
+        const t = setTimeout(() => {
+            this.cancelTimers.delete(sessionId);
+            this.patch(sessionId, { runtime: { busy: null } });
+        }, timeoutMs);
+        if (typeof t === "object" && "unref" in t)
+            t.unref();
+        this.cancelTimers.set(sessionId, t);
+    }
+    /** Cancel the safety net timer (e.g. when prompt_done arrives naturally). */
+    clearCancelSafety(sessionId) {
+        const t = this.cancelTimers.get(sessionId);
+        if (t) {
+            clearTimeout(t);
+            this.cancelTimers.delete(sessionId);
+        }
+    }
+}

package/lib/sessions-anchor.js

@@ -0,0 +1,28 @@
+import { mkdirSync, realpathSync } from "node:fs";
+import { join, sep } from "node:path";
+/**
+ * Resolved absolute path to `<dataDir>/sessions/`. Pinned at server boot so
+ * later `file://` URI construction and startsWith assertions all compare
+ * against the same realpath (defends against macOS `/var → /private/var`
+ * symlink + any future symlink swaps under `data_dir`).
+ *
+ * Throws if the directory cannot be created or resolved — fail fast at boot
+ * rather than later when an attachment dispatch tries to use it.
+ */
+export function resolveSessionsAnchor(dataDir) {
+    const dir = join(dataDir, "sessions");
+    mkdirSync(dir, { recursive: true });
+    const real = realpathSync(dir);
+    // Normalize trailing separator so `startsWith(anchor + sep)` is the
+    // canonical "is path a strict descendant" check everywhere.
+    return real.endsWith(sep) ? real.slice(0, -sep.length) : real;
+}
+/**
+ * Returns true iff `realpath` is a strict descendant of
+ * `<sessionsAnchor>/<sessionId>/attachments/`. Both args must already be
+ * realpath-resolved (no `..`, no symlinks left).
+ */
+export function isInsideSessionAttachments(sessionsAnchor, sessionId, realpath) {
+    const expected = sessionsAnchor + sep + sessionId + sep + "attachments" + sep;
+    return realpath.startsWith(expected);
+}

package/lib/share/cleanup.js

@@ -0,0 +1,45 @@
+import { log } from "../log.js";
+const slog = log.scope("share");
+const DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * Sweep one batch of stale previews (older than 24h, never activated,
+ * never revoked). Returns rows removed. `now` injectable for tests.
+ */
+export function sweepStaleSharePreviewsOnce(store, now = Date.now()) {
+    const removed = store.pruneStalePreviews(now);
+    if (removed > 0) {
+        slog.info("preview gc", { removed });
+    }
+    return removed;
+}
+/**
+ * Start the share-preview GC: sweep once synchronously on boot, then
+ * every 24h. Handle is unref'd so this interval alone doesn't keep the
+ * event loop alive — server.ts owns lifecycle.
+ *
+ * Only call when `config.share.enabled === true`; otherwise skip entirely.
+ */
+export function startSharePreviewCleanup(store) {
+    try {
+        sweepStaleSharePreviewsOnce(store);
+    }
+    catch (err) {
+        slog.error("preview gc initial sweep failed", { error: err });
+    }
+    const timer = setInterval(() => {
+        try {
+            sweepStaleSharePreviewsOnce(store);
+        }
+        catch (err) {
+            slog.error("preview gc sweep failed", { error: err });
+        }
+    }, DAY_MS);
+    if (typeof timer.unref === "function")
+        timer.unref();
+    return {
+        armed: true,
+        stop: () => {
+            clearInterval(timer);
+        },
+    };
+}