@lelouchhe/webagent 0.1.10 → 0.2.2

package/lib/event-handler.js

@@ -0,0 +1,106 @@
+export function handleAgentEvent(event, sessions, store, bridge, config, sseManager, pushService) {
+    if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
+        return;
+    switch (event.type) {
+        case "connected":
+            event.cancelTimeout = config.cancelTimeout;
+            if (event.agent)
+                sessions.agentInfo = event.agent;
+            break;
+        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;
+        case "message_chunk":
+            sessions.flushThinkingBuffer(event.sessionId);
+            sessions.appendAssistant(event.sessionId, event.text);
+            break;
+        case "thought_chunk":
+            sessions.flushAssistantBuffer(event.sessionId);
+            sessions.appendThinking(event.sessionId, event.text);
+            break;
+        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;
+        case "tool_call_update":
+            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content });
+            break;
+        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);
+                    const resolvedEvent = {
+                        type: "permission_resolved",
+                        sessionId: event.sessionId,
+                        requestId: event.requestId,
+                        optionName,
+                        denied: false,
+                    };
+                    sseManager.broadcast(resolvedEvent);
+                    return;
+                }
+            }
+            break;
+        }
+        case "prompt_done":
+            sessions.activePrompts.delete(event.sessionId);
+            sessions.flushBuffers(event.sessionId);
+            store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason });
+            break;
+        case "error":
+            if (event.sessionId) {
+                sessions.activePrompts.delete(event.sessionId);
+            }
+            break;
+    }
+    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);
+            });
+        }
+    }
+}

package/lib/push-service.js

@@ -0,0 +1,166 @@
+import webpush from "web-push";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const VAPID_FILE = "vapid.json";
+/** Remove a subscription after this many consecutive send failures. */
+const MAX_CONSECUTIVE_FAILURES = 5;
+export class PushService {
+    store;
+    vapidKeys;
+    clientVisibility = new Map(); // clientId → visible
+    clientEndpoints = new Map(); // clientId → push endpoint
+    clientSessions = new Map(); // clientId → currently viewed sessionId
+    /** endpoint → consecutive failure count (absent or 0 = healthy) */
+    failureCounts = new Map();
+    constructor(store, dataDir, vapidSubject) {
+        this.store = store;
+        this.vapidKeys = this.loadOrGenerateKeys(dataDir);
+        webpush.setVapidDetails(vapidSubject, this.vapidKeys.publicKey, this.vapidKeys.privateKey);
+    }
+    // ---------------------------------------------------------------------------
+    // VAPID keys
+    // ---------------------------------------------------------------------------
+    loadOrGenerateKeys(dataDir) {
+        const filePath = join(dataDir, VAPID_FILE);
+        if (existsSync(filePath)) {
+            chmodSync(filePath, 0o600);
+            const keys = JSON.parse(readFileSync(filePath, "utf8"));
+            console.log("[push] loaded VAPID keys");
+            return keys;
+        }
+        const keys = webpush.generateVAPIDKeys();
+        writeFileSync(filePath, JSON.stringify(keys, null, 2) + "\n", { mode: 0o600 });
+        console.log("[push] generated new VAPID keys");
+        return keys;
+    }
+    getPublicKey() {
+        return this.vapidKeys.publicKey;
+    }
+    // ---------------------------------------------------------------------------
+    // Notification formatting
+    // ---------------------------------------------------------------------------
+    formatNotification(sessionId, sessionTitle, eventType, eventData) {
+        const title = sessionTitle || "WebAgent";
+        let body;
+        switch (eventType) {
+            case "permission_request":
+                body = `⚿ ${eventData.description ?? "Permission requested"}`;
+                break;
+            case "prompt_done":
+                body = "✓ Task complete";
+                break;
+            case "bash_done": {
+                const cmd = eventData.command ?? "command";
+                const code = eventData.exitCode ?? "?";
+                body = `$ ${cmd} — exit ${code}`;
+                break;
+            }
+            default:
+                body = eventType;
+        }
+        return { title, body, data: { sessionId } };
+    }
+    // ---------------------------------------------------------------------------
+    // Client visibility tracking
+    // ---------------------------------------------------------------------------
+    setClientVisibility(clientId, visible) {
+        this.clientVisibility.set(clientId, visible);
+    }
+    setClientSession(clientId, sessionId) {
+        this.clientSessions.set(clientId, sessionId);
+    }
+    registerClient(clientId, endpoint) {
+        this.clientEndpoints.set(clientId, endpoint);
+    }
+    removeClient(clientId) {
+        this.clientVisibility.delete(clientId);
+        this.clientEndpoints.delete(clientId);
+        this.clientSessions.delete(clientId);
+    }
+    hasVisibleClient() {
+        for (const visible of this.clientVisibility.values()) {
+            if (visible)
+                return true;
+        }
+        return false;
+    }
+    /** Check if a specific endpoint has at least one visible client. */
+    isEndpointVisible(endpoint) {
+        for (const [clientId, ep] of this.clientEndpoints) {
+            if (ep === endpoint && this.clientVisibility.get(clientId))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Check if any client (across all endpoints) is visible and viewing the given session.
+     * A client with no session set does not suppress any session's push.
+     * Used for global suppression: if any client sees this session, all endpoints are skipped.
+     */
+    isSessionVisibleToAnyClient(sessionId) {
+        for (const [clientId, visible] of this.clientVisibility) {
+            if (visible && this.clientSessions.get(clientId) === sessionId)
+                return true;
+        }
+        return false;
+    }
+    // ---------------------------------------------------------------------------
+    // High-level: decide whether to push, and if so, send
+    // ---------------------------------------------------------------------------
+    static NOTIFIABLE = new Set(["permission_request", "prompt_done", "bash_done"]);
+    /**
+     * Check if this event should trigger a push notification.
+     * Returns true if a notification should be sent (caller should then call sendToAll).
+     * Global session visibility suppression happens inside sendToAll.
+     */
+    maybeNotify(sessionId, sessionTitle, eventType, eventData) {
+        if (!PushService.NOTIFIABLE.has(eventType))
+            return false;
+        return true;
+    }
+    // ---------------------------------------------------------------------------
+    // Send push to all subscriptions
+    // ---------------------------------------------------------------------------
+    async sendToAll(notification) {
+        const subs = this.store.getAllSubscriptions();
+        if (subs.length === 0)
+            return;
+        const payload = JSON.stringify(notification);
+        // Global visibility: if any client is viewing this session, suppress all push
+        if (this.isSessionVisibleToAnyClient(notification.data.sessionId))
+            return;
+        const results = await Promise.allSettled(subs.map((sub) => this.sendOne({ endpoint: sub.endpoint, keys: { auth: sub.auth, p256dh: sub.p256dh } }, payload)));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const endpoint = subs[i].endpoint;
+            if (result.status === "fulfilled") {
+                this.failureCounts.delete(endpoint);
+            }
+            else {
+                const err = result.reason;
+                if (err.statusCode === 410) {
+                    // Subscription expired — clean up immediately
+                    this.store.removeSubscription(endpoint);
+                    this.failureCounts.delete(endpoint);
+                    console.log(`[push] removed expired subscription (410): ${endpoint.slice(0, 60)}…`);
+                }
+                else {
+                    const count = (this.failureCounts.get(endpoint) ?? 0) + 1;
+                    if (count >= MAX_CONSECUTIVE_FAILURES) {
+                        this.store.removeSubscription(endpoint);
+                        this.failureCounts.delete(endpoint);
+                        console.log(`[push] removed subscription after ${count} consecutive failures: ${endpoint.slice(0, 60)}…`);
+                    }
+                    else {
+                        this.failureCounts.set(endpoint, count);
+                        console.error(`[push] send failed (${count}/${MAX_CONSECUTIVE_FAILURES}) for ${endpoint.slice(0, 60)}…:`, result.reason);
+                    }
+                }
+            }
+        }
+    }
+    /** Send a single push notification. Extracted for testability. */
+    sendOne(sub, payload) {
+        return webpush.sendNotification(sub, payload);
+    }
+}