@lelouchhe/webagent 0.1.6 → 0.1.9

package/lib/server.js

@@ -1,16 +1,15 @@
 import { createServer } from "node:http";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { WebSocketServer } from "ws";
 import { loadConfig } from "./config.js";
 import { AgentBridge } from "./bridge.js";
 import { Store } from "./store.js";
 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";
+import { SseManager } from "./sse-manager.js";
 const config = loadConfig();
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const PUBLIC_DIR = join(__dirname, "..", config.public_dir);
@@ -21,23 +20,26 @@ 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`);
+const sseManager = new SseManager();
+sseManager.onRemove((clientId) => pushService.removeClient(clientId));
+sseManager.startHeartbeat();
 let bridge = null;
-// --- HTTP + WebSocket servers ---
-const server = createServer(createRequestHandler(store, PUBLIC_DIR, config.data_dir, config.limits, pushService));
-const wss = new WebSocketServer({ server });
-setupWsHandler({
-    wss,
+// --- HTTP server ---
+const server = createServer(createRequestHandler({
     store,
     sessions,
+    sseManager,
     titleService,
     getBridge: () => bridge,
+    publicDir: PUBLIC_DIR,
+    dataDir: config.data_dir,
     limits: config.limits,
     pushService,
-});
+}));
 async function initBridge() {
     const b = new AgentBridge(config.agent_cmd);
     b.on("event", (event) => {
-        handleAgentEvent(event, sessions, store, wss, b, { cancelTimeout: config.limits.cancel_timeout }, pushService);
+        handleAgentEvent(event, sessions, store, b, { cancelTimeout: config.limits.cancel_timeout }, sseManager, pushService);
     });
     await b.start();
     bridge = b;
@@ -46,8 +48,8 @@ async function initBridge() {
 // --- Graceful shutdown ---
 async function shutdown() {
     console.log("\n[server] shutting down...");
+    sseManager.stopHeartbeat();
     sessions.killAllBashProcs();
-    wss.close();
     await bridge?.shutdown();
     store.close();
     server.close();

package/lib/session-manager.js

@@ -1,8 +1,31 @@
+import { spawn } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
+const IS_WIN = process.platform === "win32";
+export function interruptBashProc(proc) {
+    if (!proc)
+        return;
+    if (IS_WIN && typeof proc.pid === "number") {
+        // Windows: kill entire process tree since there are no process groups
+        spawn("taskkill", ["/T", "/F", "/PID", String(proc.pid)]).unref();
+        return;
+    }
+    if (typeof proc.pid === "number") {
+        try {
+            process.kill(-proc.pid, "SIGINT");
+            return;
+        }
+        catch {
+            // Fall through to direct child kill when the process is not a group leader.
+        }
+    }
+    proc.kill("SIGINT");
+}
 /** Known config option IDs that we persist per-session. */
 const PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
+/** Minimum age (seconds) before an empty session is eligible for cleanup. */
+const EMPTY_SESSION_MIN_AGE_S = 60;
 /**
  * Centralizes all session-related state that was previously scattered
  * across module-level variables in server.ts.
@@ -15,6 +38,10 @@ export class SessionManager {
     thinkingBuffers = new Map();
     activePrompts = new Set();
     runningBashProcs = new Map();
+    /** Pending permission requests keyed by requestId. */
+    pendingPermissions = new Map();
+    /** Deduplicates concurrent resume calls for the same session. */
+    pendingResumes = new Map();
     cachedConfigOptions = [];
     store;
     defaultCwd;
@@ -32,7 +59,7 @@ export class SessionManager {
         }
     }
     /** Create a new session in both bridge and store, inheriting the source session's config. */
-    async createSession(bridge, cwd, inheritFromSessionId) {
+    async createSession(bridge, cwd, inheritFromSessionId, source = "auto") {
         const sessionCwd = cwd ?? this.defaultCwd;
         try {
             const info = await stat(sessionCwd);
@@ -42,12 +69,18 @@ export class SessionManager {
         catch {
             throw new Error(`Directory does not exist: ${sessionCwd}`);
         }
+        // Clean up empty sessions (no events) older than the threshold
+        const cleaned = this.store.deleteEmptySessions(EMPTY_SESSION_MIN_AGE_S);
+        for (const id of cleaned)
+            this.liveSessions.delete(id);
+        if (cleaned.length > 0)
+            console.log(`[session] cleaned ${cleaned.length} empty session(s)`);
         const sourceSession = inheritFromSessionId
             ? this.store.getSession(inheritFromSessionId)
             : null;
         const sessionId = await bridge.newSession(sessionCwd);
         this.liveSessions.add(sessionId);
-        this.store.createSession(sessionId, sessionCwd);
+        this.store.createSession(sessionId, sessionCwd, source);
         // Inherit config options from source session
         if (sourceSession) {
             const inherited = [
@@ -115,6 +148,23 @@ export class SessionManager {
             this.restoringSessions.delete(sessionId);
         }
     }
+    /**
+     * Ensure a session is resumed (live in ACP). Deduplicates concurrent calls.
+     * Unlike resumeSession(), this is fire-and-forget safe — callers that only
+     * need the session alive (but not the event payload) can await this.
+     */
+    async ensureResumed(bridge, sessionId) {
+        if (this.liveSessions.has(sessionId))
+            return;
+        const existing = this.pendingResumes.get(sessionId);
+        if (existing)
+            return existing;
+        const p = this.resumeSession(bridge, sessionId)
+            .then(() => { })
+            .finally(() => this.pendingResumes.delete(sessionId));
+        this.pendingResumes.set(sessionId, p);
+        return p;
+    }
     /** Build configOptions from cache, overriding currentValue with stored session values. */
     buildConfigOptions(session) {
         return this.applyStoredConfig(this.cachedConfigOptions, session);
@@ -144,6 +194,11 @@ export class SessionManager {
         this.thinkingBuffers.delete(sessionId);
         this.activePrompts.delete(sessionId);
         this.runningBashProcs.delete(sessionId);
+        // Clean pending permissions for this session
+        for (const [reqId, perm] of this.pendingPermissions) {
+            if (perm.sessionId === sessionId)
+                this.pendingPermissions.delete(reqId);
+        }
         // Remove uploaded images for this session
         rm(join(this.dataDir, "images", sessionId), { recursive: true, force: true }).catch(() => { });
     }
@@ -189,6 +244,28 @@ export class SessionManager {
             return "agent";
         return null;
     }
+    /**
+     * If the session's last turn was interrupted (user_message without prompt_done),
+     * auto-retry by prompting the agent to continue. Returns true if retrying.
+     */
+    autoRetryIfNeeded(bridge, sessionId) {
+        if (this.activePrompts.has(sessionId))
+            return false;
+        if (!this.store.hasInterruptedTurn(sessionId))
+            return false;
+        console.log(`[session] auto-retrying interrupted turn for ${sessionId.slice(0, 8)}…`);
+        this.activePrompts.add(sessionId);
+        bridge.prompt(sessionId, "Continue your previous response — it was interrupted mid-way.").catch((err) => {
+            console.error(`[session] auto-retry failed for ${sessionId.slice(0, 8)}…:`, err);
+            this.activePrompts.delete(sessionId);
+        });
+        return true;
+    }
+    /** Get pending permission requests for a session (or all sessions if no id). */
+    getPendingPermissions(sessionId) {
+        const perms = [...this.pendingPermissions.values()];
+        return sessionId ? perms.filter(p => p.sessionId === sessionId) : perms;
+    }
     /** Kill all running bash processes (for shutdown). */
     killAllBashProcs() {
         const forceSignal = process.platform === "win32" ? undefined : "SIGKILL";

package/lib/shared/constants.js

@@ -0,0 +1,16 @@
+// Shared constants used by both frontend and backend.
+// --- Tool call kind → display icon ---
+export const TOOL_ICONS = {
+    read: "cat",
+    edit: "edit",
+    execute: "exec",
+    search: "find",
+    delete: "rm",
+};
+export const DEFAULT_TOOL_ICON = "run";
+// --- Plan entry status → display symbol ---
+export const PLAN_STATUS_ICONS = {
+    pending: "○",
+    in_progress: "◉",
+    completed: "●",
+};

package/lib/sse-manager.js

@@ -0,0 +1,80 @@
+import { randomBytes } from "node:crypto";
+/**
+ * Manages Server-Sent Event connections.
+ * Tracks connected clients, broadcasts events, handles cleanup.
+ */
+export class SseManager {
+    clients = new Map();
+    heartbeatTimer = null;
+    heartbeatInterval;
+    onRemoveCallback = null;
+    constructor(heartbeatMs = 20_000) {
+        this.heartbeatInterval = heartbeatMs;
+    }
+    /** Register a callback invoked when a client disconnects. */
+    onRemove(cb) {
+        this.onRemoveCallback = cb;
+    }
+    /** Start the periodic heartbeat. Call once after construction. */
+    startHeartbeat() {
+        if (this.heartbeatTimer)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            for (const client of this.clients.values()) {
+                if (!client.res.writableEnded)
+                    client.res.write(": heartbeat\n\n");
+            }
+        }, this.heartbeatInterval);
+        this.heartbeatTimer.unref();
+    }
+    /** Stop the heartbeat (e.g. on shutdown). */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /** Generate a unique client ID. */
+    generateClientId() {
+        return `cl-${randomBytes(6).toString("hex")}`;
+    }
+    /** Register a new SSE client connection. */
+    add(client) {
+        this.clients.set(client.id, client);
+        client.res.on("close", () => this.remove(client.id));
+    }
+    /** Remove a client by ID. */
+    remove(id) {
+        this.clients.delete(id);
+        this.onRemoveCallback?.(id);
+    }
+    /** Send an SSE event to a single client. */
+    sendEvent(client, event, seq) {
+        if (client.res.writableEnded)
+            return;
+        let msg = "";
+        if (seq != null)
+            msg += `id: ${seq}\n`;
+        msg += `data: ${JSON.stringify(event)}\n\n`;
+        client.res.write(msg);
+    }
+    /**
+     * Broadcast an event to all connected SSE clients.
+     * Global clients get all events. Per-session clients only get events for their session.
+     */
+    broadcast(event) {
+        const sessionId = event.sessionId;
+        for (const client of this.clients.values()) {
+            if (client.res.writableEnded)
+                continue;
+            // Global clients get everything; session clients only get matching events
+            if (client.sessionId && client.sessionId !== sessionId)
+                continue;
+            this.sendEvent(client, event);
+        }
+    }
+    /** Get count of connected clients. */
+    get size() {
+        return this.clients.size;
+    }
+}

package/lib/store.js

@@ -55,12 +55,18 @@ export class Store {
         if (!colNames.has("reasoning_effort")) {
             this.db.exec("ALTER TABLE sessions ADD COLUMN reasoning_effort TEXT");
         }
+        if (!colNames.has("source")) {
+            this.db.exec("ALTER TABLE sessions ADD COLUMN source TEXT NOT NULL DEFAULT 'auto'");
+        }
     }
-    createSession(id, cwd) {
-        this.db.prepare("INSERT INTO sessions (id, cwd) VALUES (?, ?)").run(id, cwd);
+    createSession(id, cwd, source = "auto") {
+        this.db.prepare("INSERT INTO sessions (id, cwd, source) VALUES (?, ?, ?)").run(id, cwd, source);
         return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
     }
-    listSessions() {
+    listSessions(opts) {
+        if (opts?.source) {
+            return this.db.prepare("SELECT * FROM sessions WHERE source = ? ORDER BY COALESCE(last_active_at, created_at) DESC").all(opts.source);
+        }
         return this.db.prepare("SELECT * FROM sessions ORDER BY COALESCE(last_active_at, created_at) DESC").all();
     }
     getSession(id) {
@@ -70,6 +76,21 @@ export class Store {
         this.db.prepare("DELETE FROM events WHERE session_id = ?").run(id);
         this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
     }
+    /** Delete sessions that have zero events and are older than minAgeS seconds. Returns IDs deleted. */
+    deleteEmptySessions(minAgeS) {
+        const empties = this.db.prepare(`
+      SELECT s.id FROM sessions s
+      LEFT JOIN events e ON e.session_id = s.id
+      WHERE e.id IS NULL
+        AND strftime('%s', 'now') - strftime('%s', s.created_at) >= ?
+    `).all(minAgeS);
+        if (empties.length === 0)
+            return [];
+        const del = this.db.prepare("DELETE FROM sessions WHERE id = ?");
+        for (const r of empties)
+            del.run(r.id);
+        return empties.map(r => r.id);
+    }
     updateSessionTitle(id, title) {
         this.db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
     }
@@ -90,17 +111,50 @@ export class Store {
             .get(sessionId, seq);
     }
     getEvents(sessionId, opts) {
-        let query = "SELECT * FROM events WHERE session_id = ?";
+        const hasLimit = opts?.limit != null && opts.limit > 0;
+        const conditions = ["session_id = ?"];
         const params = [sessionId];
         if (opts?.afterSeq != null) {
-            query += " AND seq > ?";
+            conditions.push("seq > ?");
             params.push(opts.afterSeq);
         }
+        if (opts?.beforeSeq != null) {
+            conditions.push("seq < ?");
+            params.push(opts.beforeSeq);
+        }
+        if (opts?.excludeThinking) {
+            conditions.push("type != 'thinking'");
+        }
+        const where = conditions.join(" AND ");
+        if (hasLimit) {
+            // Fetch the last N matching rows: subquery orders DESC with LIMIT,
+            // outer query re-orders ASC so the page is in chronological order.
+            const sql = `SELECT * FROM (SELECT * FROM events WHERE ${where} ORDER BY seq DESC LIMIT ?) ORDER BY seq`;
+            params.push(opts.limit);
+            return this.db.prepare(sql).all(...params);
+        }
+        return this.db.prepare(`SELECT * FROM events WHERE ${where} ORDER BY seq`).all(...params);
+    }
+    getEventCount(sessionId, opts) {
+        let query = "SELECT COUNT(*) as count FROM events WHERE session_id = ?";
+        const params = [sessionId];
         if (opts?.excludeThinking) {
             query += " AND type != 'thinking'";
         }
-        query += " ORDER BY seq";
-        return this.db.prepare(query).all(...params);
+        return this.db.prepare(query).get(...params).count;
+    }
+    /** Check if the most recent agent turn was interrupted (user_message without a following prompt_done). */
+    hasInterruptedTurn(sessionId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM events
+      WHERE session_id = ? AND type = 'user_message'
+        AND seq > COALESCE(
+          (SELECT MAX(seq) FROM events WHERE session_id = ? AND type = 'prompt_done'),
+          0
+        )
+      LIMIT 1
+    `).get(sessionId, sessionId);
+        return !!row;
     }
     // --- Push subscriptions ---
     saveSubscription(endpoint, auth, p256dh) {

package/lib/types.js

@@ -1,38 +1,3 @@
-import { z } from "zod/v4";
-// --- Inbound WS messages (client → server) ---
-const ImageSchema = z.object({
-    data: z.string(),
-    mimeType: z.string(),
-    path: z.string().optional(),
-});
-export const WsMessageSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("new_session"),
-        cwd: z.string().optional(),
-        inheritFromSessionId: z.string().optional(),
-    }),
-    z.object({ type: z.literal("resume_session"), sessionId: z.string() }),
-    z.object({ type: z.literal("delete_session"), sessionId: z.string() }),
-    z.object({
-        type: z.literal("prompt"),
-        sessionId: z.string(),
-        text: z.string(),
-        images: z.array(ImageSchema).optional(),
-    }),
-    z.object({
-        type: z.literal("permission_response"),
-        sessionId: z.string().optional(),
-        requestId: z.string(),
-        optionId: z.string().optional(),
-        optionName: z.string().optional(),
-        denied: z.boolean().optional(),
-    }),
-    z.object({ type: z.literal("cancel"), sessionId: z.string() }),
-    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) {
     if (err instanceof Error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lelouchhe/webagent",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "A terminal-style web UI for ACP-compatible agents",
   "type": "module",
   "license": "MIT",
@@ -15,7 +15,7 @@
     "web-ui",
     "copilot",
     "chat",
-    "websocket"
+    "sse"
   ],
   "engines": {
     "node": ">=22.6.0"
@@ -35,8 +35,8 @@
     "start": "node --experimental-strip-types src/server.ts --config config.toml",
     "test": "node --experimental-strip-types --test test/*.test.ts",
     "test:e2e": "playwright test",
-    "dev": "node --experimental-strip-types --watch src/server.ts --config config.dev.toml",
-    "dev:start": "node --experimental-strip-types src/server.ts --config config.dev.toml &",
+    "dev": "node scripts/build.js --watch & node --experimental-strip-types --watch src/server.ts --config config.dev.toml",
+    "dev:start": "node scripts/build.js --dev && node --experimental-strip-types src/server.ts --config config.dev.toml &",
     "dev:stop": "lsof -ti:6801 | xargs kill 2>/dev/null || true"
   },
   "dependencies": {
@@ -45,13 +45,12 @@
     "better-sqlite3": "^12.6.2",
     "smol-toml": "^1.6.0",
     "web-push": "^3.6.7",
-    "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.3.3",
-    "@types/ws": "^8.18.1",
+    "esbuild": "^0.27.3",
     "happy-dom": "^20.8.3",
     "playwright": "^1.58.2",
     "typescript": "^5.9.3"

package/dist/js/app.mmlj9sk2.js

@@ -1,34 +0,0 @@
-// Boot entry point — imports all modules and starts the app
-
-import './render.mmlj9sk2.js';    // theme, click-to-collapse listeners
-import './commands.mmlj9sk2.js';  // slash menu listeners
-import './images.mmlj9sk2.js';    // attach/paste listeners
-import './input.mmlj9sk2.js';     // keyboard/send listeners
-import { connect } from './connection.mmlj9sk2.js';
-import { state, setHashSessionId, resetSessionUI, updateSessionInfo } from './state.mmlj9sk2.js';
-import { loadHistory } from './events.mmlj9sk2.js';
-import { addSystem, scrollToBottom } from './render.mmlj9sk2.js';
-
-connect();
-
-if ('serviceWorker' in navigator) {
-  navigator.serviceWorker.register('/sw.js');
-
-  // Handle push notification click → navigate to session
-  navigator.serviceWorker.addEventListener('message', (e) => {
-    if (e.data?.type === 'navigate' && e.data.sessionId) {
-      const targetId = e.data.sessionId;
-      if (state.sessionId === targetId) return; // already there
-      resetSessionUI();
-      state.sessionId = targetId;
-      state.sessionTitle = null;
-      setHashSessionId(targetId);
-      updateSessionInfo(targetId, null);
-      addSystem('Switching…');
-      loadHistory(targetId).then(loaded => { if (loaded) scrollToBottom(true); });
-      if (state.ws && state.ws.readyState === 1) {
-        state.ws.send(JSON.stringify({ type: 'resume_session', sessionId: targetId }));
-      }
-    }
-  });
-}