@lelouchhe/webagent 0.3.0 → 0.4.0

package/lib/event-handler.js

@@ -1,106 +1,224 @@
-export function handleAgentEvent(event, sessions, store, bridge, config, sseManager, pushService) {
-    if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
+import { shouldAutoApproveAttachmentRead, } from "./attachment-interceptor.js";
+import { log } from "./log.js";
+import { isAutopilotMode } from "./mode-bucket.js";
+const ailog = log.scope("attachment-interceptor");
+const plog = log.scope("push");
+function handleConnected(event, sessions, config) {
+    event.cancelTimeout = config.cancelTimeout;
+    event.recentPathsLimit = config.recentPathsLimit;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive check
+    if (event.agent)
+        sessions.agentInfo = event.agent;
+}
+function handleConfigLikeEvent(event, sessions, store) {
+    if (event.configOptions.length)
+        sessions.cachedConfigOptions = event.configOptions;
+    for (const opt of event.configOptions) {
+        store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
+    }
+}
+function handleMessageChunk(event, sessions) {
+    sessions.flushThinkingBuffer(event.sessionId);
+    sessions.appendAssistant(event.sessionId, event.text);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: true, thinking: false } },
+    });
+}
+function handleThoughtChunk(event, sessions) {
+    sessions.flushAssistantBuffer(event.sessionId);
+    sessions.appendThinking(event.sessionId, event.text);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: false, thinking: true } },
+    });
+}
+function handleToolCall(event, sessions, store) {
+    sessions.flushBuffers(event.sessionId);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: false, thinking: false } },
+    });
+    store.saveEvent(event.sessionId, event.type, {
+        id: event.id,
+        title: event.title,
+        kind: event.kind,
+        rawInput: event.rawInput,
+    }, { from_ref: "agent" });
+}
+function handlePlan(event, sessions, store) {
+    sessions.flushBuffers(event.sessionId);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: false, thinking: false } },
+    });
+    store.saveEvent(event.sessionId, event.type, { entries: event.entries }, { from_ref: "agent" });
+}
+function performAutoApprove(event, opt, sessions, store, bridge, sseManager, broadcastRequest) {
+    bridge.resolvePermission(event.requestId, opt.optionId);
+    sessions.pendingPermissions.delete(event.requestId);
+    sessions.syncPendingPermissions(event.sessionId);
+    const optionName = opt.label ?? opt.optionId;
+    store.saveEvent(event.sessionId, "permission_response", {
+        requestId: event.requestId,
+        optionName,
+        denied: false,
+    }, { from_ref: "system" });
+    if (broadcastRequest)
+        sseManager.broadcast(event);
+    sseManager.broadcast({
+        type: "permission_response",
+        sessionId: event.sessionId,
+        requestId: event.requestId,
+        optionName,
+        denied: false,
+    });
+}
+function maybeAutoApprovePermission(event, sessions, store, bridge, sseManager) {
+    const mode = store.getSession(event.sessionId)?.mode ?? "";
+    if (!isAutopilotMode(mode))
+        return false;
+    const opt = event.options.find((o) => o.kind === "allow_once");
+    if (!opt)
+        return false;
+    performAutoApprove(event, opt, sessions, store, bridge, sseManager, true);
+    return true;
+}
+function maybeAutoApproveAttachmentRead(event, sessions, store, bridge, sseManager, config) {
+    // Plan §1.4 — async attachment-read auto-approve runs *after* the
+    // permission_request has already been broadcast (so the UI shows it
+    // briefly), then if the request matches we follow up with a
+    // permission_response, identical to autopilot's collapse behavior.
+    const interceptor = config.attachmentInterceptor;
+    if (!interceptor)
         return;
+    const opt = event.options.find((o) => o.kind === "allow_once");
+    if (!opt)
+        return;
+    void shouldAutoApproveAttachmentRead({
+        sessionId: event.sessionId,
+        toolKind: event.toolKind,
+        toolName: event.toolName,
+        locations: event.locations,
+        rawInput: event.rawInput,
+    }, {
+        listAttachmentRealpaths: (sid) => store.listAttachmentRealpaths(sid),
+        counters: interceptor.counters,
+        logger: interceptor.logger,
+        onSchemaDrift: interceptor.onSchemaDrift,
+    }).then((approved) => {
+        if (!approved)
+            return;
+        // Race guard: the user (or another client) may have already
+        // resolved the permission while we were realpath-ing.
+        if (!sessions.pendingPermissions.has(event.requestId))
+            return;
+        performAutoApprove(event, opt, sessions, store, bridge, sseManager, false);
+    }, (err) => {
+        ailog.warn("unexpected error", { error: err.message });
+    });
+}
+function handlePermissionRequest(event, sessions, store, bridge, sseManager, config) {
+    sessions.flushBuffers(event.sessionId);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: false, thinking: false } },
+    });
+    store.saveEvent(event.sessionId, event.type, {
+        requestId: event.requestId,
+        title: event.title,
+        options: event.options,
+    }, { from_ref: "agent" });
+    sessions.pendingPermissions.set(event.requestId, {
+        requestId: event.requestId,
+        sessionId: event.sessionId,
+        title: event.title,
+        options: event.options.map((o) => ({
+            optionId: o.optionId,
+            label: o.label ?? o.name ?? o.optionId,
+        })),
+    });
+    sessions.syncPendingPermissions(event.sessionId);
+    const autopiloted = maybeAutoApprovePermission(event, sessions, store, bridge, sseManager);
+    if (autopiloted)
+        return true;
+    // Async attachment-read auto-approve runs after the request broadcasts.
+    maybeAutoApproveAttachmentRead(event, sessions, store, bridge, sseManager, config);
+    return false;
+}
+function handlePromptDone(event, sessions, store) {
+    sessions.activePrompts.delete(event.sessionId);
+    sessions.syncBusy(event.sessionId);
+    sessions.flushBuffers(event.sessionId);
+    sessions.state.patch(event.sessionId, {
+        runtime: { streaming: { assistant: false, thinking: false } },
+    });
+    store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason }, { from_ref: "agent" });
+}
+function handleError(event, sessions) {
+    if (event.sessionId) {
+        sessions.activePrompts.delete(event.sessionId);
+        sessions.syncBusy(event.sessionId);
+    }
+}
+function dispatchAgentEvent(event, sessions, store, bridge, config, sseManager) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- only handles events with side effects
     switch (event.type) {
         case "connected":
-            event.cancelTimeout = config.cancelTimeout;
-            event.recentPathsLimit = config.recentPathsLimit;
-            if (event.agent)
-                sessions.agentInfo = event.agent;
-            break;
+            handleConnected(event, sessions, config);
+            return false;
         case "session_created":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
         case "config_option_update":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
+            handleConfigLikeEvent(event, sessions, store);
+            return false;
         case "message_chunk":
-            sessions.flushThinkingBuffer(event.sessionId);
-            sessions.appendAssistant(event.sessionId, event.text);
-            break;
+            handleMessageChunk(event, sessions);
+            return false;
         case "thought_chunk":
-            sessions.flushAssistantBuffer(event.sessionId);
-            sessions.appendThinking(event.sessionId, event.text);
-            break;
+            handleThoughtChunk(event, sessions);
+            return false;
         case "tool_call":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { id: event.id, title: event.title, kind: event.kind, rawInput: event.rawInput });
-            break;
+            handleToolCall(event, sessions, store);
+            return false;
         case "tool_call_update":
-            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content });
-            break;
+            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content }, { from_ref: "agent" });
+            return false;
         case "plan":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { entries: event.entries });
-            break;
-        case "permission_request": {
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, {
-                requestId: event.requestId, title: event.title, options: event.options,
-            });
-            sessions.pendingPermissions.set(event.requestId, {
-                requestId: event.requestId,
-                sessionId: event.sessionId,
-                title: event.title,
-                options: event.options.map((o) => ({ optionId: o.optionId, label: o.label ?? o.name ?? o.optionId })),
-            });
-            // Auto-approve permissions in autopilot mode (allow_once only to avoid persisting across mode switches)
-            const mode = store.getSession(event.sessionId)?.mode ?? "";
-            if (mode.includes("#autopilot")) {
-                const opt = event.options.find((o) => o.kind === "allow_once");
-                if (opt) {
-                    bridge.resolvePermission(event.requestId, opt.optionId);
-                    sessions.pendingPermissions.delete(event.requestId);
-                    const optionName = opt.label ?? opt.optionId;
-                    store.saveEvent(event.sessionId, "permission_response", {
-                        requestId: event.requestId, optionName, denied: false,
-                    });
-                    // Broadcast both so the frontend can render then collapse the permission card
-                    sseManager.broadcast(event);
-                    sseManager.broadcast({
-                        type: "permission_response",
-                        sessionId: event.sessionId,
-                        requestId: event.requestId,
-                        optionName,
-                        denied: false,
-                    });
-                    return;
-                }
-            }
-            break;
-        }
+            handlePlan(event, sessions, store);
+            return false;
+        case "permission_request":
+            return handlePermissionRequest(event, sessions, store, bridge, sseManager, config);
         case "prompt_done":
-            sessions.activePrompts.delete(event.sessionId);
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason });
-            break;
+            handlePromptDone(event, sessions, store);
+            return false;
         case "error":
-            if (event.sessionId) {
-                sessions.activePrompts.delete(event.sessionId);
-            }
-            break;
+            handleError(event, sessions);
+            return false;
     }
-    sseManager.broadcast(event);
-    // Push notification check (after broadcast so clients get the event first)
-    if (pushService && "sessionId" in event && event.sessionId) {
-        const session = store.getSession(event.sessionId);
-        const eventData = {};
-        if (event.type === "permission_request") {
-            eventData.description = event.title;
-        }
-        if (pushService.maybeNotify(event.sessionId, session?.title ?? null, event.type, eventData)) {
-            const notification = pushService.formatNotification(event.sessionId, session?.title ?? null, event.type, eventData);
-            pushService.sendToAll(notification).catch((err) => {
-                console.error("[push] failed to send:", err);
-            });
-        }
+    return false;
+}
+function maybePushNotify(event, pushService) {
+    if (!("sessionId" in event) || !event.sessionId)
+        return;
+    const pushEvent = {
+        type: event.type,
+    };
+    if (event.type === "permission_request") {
+        pushEvent.title = event.title;
+        pushEvent.eventId = String(event.requestId);
     }
+    else if (event.type === "bash_done") {
+        // bash_done has `code` not `exitCode`; command not stored in the event
+        pushEvent.exitCode = event.code ?? undefined;
+    }
+    pushService.sendForEvent(event.sessionId, pushEvent).catch((err) => {
+        plog.error("failed to send", { error: err });
+    });
+}
+export function handleAgentEvent(event, sessions, store, bridge, config, sseManager, pushService, _clientRegistry) {
+    if ("sessionId" in event &&
+        event.sessionId &&
+        sessions.restoringSessions.has(event.sessionId))
+        return;
+    const suppress = dispatchAgentEvent(event, sessions, store, bridge, config, sseManager);
+    if (suppress)
+        return;
+    sseManager.broadcast(event);
+    if (pushService)
+        maybePushNotify(event, pushService);
 }

package/lib/log-fmt.js

@@ -0,0 +1,67 @@
+// Shared log formatting utilities used by both the frontend (`public/js/log.ts`)
+// and the backend (`src/log.ts`). Keeping a single source of truth here avoids
+// drift between the two emit paths (level rank, timestamp format, structured
+// field stringification).
+export const LEVEL_RANK = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    off: 99,
+};
+export const VALID_LEVELS = new Set([
+    "off",
+    "debug",
+    "info",
+    "warn",
+    "error",
+]);
+const FIELD_CAP_BYTES = 4096;
+export function safeStringify(value) {
+    try {
+        const seen = new WeakSet();
+        const str = JSON.stringify(value, (_key, v) => {
+            if (v instanceof Error) {
+                return { name: v.name, message: v.message, stack: v.stack };
+            }
+            if (typeof v === "function") {
+                const fn = v;
+                return `[Function ${fn.name ?? "anonymous"}]`;
+            }
+            if (typeof v === "bigint")
+                return v.toString() + "n";
+            if (typeof v === "symbol")
+                return v.toString();
+            if (typeof v === "object" && v !== null) {
+                if (seen.has(v))
+                    return "[Circular]";
+                seen.add(v);
+            }
+            return v;
+        });
+        if (typeof str !== "string")
+            return String(value);
+        if (str.length > FIELD_CAP_BYTES) {
+            return (str.slice(0, FIELD_CAP_BYTES) + `…(truncated, ${str.length} bytes)`);
+        }
+        return str;
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return "[unserializable]";
+        }
+    }
+}
+function pad2(n) {
+    return n < 10 ? "0" + n : String(n);
+}
+function pad3(n) {
+    return n < 10 ? "00" + n : n < 100 ? "0" + n : String(n);
+}
+export function formatTs(ts) {
+    const d = new Date(ts);
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${pad3(d.getMilliseconds())}`;
+}

package/lib/log.js

@@ -0,0 +1,83 @@
+// Backend logger — mirror of `public/js/log.ts`, single-knob level-gated.
+//
+// Single axis:
+//   level: off | debug | info | warn | error
+//
+// `off` short-circuits with a single boolean read (zero cost when disabled).
+// For any other level, records at or above the threshold are written to
+// stdout (debug/info) or stderr (warn/error), formatted as:
+//   HH:MM:SS.mmm LEVEL [scope] msg {fields-json}\n
+//
+// Format and `safeStringify` are shared with the frontend via `./log-fmt.ts`,
+// keeping the two emit paths in sync.
+//
+// Tests can hook the output via `setLogSink((stream, line) => ...)`. In
+// production this is unset and writes go straight to `process.stdout` /
+// `process.stderr`.
+import { LEVEL_RANK, VALID_LEVELS, safeStringify, formatTs, } from "./log-fmt.js";
+// ============================================================
+// Module state
+// ============================================================
+let currentLevel = "off";
+let sink = null;
+// ============================================================
+// Public API
+// ============================================================
+export function setLogLevel(level) {
+    if (!VALID_LEVELS.has(level))
+        return;
+    currentLevel = level;
+}
+export function getLogLevel() {
+    return currentLevel;
+}
+/** Install a custom sink (test hook). Pass `null` to restore stdout/stderr. */
+export function setLogSink(fn) {
+    sink = fn;
+}
+// ============================================================
+// Logger implementation
+// ============================================================
+function make(parentScope) {
+    const emit = (level, msg, fields) => {
+        // Zero-overhead gate: must be the first statement.
+        if (LEVEL_RANK[level] < LEVEL_RANK[currentLevel]) {
+            return;
+        }
+        const ts = formatTs(Date.now());
+        const scopePart = parentScope ? ` [${parentScope}]` : "";
+        const fieldsPart = fields !== undefined ? " " + safeStringify(fields) : "";
+        const line = `${ts}${scopePart} ${level.toUpperCase()} ${msg}${fieldsPart}\n`;
+        const stream = level === "warn" || level === "error" ? "err" : "out";
+        try {
+            if (sink) {
+                sink(stream, line);
+            }
+            else if (stream === "err") {
+                process.stderr.write(line);
+            }
+            else {
+                process.stdout.write(line);
+            }
+        }
+        catch {
+            // never let logger internals throw to caller
+        }
+    };
+    return {
+        debug: (m, f) => {
+            emit("debug", m, f);
+        },
+        info: (m, f) => {
+            emit("info", m, f);
+        },
+        warn: (m, f) => {
+            emit("warn", m, f);
+        },
+        error: (m, f) => {
+            emit("error", m, f);
+        },
+        scope: (n) => make(parentScope ? `${parentScope}.${n}` : n),
+    };
+}
+export const log = make();

package/lib/message-cleanup.js

@@ -0,0 +1,48 @@
+import { log } from "./log.js";
+const mlog = log.scope("msg");
+const DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * Sweep unprocessed messages whose created_at is older than ttlDays.
+ * Returns the number of rows removed. `now` is injectable for tests.
+ * ttlDays=0 means "keep forever" — returns 0 without touching the DB.
+ */
+export function sweepOnce(store, ttlDays, now = Date.now()) {
+    if (ttlDays <= 0)
+        return 0;
+    const threshold = now - ttlDays * DAY_MS;
+    const removed = store.deleteOlderThan(threshold);
+    if (removed > 0) {
+        mlog.info("ttl sweep", { removed, ttl_days: ttlDays });
+    }
+    return removed;
+}
+/**
+ * Start the unprocessed-message TTL cleanup job:
+ *  - sweep once immediately (synchronous),
+ *  - then every 24h via setInterval.
+ *
+ * ttlDays=0 disables the scheduler entirely (handle.armed=false).
+ */
+export function startMessageCleanup(store, ttlDays) {
+    sweepOnce(store, ttlDays);
+    if (ttlDays <= 0) {
+        return { armed: false, stop: () => { } };
+    }
+    const timer = setInterval(() => {
+        try {
+            sweepOnce(store, ttlDays);
+        }
+        catch (err) {
+            mlog.error("ttl sweep failed", { error: err });
+        }
+    }, DAY_MS);
+    // Don't keep the event loop alive for this interval alone (let server.ts own lifecycle).
+    if (typeof timer.unref === "function")
+        timer.unref();
+    return {
+        armed: true,
+        stop: () => {
+            clearInterval(timer);
+        },
+    };
+}

package/lib/mode-bucket.js

@@ -0,0 +1,62 @@
+// Cross-agent ACP mode classification.
+//
+// Different agents emit `currentModeId` in different forms:
+//   - Copilot CLI:   "https://agentclientprotocol.com/protocol/session-modes#autopilot"
+//   - Claude Code:   "bypassPermissions" (bare camelCase string)
+//   - Codex:         "read-only" / "auto" / "full-access" (bare hyphenated)
+//   - Gemini CLI:    "default" / "autoEdit" / "yolo" / "plan" (bare; enum-based)
+//   - OpenCode:      "build" / "plan" / "general" + user-defined agent names
+//
+// `extractModeId` normalizes URL forms into a short id. All bucket / display
+// logic flows through `extractModeId`, so adding a new mode means adding one
+// entry to one of the small constant sets below.
+//
+// Buckets webagent cares about:
+//   - plan       → read-only; visual hint only, no permission interception
+//   - autopilot  → all permission_requests auto-approved with `allow_once`
+//   - default    → forwarded as-is to the user (anything that's neither plan nor autopilot)
+//
+// The agent's own internal modes (Claude acceptEdits/dontAsk/auto, Gemini
+// autoEdit, OpenCode user-defined agents) all fall into the default bucket
+// from webagent's perspective: the agent decides internally whether to emit
+// a permission_request, and we just respond to what arrives.
+const PLAN_IDS = new Set(["plan", "read-only"]);
+const AUTOPILOT_IDS = new Set([
+    "autopilot",
+    "bypassPermissions",
+    "full-access",
+    "yolo",
+]);
+// IDs that should hide the pill entirely (the canonical "default" of each
+// agent — showing it adds noise because it's the resting state).
+//   - "agent"   → Copilot default
+//   - "default" → Claude default + Gemini default
+//   - "build"   → OpenCode default
+const HIDDEN_DEFAULT_IDS = new Set(["agent", "default", "build"]);
+export function extractModeId(raw) {
+    if (!raw)
+        return "";
+    const m = raw.match(/[#/]([^#/]+)$/);
+    return m ? m[1] : raw;
+}
+export function isPlanMode(raw) {
+    return PLAN_IDS.has(extractModeId(raw));
+}
+export function isAutopilotMode(raw) {
+    return AUTOPILOT_IDS.has(extractModeId(raw));
+}
+export function shouldShowModePill(raw) {
+    const id = extractModeId(raw);
+    if (!id)
+        return false;
+    return !HIDDEN_DEFAULT_IDS.has(id);
+}
+// camelCase → "camel Case" (CSS `text-transform: uppercase` finishes the job).
+// `bypassPermissions` → "bypass Permissions" → "BYPASS PERMISSIONS"
+// `acceptEdits` → "accept Edits" → "ACCEPT EDITS"
+// `plan` → "plan" → "PLAN"
+export function formatModeLabel(raw) {
+    return extractModeId(raw)
+        .replace(/([A-Z])/g, " $1")
+        .trim();
+}