@lelouchhe/webagent 0.1.9 → 0.2.1

package/lib/server.js

@@ -1,72 +0,0 @@
-import { createServer } from "node:http";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-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 { 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);
-// --- 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);
-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 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, b, { cancelTimeout: config.limits.cancel_timeout }, sseManager, pushService);
-    });
-    await b.start();
-    bridge = b;
-    return b;
-}
-// --- Graceful shutdown ---
-async function shutdown() {
-    console.log("\n[server] shutting down...");
-    sseManager.stopHeartbeat();
-    sessions.killAllBashProcs();
-    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

@@ -1,276 +0,0 @@
-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.
- */
-export class SessionManager {
-    liveSessions = new Set();
-    restoringSessions = new Set();
-    sessionHasTitle = new Set();
-    assistantBuffers = new Map();
-    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;
-    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, source = "auto") {
-        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}`);
-        }
-        // 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, source);
-        // 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);
-        }
-    }
-    /**
-     * 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);
-    }
-    /** 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);
-        // 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(() => { });
-    }
-    /** 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;
-    }
-    /**
-     * 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";
-        for (const [, proc] of this.runningBashProcs)
-            proc.kill(forceSignal);
-        this.runningBashProcs.clear();
-    }
-}

package/lib/shared/constants.js

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

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

@@ -1,174 +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");
-        }
-        if (!colNames.has("source")) {
-            this.db.exec("ALTER TABLE sessions ADD COLUMN source TEXT NOT NULL DEFAULT 'auto'");
-        }
-    }
-    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(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) {
-        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);
-    }
-    /** 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);
-    }
-    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) {
-        const hasLimit = opts?.limit != null && opts.limit > 0;
-        const conditions = ["session_id = ?"];
-        const params = [sessionId];
-        if (opts?.afterSeq != null) {
-            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'";
-        }
-        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) {
-        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;
-        }
-    }
-}