@lelouchhe/webagent 0.1.0 → 0.1.2

package/src/routes.ts

@@ -1,147 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join, extname } from "node:path";
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { Store } from "./store.ts";
-import type { Config } from "./config.ts";
-
-const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
-
-const MIME: Record<string, string> = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-};
-
-export function createRequestHandler(store: Store, publicDir: string, dataDir: string, limits: Config["limits"]) {
-  return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
-    const url = req.url ?? "/";
-
-    // --- API routes ---
-    if (url.startsWith("/api/")) {
-      res.setHeader("Content-Type", "application/json");
-
-      // GET /api/sessions
-      if (url === "/api/sessions" && req.method === "GET") {
-        res.end(JSON.stringify(store.listSessions()));
-        return;
-      }
-
-      // GET /api/sessions/:id/events?thinking=0|1
-      const eventsMatch = url.match(/^\/api\/sessions\/([^/]+)\/events(\?.*)?$/);
-      if (eventsMatch && req.method === "GET") {
-        const sessionId = decodeURIComponent(eventsMatch[1]);
-        const params = new URLSearchParams(eventsMatch[2]?.slice(1) ?? "");
-        const excludeThinking = params.get("thinking") === "0";
-        const afterSeqRaw = params.get("after_seq");
-        const afterSeq = afterSeqRaw != null ? Number(afterSeqRaw) : undefined;
-        const session = store.getSession(sessionId);
-        if (!session) {
-          res.writeHead(404);
-          res.end(JSON.stringify({ error: "Session not found" }));
-          return;
-        }
-        const events = store.getEvents(sessionId, { excludeThinking, afterSeq });
-        res.end(JSON.stringify(events));
-        return;
-      }
-
-      // POST /api/images/:sessionId
-      const imgMatch = url.match(/^\/api\/images\/([^/]+)$/);
-      if (imgMatch && req.method === "POST") {
-        const sessionId = decodeURIComponent(imgMatch[1]);
-        if (!SAFE_ID.test(sessionId)) {
-          res.writeHead(400);
-          res.end(JSON.stringify({ error: "Invalid session ID" }));
-          return;
-        }
-        // Enforce upload size limit
-        const contentLength = parseInt(req.headers["content-length"] ?? "0", 10);
-        if (contentLength > limits.image_upload) {
-          res.writeHead(413);
-          res.end(JSON.stringify({ error: "Upload too large" }));
-          return;
-        }
-        const chunks: Buffer[] = [];
-        let totalSize = 0;
-        for await (const chunk of req) {
-          totalSize += (chunk as Buffer).length;
-          if (totalSize > limits.image_upload) {
-            res.writeHead(413);
-            res.end(JSON.stringify({ error: "Upload too large" }));
-            return;
-          }
-          chunks.push(chunk as Buffer);
-        }
-        let body: { data: string; mimeType: string };
-        try {
-          body = JSON.parse(Buffer.concat(chunks).toString());
-        } catch {
-          res.writeHead(400);
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-          return;
-        }
-        const { data, mimeType } = body;
-        const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") ?? "png";
-        const seq = Date.now();
-        const relPath = `images/${sessionId}/${seq}.${ext}`;
-        const absPath = join(dataDir, relPath);
-        await mkdir(join(dataDir, "images", sessionId), { recursive: true });
-        await writeFile(absPath, Buffer.from(data, "base64"));
-        const imgUrl = `/data/${relPath}`;
-        res.end(JSON.stringify({ path: relPath, url: imgUrl }));
-        return;
-      }
-
-      res.writeHead(404);
-      res.end(JSON.stringify({ error: "Not found" }));
-      return;
-    }
-
-    // --- Serve uploaded images: /data/images/... ---
-    if (url.startsWith("/data/images/")) {
-      const filePath = join(dataDir, url.slice(6)); // strip "/data/"
-      if (!filePath.startsWith(join(dataDir, "images"))) {
-        res.writeHead(403);
-        res.end("Forbidden");
-        return;
-      }
-      try {
-        const data = await readFile(filePath);
-        const ext = extname(filePath);
-        res.writeHead(200, {
-          "Content-Type": MIME[ext] ?? "application/octet-stream",
-          "Cache-Control": "public, max-age=31536000, immutable",
-        });
-        res.end(data);
-      } catch {
-        res.writeHead(404);
-        res.end("Not found");
-      }
-      return;
-    }
-
-    // --- Static files ---
-    const filePath = join(publicDir, url === "/" ? "/index.html" : url);
-    if (!filePath.startsWith(publicDir)) {
-      res.writeHead(403);
-      res.end("Forbidden");
-      return;
-    }
-    try {
-      const data = await readFile(filePath);
-      const ext = extname(filePath);
-      res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
-      res.end(data);
-    } catch {
-      res.writeHead(404);
-      res.end("Not found");
-    }
-  };
-}

package/src/server.ts

@@ -1,159 +0,0 @@
-import { createServer } from "node:http";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { WebSocketServer } from "ws";
-import { loadConfig } from "./config.ts";
-import { AgentBridge } from "./bridge.ts";
-import { Store } from "./store.ts";
-import { SessionManager } from "./session-manager.ts";
-import { TitleService } from "./title-service.ts";
-import { createRequestHandler } from "./routes.ts";
-import { setupWsHandler, broadcast } from "./ws-handler.ts";
-import type { AgentEvent } from "./types.ts";
-
-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: AgentBridge | null = 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(): Promise<AgentBridge> {
-  const b = new AgentBridge(config.agent_cmd);
-
-  b.on("event", (event: AgentEvent) => {
-    if (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: any) => 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,
-            } as any);
-            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/src/session-manager.ts

@@ -1,223 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-import { rm } from "node:fs/promises";
-import { stat } from "node:fs/promises";
-import { join } from "node:path";
-import type { Store } from "./store.ts";
-import type { AgentBridge } from "./bridge.ts";
-import type { AgentEvent, ConfigOption } from "./types.ts";
-
-type SessionBridge = Pick<AgentBridge, "newSession" | "setConfigOption" | "loadSession">;
-
-/** Known config option IDs that we persist per-session. */
-const PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"] as const;
-
-/**
- * Centralizes all session-related state that was previously scattered
- * across module-level variables in server.ts.
- */
-export class SessionManager {
-  readonly liveSessions = new Set<string>();
-  readonly restoringSessions = new Set<string>();
-  readonly sessionHasTitle = new Set<string>();
-  readonly assistantBuffers = new Map<string, string>();
-  readonly thinkingBuffers = new Map<string, string>();
-  readonly activePrompts = new Set<string>();
-  readonly runningBashProcs = new Map<string, ChildProcess>();
-
-  cachedConfigOptions: ConfigOption[] = [];
-
-  private store: Store;
-  private defaultCwd: string;
-  private dataDir: string;
-
-  constructor(store: Store, defaultCwd: string, dataDir: string) {
-    this.store = store;
-    this.defaultCwd = defaultCwd;
-    this.dataDir = dataDir;
-  }
-
-  /** Populate sessionHasTitle from existing DB sessions on startup. */
-  hydrate(): void {
-    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: SessionBridge,
-    cwd?: string,
-    inheritFromSessionId?: string,
-  ): Promise<{ sessionId: string; configOptions: ConfigOption[] }> {
-    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: Array<{ configId: string; value: string | null }> = [
-        { 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: SessionBridge,
-    sessionId: string,
-  ): Promise<AgentEvent> {
-    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. */
-  private buildConfigOptions(session: { model: string | null; mode: string | null; reasoning_effort: string | null }): ConfigOption[] {
-    return this.applyStoredConfig(this.cachedConfigOptions, session);
-  }
-
-  /** Override currentValue in configOptions with stored session values. */
-  private applyStoredConfig(
-    configOptions: ConfigOption[],
-    session: { model: string | null; mode: string | null; reasoning_effort: string | null },
-  ): ConfigOption[] {
-    if (!configOptions.length) return this.cachedConfigOptions;
-    const stored: Record<string, string | null> = {
-      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: string): void {
-    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: string): void {
-    this.flushAssistantBuffer(sessionId);
-    this.flushThinkingBuffer(sessionId);
-  }
-
-  /** Flush only the assistant message buffer to store. */
-  flushAssistantBuffer(sessionId: string): void {
-    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: string): void {
-    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: string, text: string): void {
-    const buf = (this.assistantBuffers.get(sessionId) ?? "") + text;
-    this.assistantBuffers.set(sessionId, buf);
-  }
-
-  /** Append to thinking buffer. */
-  appendThinking(sessionId: string, text: string): void {
-    const buf = (this.thinkingBuffers.get(sessionId) ?? "") + text;
-    this.thinkingBuffers.set(sessionId, buf);
-  }
-
-  /** Get CWD for a session (falls back to default). */
-  getSessionCwd(sessionId: string): string {
-    return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
-  }
-
-  getBusyKind(sessionId: string): "agent" | "bash" | null {
-    if (this.runningBashProcs.has(sessionId)) return "bash";
-    if (this.activePrompts.has(sessionId)) return "agent";
-    return null;
-  }
-
-  /** Kill all running bash processes (for shutdown). */
-  killAllBashProcs(): void {
-    for (const [, proc] of this.runningBashProcs) proc.kill("SIGKILL");
-    this.runningBashProcs.clear();
-  }
-}

package/src/store.ts

@@ -1,140 +0,0 @@
-import Database from "better-sqlite3";
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-
-export interface SessionRow {
-  id: string;
-  cwd: string;
-  title: string | null;
-  model: string | null;
-  mode: string | null;
-  reasoning_effort: string | null;
-  created_at: string;
-  last_active_at: string;
-}
-
-export interface EventRow {
-  id: number;
-  session_id: string;
-  seq: number;
-  type: string;
-  data: string; // JSON
-  created_at: string;
-}
-
-export class Store {
-  private db: Database.Database;
-
-  constructor(dataDir: string) {
-    mkdirSync(dataDir, { recursive: true });
-    this.db = new Database(join(dataDir, "webagent.db"));
-    this.db.pragma("journal_mode = WAL");
-    this.migrate();
-  }
-
-  private migrate(): void {
-    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() as Array<{ name: string }>;
-    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: string, cwd: string): SessionRow {
-    this.db.prepare("INSERT INTO sessions (id, cwd) VALUES (?, ?)").run(id, cwd);
-    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id) as SessionRow;
-  }
-
-  listSessions(): SessionRow[] {
-    return this.db.prepare("SELECT * FROM sessions ORDER BY COALESCE(last_active_at, created_at) DESC").all() as SessionRow[];
-  }
-
-  getSession(id: string): SessionRow | undefined {
-    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id) as SessionRow | undefined;
-  }
-
-  deleteSession(id: string): void {
-    this.db.prepare("DELETE FROM events WHERE session_id = ?").run(id);
-    this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-  }
-
-  updateSessionTitle(id: string, title: string): void {
-    this.db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
-  }
-
-  updateSessionLastActive(id: string): void {
-    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: string, configId: string, value: string): void {
-    const column = ({ model: "model", mode: "mode", reasoning_effort: "reasoning_effort" } as Record<string, string>)[configId];
-    if (!column) return;
-    this.db.prepare(`UPDATE sessions SET ${column} = ? WHERE id = ?`).run(value, id);
-  }
-
-  saveEvent(sessionId: string, type: string, data: Record<string, unknown> = {}): EventRow {
-    const seq = (this.db.prepare(
-      "SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM events WHERE session_id = ?"
-    ).get(sessionId) as { next: number }).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) as EventRow;
-  }
-
-  getEvents(sessionId: string, opts?: { excludeThinking?: boolean; afterSeq?: number }): EventRow[] {
-    let query = "SELECT * FROM events WHERE session_id = ?";
-    const params: unknown[] = [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) as EventRow[];
-  }
-
-  close(): void {
-    this.db.close();
-  }
-}