@lelouchhe/webagent 0.1.7 → 0.1.10

package/lib/store.js

@@ -1,120 +0,0 @@
-import Database from "better-sqlite3";
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-export class Store {
-    db;
-    constructor(dataDir) {
-        mkdirSync(dataDir, { recursive: true });
-        this.db = new Database(join(dataDir, "webagent.db"));
-        this.db.pragma("journal_mode = WAL");
-        this.migrate();
-    }
-    migrate() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        cwd TEXT NOT NULL,
-        title TEXT,
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
-        last_active_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now'))
-      );
-      CREATE TABLE IF NOT EXISTS events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT NOT NULL REFERENCES sessions(id),
-        seq INTEGER NOT NULL,
-        type TEXT NOT NULL,
-        data TEXT NOT NULL DEFAULT '{}',
-        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();
-        const colNames = new Set(cols.map(c => c.name));
-        if (!colNames.has("title")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN title TEXT");
-        }
-        if (!colNames.has("last_active_at")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN last_active_at TEXT");
-            // Backfill from created_at
-            this.db.exec("UPDATE sessions SET last_active_at = created_at WHERE last_active_at IS NULL");
-        }
-        if (!colNames.has("model")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN model TEXT");
-        }
-        if (!colNames.has("mode")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN mode TEXT");
-        }
-        if (!colNames.has("reasoning_effort")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN reasoning_effort TEXT");
-        }
-    }
-    createSession(id, cwd) {
-        this.db.prepare("INSERT INTO sessions (id, cwd) VALUES (?, ?)").run(id, cwd);
-        return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
-    }
-    listSessions() {
-        return this.db.prepare("SELECT * FROM sessions ORDER BY COALESCE(last_active_at, created_at) DESC").all();
-    }
-    getSession(id) {
-        return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
-    }
-    deleteSession(id) {
-        this.db.prepare("DELETE FROM events WHERE session_id = ?").run(id);
-        this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-    }
-    updateSessionTitle(id, title) {
-        this.db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
-    }
-    updateSessionLastActive(id) {
-        this.db.prepare("UPDATE sessions SET last_active_at = strftime('%Y-%m-%d %H:%M:%f', 'now') WHERE id = ?").run(id);
-    }
-    /** Update a config option value (model, mode, reasoning_effort) for a session. */
-    updateSessionConfig(id, configId, value) {
-        const column = { model: "model", mode: "mode", reasoning_effort: "reasoning_effort" }[configId];
-        if (!column)
-            return;
-        this.db.prepare(`UPDATE sessions SET ${column} = ? WHERE id = ?`).run(value, id);
-    }
-    saveEvent(sessionId, type, data = {}) {
-        const seq = this.db.prepare("SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM events WHERE session_id = ?").get(sessionId).next;
-        this.db.prepare("INSERT INTO events (session_id, seq, type, data) VALUES (?, ?, ?, ?)").run(sessionId, seq, type, JSON.stringify(data));
-        return this.db.prepare("SELECT * FROM events WHERE session_id = ? AND seq = ?")
-            .get(sessionId, seq);
-    }
-    getEvents(sessionId, opts) {
-        let query = "SELECT * FROM events WHERE session_id = ?";
-        const params = [sessionId];
-        if (opts?.afterSeq != null) {
-            query += " AND seq > ?";
-            params.push(opts.afterSeq);
-        }
-        if (opts?.excludeThinking) {
-            query += " AND type != 'thinking'";
-        }
-        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/title-service.js

@@ -1,71 +0,0 @@
-const TITLE_MODEL = "claude-haiku-4.5";
-export class TitleService {
-    titleSessionId = null;
-    activeSourceSessions = new Set();
-    cancelledSourceSessions = new Set();
-    defaultCwd;
-    store;
-    sessions;
-    constructor(store, sessions, defaultCwd) {
-        this.store = store;
-        this.sessions = sessions;
-        this.defaultCwd = defaultCwd;
-    }
-    /** Generate a title for the session (non-blocking, fire-and-forget). */
-    generate(bridge, userMessage, sessionId, onTitle) {
-        if (this.sessions.sessionHasTitle.has(sessionId) || this.activeSourceSessions.has(sessionId))
-            return;
-        this._generate(bridge, userMessage, sessionId).then((title) => {
-            if (title && onTitle)
-                onTitle(title);
-        }).catch((err) => {
-            console.error(`[title] generation failed:`, err);
-        });
-    }
-    async _generate(bridge, userMessage, sessionId) {
-        this.activeSourceSessions.add(sessionId);
-        const tsId = await this.ensureTitleSession(bridge);
-        if (!tsId) {
-            this.activeSourceSessions.delete(sessionId);
-            this.cancelledSourceSessions.delete(sessionId);
-            return;
-        }
-        try {
-            const prompt = `Generate a short title (max 30 chars, no quotes) for a chat that starts with this message. Reply with ONLY the title, nothing else:\n\n${userMessage.slice(0, 500)}`;
-            const title = await bridge.promptForText(tsId, prompt);
-            if (!title || this.cancelledSourceSessions.has(sessionId))
-                return;
-            const cleaned = title.replace(/^["']|["']$/g, "").trim().slice(0, 30);
-            if (!cleaned)
-                return;
-            this.store.updateSessionTitle(sessionId, cleaned);
-            this.sessions.sessionHasTitle.add(sessionId);
-            return cleaned;
-        }
-        finally {
-            this.activeSourceSessions.delete(sessionId);
-            this.cancelledSourceSessions.delete(sessionId);
-        }
-    }
-    async cancel(sessionId, bridge) {
-        this.cancelledSourceSessions.add(sessionId);
-        if (!this.titleSessionId || !this.activeSourceSessions.has(sessionId))
-            return;
-        await bridge.cancel(this.titleSessionId);
-    }
-    /** Ensure the dedicated title session exists. Returns session ID or null. */
-    async ensureTitleSession(bridge) {
-        if (this.titleSessionId)
-            return this.titleSessionId;
-        try {
-            const id = await bridge.newSession(this.defaultCwd, { silent: true });
-            this.sessions.liveSessions.add(id);
-            await bridge.setConfigOption(id, "model", TITLE_MODEL).catch(() => []);
-            this.titleSessionId = id;
-            return id;
-        }
-        catch {
-            return null;
-        }
-    }
-}

package/lib/types.js

@@ -1,48 +0,0 @@
-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)
-        return err.message;
-    if (typeof err === "string")
-        return err;
-    try {
-        return JSON.stringify(err);
-    }
-    catch {
-        return String(err);
-    }
-}

package/lib/ws-handler.js

@@ -1,280 +0,0 @@
-import { spawn } from "node:child_process";
-import { WebSocket, WebSocketServer } from "ws";
-import { WsMessageSchema, errorMessage } from "./types.js";
-const IS_WIN = process.platform === "win32";
-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");
-}
-export function broadcast(wss, event, exclude) {
-    const msg = JSON.stringify(event);
-    for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN && client !== exclude) {
-            try {
-                client.send(msg);
-            }
-            catch { /* client gone mid-send */ }
-        }
-    }
-}
-function send(ws, event) {
-    if (ws.readyState === WebSocket.OPEN) {
-        try {
-            ws.send(JSON.stringify(event));
-        }
-        catch { /* client gone mid-send */ }
-    }
-}
-export function setupWsHandler(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();
-        }, 30_000);
-        ws.on("message", async (raw) => {
-            // Parse & validate
-            let parsed;
-            try {
-                parsed = JSON.parse(raw.toString());
-            }
-            catch {
-                send(ws, { type: "error", message: "Invalid JSON" });
-                return;
-            }
-            const result = WsMessageSchema.safeParse(parsed);
-            if (!result.success) {
-                send(ws, { type: "error", message: `Invalid message: ${result.error.message}` });
-                return;
-            }
-            const msg = result.data;
-            try {
-                const bridge = getBridge();
-                switch (msg.type) {
-                    case "new_session": {
-                        if (!bridge) {
-                            send(ws, { type: "error", message: "Agent not ready yet" });
-                            return;
-                        }
-                        const created = await sessions.createSession(bridge, msg.cwd, msg.inheritFromSessionId);
-                        if (created.configOptions.length) {
-                            send(ws, {
-                                type: "config_option_update",
-                                sessionId: created.sessionId,
-                                configOptions: created.configOptions,
-                            });
-                        }
-                        break;
-                    }
-                    case "resume_session": {
-                        if (!bridge) {
-                            send(ws, { type: "error", message: "Agent not ready yet" });
-                            return;
-                        }
-                        try {
-                            const event = await sessions.resumeSession(bridge, msg.sessionId);
-                            send(ws, event);
-                        }
-                        catch {
-                            send(ws, { type: "session_expired", sessionId: msg.sessionId });
-                        }
-                        break;
-                    }
-                    case "delete_session": {
-                        sessions.deleteSession(msg.sessionId);
-                        broadcast(wss, { type: "session_deleted", sessionId: msg.sessionId });
-                        console.log(`[session] deleted: ${msg.sessionId.slice(0, 8)}…`);
-                        break;
-                    }
-                    case "prompt": {
-                        if (!bridge) {
-                            send(ws, { type: "error", message: "No active bridge" });
-                            return;
-                        }
-                        const images = msg.images;
-                        const userData = {
-                            text: msg.text,
-                            ...(images && { images: images.map((i) => ({ path: i.path, mimeType: i.mimeType })) }),
-                        };
-                        store.saveEvent(msg.sessionId, "user_message", userData);
-                        store.updateSessionLastActive(msg.sessionId);
-                        // Generate title once the session actually gets one; canceled/failed attempts can retry later.
-                        if (!sessions.sessionHasTitle.has(msg.sessionId)) {
-                            titleService.generate(bridge, msg.text, msg.sessionId, (title) => {
-                                broadcast(wss, { type: "session_title_updated", sessionId: msg.sessionId, title });
-                            });
-                        }
-                        // Broadcast to other clients
-                        const userEvent = JSON.stringify({ type: "user_message", sessionId: msg.sessionId, ...userData });
-                        for (const client of wss.clients) {
-                            if (client !== ws && client.readyState === WebSocket.OPEN) {
-                                client.send(userEvent);
-                            }
-                        }
-                        sessions.activePrompts.add(msg.sessionId);
-                        bridge.prompt(msg.sessionId, msg.text, images).catch((err) => {
-                            send(ws, { type: "error", message: errorMessage(err) });
-                        });
-                        break;
-                    }
-                    case "permission_response": {
-                        if (!bridge)
-                            return;
-                        if (msg.denied) {
-                            bridge.denyPermission(msg.requestId);
-                        }
-                        else if (msg.optionId) {
-                            bridge.resolvePermission(msg.requestId, msg.optionId);
-                        }
-                        if (msg.sessionId) {
-                            store.saveEvent(msg.sessionId, "permission_response", {
-                                requestId: msg.requestId,
-                                optionName: msg.optionName || "",
-                                denied: !!msg.denied,
-                            });
-                        }
-                        broadcast(wss, {
-                            type: "permission_resolved",
-                            sessionId: msg.sessionId,
-                            requestId: msg.requestId,
-                            optionName: msg.optionName || "",
-                            denied: !!msg.denied,
-                        });
-                        break;
-                    }
-                    case "cancel": {
-                        interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
-                        if (bridge) {
-                            await titleService.cancel(msg.sessionId, bridge);
-                        }
-                        await bridge?.cancel(msg.sessionId);
-                        break;
-                    }
-                    case "set_config_option": {
-                        if (!bridge) {
-                            send(ws, { type: "error", message: "Agent not ready yet" });
-                            return;
-                        }
-                        try {
-                            const configOptions = await bridge.setConfigOption(msg.sessionId, msg.configId, msg.value);
-                            for (const opt of configOptions) {
-                                store.updateSessionConfig(msg.sessionId, opt.id, opt.currentValue);
-                            }
-                            send(ws, { type: "config_set", configId: msg.configId, value: msg.value });
-                            if (configOptions.length) {
-                                broadcast(wss, { type: "config_option_update", sessionId: msg.sessionId, configOptions }, ws);
-                            }
-                        }
-                        catch (err) {
-                            send(ws, { type: "error", message: `Failed to set ${msg.configId}: ${errorMessage(err)}` });
-                        }
-                        break;
-                    }
-                    case "bash_exec": {
-                        if (sessions.runningBashProcs.has(msg.sessionId)) {
-                            send(ws, { type: "error", message: "A bash command is already running in this session" });
-                            return;
-                        }
-                        const cwd = sessions.getSessionCwd(msg.sessionId);
-                        store.saveEvent(msg.sessionId, "bash_command", { command: msg.command });
-                        // Broadcast to other clients
-                        const bashEvent = JSON.stringify({
-                            type: "bash_command", sessionId: msg.sessionId, command: msg.command,
-                        });
-                        for (const client of wss.clients) {
-                            if (client !== ws && client.readyState === WebSocket.OPEN) {
-                                client.send(bashEvent);
-                            }
-                        }
-                        const shell = IS_WIN ? (process.env.COMSPEC || "cmd.exe") : (process.env.SHELL || "bash");
-                        const shellArgs = IS_WIN ? ["/s", "/c", msg.command] : ["-c", msg.command];
-                        const child = spawn(shell, shellArgs, {
-                            cwd,
-                            detached: !IS_WIN,
-                            env: { ...process.env, TERM: "dumb" },
-                            stdio: ["ignore", "pipe", "pipe"],
-                        });
-                        sessions.runningBashProcs.set(msg.sessionId, child);
-                        let output = "";
-                        let outputTruncated = false;
-                        const onData = (stream) => (chunk) => {
-                            const text = chunk.toString();
-                            if (!outputTruncated) {
-                                output += text;
-                                if (output.length > limits.bash_output) {
-                                    output = output.slice(-limits.bash_output);
-                                    outputTruncated = true;
-                                }
-                            }
-                            else {
-                                // Keep only the tail within the limit
-                                output = (output + text).slice(-limits.bash_output);
-                            }
-                            broadcast(wss, { type: "bash_output", sessionId: msg.sessionId, text, stream });
-                        };
-                        child.stdout.on("data", onData("stdout"));
-                        child.stderr.on("data", onData("stderr"));
-                        child.on("close", (code, signal) => {
-                            sessions.runningBashProcs.delete(msg.sessionId);
-                            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);
-                            const errMsg = errorMessage(err);
-                            store.saveEvent(msg.sessionId, "bash_result", { output: errMsg, code: -1, signal: null });
-                            broadcast(wss, { type: "bash_done", sessionId: msg.sessionId, code: -1, signal: null, error: errMsg });
-                        });
-                        break;
-                    }
-                    case "bash_cancel": {
-                        interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
-                        break;
-                    }
-                    case "visibility": {
-                        pushService?.setClientVisibility(clientId, msg.visible);
-                        break;
-                    }
-                }
-            }
-            catch (err) {
-                send(ws, { type: "error", message: errorMessage(err) });
-            }
-        });
-        ws.on("close", () => {
-            clearInterval(pingInterval);
-            pushService?.removeClient(clientId);
-            console.log(`[ws] client disconnected (total: ${wss.clients.size})`);
-        });
-    });
-}