@lelouchhe/webagent 0.1.4 → 0.1.6

package/lib/routes.js

@@ -13,7 +13,7 @@ const MIME = {
     ".gif": "image/gif",
     ".webp": "image/webp",
 };
-export function createRequestHandler(store, publicDir, dataDir, limits) {
+export function createRequestHandler(store, publicDir, dataDir, limits, pushService) {
     return async (req, res) => {
         const url = req.url ?? "/";
         // --- API routes ---
@@ -89,6 +89,71 @@ export function createRequestHandler(store, publicDir, dataDir, limits) {
                 res.end(JSON.stringify({ path: relPath, url: imgUrl }));
                 return;
             }
+            // --- Push notification routes ---
+            // GET /api/push/vapid-key
+            if (url === "/api/push/vapid-key" && req.method === "GET") {
+                if (!pushService) {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: "Push not configured" }));
+                    return;
+                }
+                res.end(JSON.stringify({ publicKey: pushService.getPublicKey() }));
+                return;
+            }
+            // POST /api/push/subscribe
+            if (url === "/api/push/subscribe" && req.method === "POST") {
+                if (!pushService) {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: "Push not configured" }));
+                    return;
+                }
+                const chunks = [];
+                for await (const chunk of req)
+                    chunks.push(chunk);
+                let body;
+                try {
+                    body = JSON.parse(Buffer.concat(chunks).toString());
+                }
+                catch {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: "Invalid JSON" }));
+                    return;
+                }
+                if (!body.endpoint || !body.keys?.auth || !body.keys?.p256dh) {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: "Missing endpoint or keys (auth, p256dh)" }));
+                    return;
+                }
+                store.saveSubscription(body.endpoint, body.keys.auth, body.keys.p256dh);
+                res.writeHead(201);
+                res.end(JSON.stringify({ ok: true }));
+                return;
+            }
+            // POST /api/push/unsubscribe
+            if (url === "/api/push/unsubscribe" && req.method === "POST") {
+                if (!pushService) {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: "Push not configured" }));
+                    return;
+                }
+                const chunks = [];
+                for await (const chunk of req)
+                    chunks.push(chunk);
+                let body;
+                try {
+                    body = JSON.parse(Buffer.concat(chunks).toString());
+                }
+                catch {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({ error: "Invalid JSON" }));
+                    return;
+                }
+                if (body.endpoint) {
+                    store.removeSubscription(body.endpoint);
+                }
+                res.end(JSON.stringify({ ok: true }));
+                return;
+            }
             res.writeHead(404);
             res.end(JSON.stringify({ error: "Not found" }));
             return;

package/lib/server.js

@@ -9,6 +9,8 @@ import { SessionManager } from "./session-manager.js";
 import { TitleService } from "./title-service.js";
 import { createRequestHandler } from "./routes.js";
 import { setupWsHandler, broadcast } from "./ws-handler.js";
+import { handleAgentEvent } from "./event-handler.js";
+import { PushService } from "./push-service.js";
 const config = loadConfig();
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const PUBLIC_DIR = join(__dirname, "..", config.public_dir);
@@ -17,9 +19,11 @@ const store = new Store(config.data_dir);
 console.log(`[store] using ${config.data_dir}/`);
 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);
+console.log(`[push] VAPID public key ready`);
 let bridge = null;
 // --- HTTP + WebSocket servers ---
-const server = createServer(createRequestHandler(store, PUBLIC_DIR, config.data_dir, config.limits));
+const server = createServer(createRequestHandler(store, PUBLIC_DIR, config.data_dir, config.limits, pushService));
 const wss = new WebSocketServer({ server });
 setupWsHandler({
     wss,
@@ -28,90 +32,12 @@ setupWsHandler({
     titleService,
     getBridge: () => bridge,
     limits: config.limits,
+    pushService,
 });
-// --- Bridge initialization ---
 async function initBridge() {
     const b = new AgentBridge(config.agent_cmd);
     b.on("event", (event) => {
-        if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
-            return;
-        switch (event.type) {
-            case "connected":
-                event.cancelTimeout = config.limits.cancel_timeout;
-                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,
-                });
-                // 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) {
-                        b.resolvePermission(event.requestId, opt.optionId);
-                        const optionName = opt.label ?? opt.optionId;
-                        store.saveEvent(event.sessionId, "permission_response", {
-                            requestId: event.requestId, optionName, denied: false,
-                        });
-                        // Skip broadcasting the permission_request — send resolved directly
-                        broadcast(wss, {
-                            type: "permission_resolved",
-                            sessionId: event.sessionId,
-                            requestId: event.requestId,
-                            optionName,
-                            denied: false,
-                        });
-                        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;
-        }
-        broadcast(wss, event);
+        handleAgentEvent(event, sessions, store, wss, b, { cancelTimeout: config.limits.cancel_timeout }, pushService);
     });
     await b.start();
     bridge = b;

package/lib/store.js

@@ -27,6 +27,13 @@ export class Store {
         created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now'))
       );
       CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, seq);
+      CREATE TABLE IF NOT EXISTS push_subscriptions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        endpoint TEXT NOT NULL UNIQUE,
+        auth TEXT NOT NULL,
+        p256dh TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now'))
+      );
     `);
         // Migrate existing tables: add columns if missing
         const cols = this.db.prepare("PRAGMA table_info(sessions)").all();
@@ -95,6 +102,18 @@ export class Store {
         query += " ORDER BY seq";
         return this.db.prepare(query).all(...params);
     }
+    // --- Push subscriptions ---
+    saveSubscription(endpoint, auth, p256dh) {
+        this.db.prepare(`INSERT INTO push_subscriptions (endpoint, auth, p256dh)
+       VALUES (?, ?, ?)
+       ON CONFLICT(endpoint) DO UPDATE SET auth = excluded.auth, p256dh = excluded.p256dh`).run(endpoint, auth, p256dh);
+    }
+    removeSubscription(endpoint) {
+        this.db.prepare("DELETE FROM push_subscriptions WHERE endpoint = ?").run(endpoint);
+    }
+    getAllSubscriptions() {
+        return this.db.prepare("SELECT * FROM push_subscriptions").all();
+    }
     close() {
         this.db.close();
     }

package/lib/types.js

@@ -31,6 +31,7 @@ export const WsMessageSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("set_config_option"), sessionId: z.string(), configId: z.string(), value: z.string() }),
     z.object({ type: z.literal("bash_exec"), sessionId: z.string(), command: z.string() }),
     z.object({ type: z.literal("bash_cancel"), sessionId: z.string() }),
+    z.object({ type: z.literal("visibility"), visible: z.boolean() }),
 ]);
 // --- Utility ---
 export function errorMessage(err) {

package/lib/ws-handler.js

@@ -41,9 +41,13 @@ function send(ws, event) {
     }
 }
 export function setupWsHandler(deps) {
-    const { wss, store, sessions, titleService, getBridge, limits } = deps;
+    const { wss, store, sessions, titleService, getBridge, limits, pushService } = deps;
+    let nextClientId = 1;
     wss.on("connection", (ws) => {
+        const clientId = `ws-${nextClientId++}`;
         console.log(`[ws] client connected (total: ${wss.clients.size})`);
+        // Track client for push notification visibility — actual state sent by client
+        // (no default assumed; client sends visibility message in onopen)
         const pingInterval = setInterval(() => {
             if (ws.readyState === WebSocket.OPEN)
                 ws.ping();
@@ -235,6 +239,15 @@ export function setupWsHandler(deps) {
                             const stored = outputTruncated ? "[truncated]\n" + output : output;
                             store.saveEvent(msg.sessionId, "bash_result", { output: stored, code, signal });
                             broadcast(wss, { type: "bash_done", sessionId: msg.sessionId, code, signal });
+                            // Push notification for bash completion
+                            if (pushService) {
+                                const session = store.getSession(msg.sessionId);
+                                const eventData = { command: msg.command, exitCode: code };
+                                if (pushService.maybeNotify(msg.sessionId, session?.title ?? null, "bash_done", eventData)) {
+                                    const notification = pushService.formatNotification(msg.sessionId, session?.title ?? null, "bash_done", eventData);
+                                    pushService.sendToAll(notification).catch(err => console.error("[push] failed to send:", err));
+                                }
+                            }
                         });
                         child.on("error", (err) => {
                             sessions.runningBashProcs.delete(msg.sessionId);
@@ -248,6 +261,10 @@ export function setupWsHandler(deps) {
                         interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
                         break;
                     }
+                    case "visibility": {
+                        pushService?.setClientVisibility(clientId, msg.visible);
+                        break;
+                    }
                 }
             }
             catch (err) {
@@ -256,6 +273,7 @@ export function setupWsHandler(deps) {
         });
         ws.on("close", () => {
             clearInterval(pingInterval);
+            pushService?.removeClient(clientId);
             console.log(`[ws] client disconnected (total: ${wss.clients.size})`);
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lelouchhe/webagent",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A terminal-style web UI for ACP-compatible agents",
   "type": "module",
   "license": "MIT",
@@ -41,8 +41,10 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.14.1",
+    "@types/web-push": "^3.6.4",
     "better-sqlite3": "^12.6.2",
     "smol-toml": "^1.6.0",
+    "web-push": "^3.6.7",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },

package/dist/js/app.mmk25uhc.js

@@ -1,10 +0,0 @@
-// Boot entry point — imports all modules and starts the app
-
-import './render.mmk25uhc.js';    // theme, click-to-collapse listeners
-import './commands.mmk25uhc.js';  // slash menu listeners
-import './images.mmk25uhc.js';    // attach/paste listeners
-import './input.mmk25uhc.js';     // keyboard/send listeners
-import { connect } from './connection.mmk25uhc.js';
-
-connect();
-if ('serviceWorker' in navigator) navigator.serviceWorker.register('/sw.js');