@lelouchhe/webagent 0.1.9 → 0.1.10

package/lib/event-handler.js

@@ -1,104 +0,0 @@
-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;
-            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

@@ -1,168 +0,0 @@
-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 a specific endpoint has a visible client viewing the given session.
-     * A client with no session set does not suppress any session's push.
-     */
-    isEndpointVisibleForSession(endpoint, sessionId) {
-        for (const [clientId, ep] of this.clientEndpoints) {
-            if (ep === endpoint
-                && this.clientVisibility.get(clientId)
-                && 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).
-     * Per-subscription visibility filtering 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);
-        // Per-subscription visibility: skip endpoints where a visible client is viewing this session
-        const targets = subs.filter((sub) => !this.isEndpointVisibleForSession(sub.endpoint, notification.data.sessionId));
-        if (targets.length === 0)
-            return;
-        const results = await Promise.allSettled(targets.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 = targets[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);
-    }
-}