@lelouchhe/webagent 0.1.0 → 0.1.2

package/lib/server.js

@@ -0,0 +1,144 @@
+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";
+const config = loadConfig();
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const PUBLIC_DIR = join(__dirname, "..", config.public_dir);
+// --- Core dependencies ---
+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);
+let bridge = null;
+// --- HTTP + WebSocket servers ---
+const server = createServer(createRequestHandler(store, PUBLIC_DIR, config.data_dir, config.limits));
+const wss = new WebSocketServer({ server });
+setupWsHandler({
+    wss,
+    store,
+    sessions,
+    titleService,
+    getBridge: () => bridge,
+    limits: config.limits,
+});
+// --- 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);
+    });
+    await b.start();
+    bridge = b;
+    return b;
+}
+// --- Graceful shutdown ---
+async function shutdown() {
+    console.log("\n[server] shutting down...");
+    sessions.killAllBashProcs();
+    wss.close();
+    await bridge?.shutdown();
+    store.close();
+    server.close();
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+// --- Start ---
+server.listen(config.port, "0.0.0.0", async () => {
+    console.log(`[server] listening on http://localhost:${config.port}`);
+    console.log(`[bridge] starting: ${config.agent_cmd}...`);
+    try {
+        await initBridge();
+        console.log(`[bridge] ready`);
+        sessions.hydrate();
+    }
+    catch (err) {
+        console.error(`[bridge] failed to start:`, err);
+    }
+});

package/lib/session-manager.js

@@ -0,0 +1,198 @@
+import { rm } from "node:fs/promises";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+/** Known config option IDs that we persist per-session. */
+const PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
+/**
+ * Centralizes all session-related state that was previously scattered
+ * across module-level variables in server.ts.
+ */
+export class SessionManager {
+    liveSessions = new Set();
+    restoringSessions = new Set();
+    sessionHasTitle = new Set();
+    assistantBuffers = new Map();
+    thinkingBuffers = new Map();
+    activePrompts = new Set();
+    runningBashProcs = new Map();
+    cachedConfigOptions = [];
+    store;
+    defaultCwd;
+    dataDir;
+    constructor(store, defaultCwd, dataDir) {
+        this.store = store;
+        this.defaultCwd = defaultCwd;
+        this.dataDir = dataDir;
+    }
+    /** Populate sessionHasTitle from existing DB sessions on startup. */
+    hydrate() {
+        for (const s of this.store.listSessions()) {
+            if (s.title)
+                this.sessionHasTitle.add(s.id);
+        }
+    }
+    /** Create a new session in both bridge and store, inheriting the source session's config. */
+    async createSession(bridge, cwd, inheritFromSessionId) {
+        const sessionCwd = cwd ?? this.defaultCwd;
+        try {
+            const info = await stat(sessionCwd);
+            if (!info.isDirectory())
+                throw new Error("not a directory");
+        }
+        catch {
+            throw new Error(`Directory does not exist: ${sessionCwd}`);
+        }
+        const sourceSession = inheritFromSessionId
+            ? this.store.getSession(inheritFromSessionId)
+            : null;
+        const sessionId = await bridge.newSession(sessionCwd);
+        this.liveSessions.add(sessionId);
+        this.store.createSession(sessionId, sessionCwd);
+        // Inherit config options from source session
+        if (sourceSession) {
+            const inherited = [
+                { configId: "model", value: sourceSession.model },
+                { configId: "reasoning_effort", value: sourceSession.reasoning_effort },
+            ];
+            for (const { configId, value } of inherited) {
+                if (!value)
+                    continue;
+                try {
+                    await bridge.setConfigOption(sessionId, configId, value);
+                    this.store.updateSessionConfig(sessionId, configId, value);
+                }
+                catch {
+                    // Option may no longer be available; ignore
+                }
+            }
+        }
+        const session = this.store.getSession(sessionId);
+        return {
+            sessionId,
+            configOptions: session ? this.buildConfigOptions(session) : [],
+        };
+    }
+    /** Resume a session — returns event to send to the requesting client. */
+    async resumeSession(bridge, sessionId) {
+        const session = this.store.getSession(sessionId);
+        if (!session)
+            throw new Error("Session not found");
+        if (this.liveSessions.has(sessionId)) {
+            // Session already live — build configOptions with stored overrides
+            const configOptions = this.buildConfigOptions(session);
+            return {
+                type: "session_created",
+                sessionId,
+                cwd: session.cwd,
+                title: session.title,
+                configOptions,
+                busyKind: this.getBusyKind(sessionId) ?? undefined,
+            };
+        }
+        // Restore via ACP
+        this.restoringSessions.add(sessionId);
+        try {
+            const restored = await bridge.loadSession(sessionId, session.cwd);
+            this.liveSessions.add(sessionId);
+            if (session.title)
+                this.sessionHasTitle.add(sessionId);
+            const configOptions = this.applyStoredConfig(restored.configOptions, session);
+            console.log(`[session] restored: ${sessionId.slice(0, 8)}…`);
+            return {
+                type: "session_created",
+                sessionId,
+                cwd: session.cwd,
+                title: session.title,
+                configOptions,
+                busyKind: this.getBusyKind(sessionId) ?? undefined,
+            };
+        }
+        catch (err) {
+            console.error(`[session] restore failed:`, err);
+            throw err;
+        }
+        finally {
+            this.restoringSessions.delete(sessionId);
+        }
+    }
+    /** Build configOptions from cache, overriding currentValue with stored session values. */
+    buildConfigOptions(session) {
+        return this.applyStoredConfig(this.cachedConfigOptions, session);
+    }
+    /** Override currentValue in configOptions with stored session values. */
+    applyStoredConfig(configOptions, session) {
+        if (!configOptions.length)
+            return this.cachedConfigOptions;
+        const stored = {
+            model: session.model,
+            mode: session.mode,
+            reasoning_effort: session.reasoning_effort,
+        };
+        return configOptions.map((opt) => {
+            const override = stored[opt.id];
+            if (override)
+                return { ...opt, currentValue: override };
+            return opt;
+        });
+    }
+    /** Delete a session from store and clean up all state (including images). */
+    deleteSession(sessionId) {
+        this.store.deleteSession(sessionId);
+        this.liveSessions.delete(sessionId);
+        this.sessionHasTitle.delete(sessionId);
+        this.assistantBuffers.delete(sessionId);
+        this.thinkingBuffers.delete(sessionId);
+        this.activePrompts.delete(sessionId);
+        this.runningBashProcs.delete(sessionId);
+        // Remove uploaded images for this session
+        rm(join(this.dataDir, "images", sessionId), { recursive: true, force: true }).catch(() => { });
+    }
+    /** Flush assistant/thinking buffers to store. */
+    flushBuffers(sessionId) {
+        this.flushAssistantBuffer(sessionId);
+        this.flushThinkingBuffer(sessionId);
+    }
+    /** Flush only the assistant message buffer to store. */
+    flushAssistantBuffer(sessionId) {
+        const assistant = this.assistantBuffers.get(sessionId);
+        if (assistant) {
+            this.store.saveEvent(sessionId, "assistant_message", { text: assistant });
+            this.assistantBuffers.delete(sessionId);
+        }
+    }
+    /** Flush only the thinking buffer to store. */
+    flushThinkingBuffer(sessionId) {
+        const thinking = this.thinkingBuffers.get(sessionId);
+        if (thinking) {
+            this.store.saveEvent(sessionId, "thinking", { text: thinking });
+            this.thinkingBuffers.delete(sessionId);
+        }
+    }
+    /** Append to assistant message buffer. */
+    appendAssistant(sessionId, text) {
+        const buf = (this.assistantBuffers.get(sessionId) ?? "") + text;
+        this.assistantBuffers.set(sessionId, buf);
+    }
+    /** Append to thinking buffer. */
+    appendThinking(sessionId, text) {
+        const buf = (this.thinkingBuffers.get(sessionId) ?? "") + text;
+        this.thinkingBuffers.set(sessionId, buf);
+    }
+    /** Get CWD for a session (falls back to default). */
+    getSessionCwd(sessionId) {
+        return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
+    }
+    getBusyKind(sessionId) {
+        if (this.runningBashProcs.has(sessionId))
+            return "bash";
+        if (this.activePrompts.has(sessionId))
+            return "agent";
+        return null;
+    }
+    /** Kill all running bash processes (for shutdown). */
+    killAllBashProcs() {
+        for (const [, proc] of this.runningBashProcs)
+            proc.kill("SIGKILL");
+        this.runningBashProcs.clear();
+    }
+}

package/lib/store.js

@@ -0,0 +1,101 @@
+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);
+    `);
+        // 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);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/lib/title-service.js

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

@@ -0,0 +1,47 @@
+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() }),
+]);
+// --- 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);
+    }
+}