@lelouchhe/webagent 0.1.0

package/src/session-manager.ts

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

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

package/src/title-service.ts

@@ -0,0 +1,81 @@
+import type { AgentBridge } from "./bridge.ts";
+import type { SessionManager } from "./session-manager.ts";
+import type { Store } from "./store.ts";
+
+const TITLE_MODEL = "claude-haiku-4.5";
+
+export class TitleService {
+  private titleSessionId: string | null = null;
+  private activeSourceSessions = new Set<string>();
+  private cancelledSourceSessions = new Set<string>();
+  private defaultCwd: string;
+
+  private store: Store;
+  private sessions: SessionManager;
+
+  constructor(store: Store, sessions: SessionManager, defaultCwd: string) {
+    this.store = store;
+    this.sessions = sessions;
+    this.defaultCwd = defaultCwd;
+  }
+
+  /** Generate a title for the session (non-blocking, fire-and-forget). */
+  generate(bridge: AgentBridge, userMessage: string, sessionId: string, onTitle?: (title: string) => void): void {
+    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);
+    });
+  }
+
+  private async _generate(
+    bridge: AgentBridge,
+    userMessage: string,
+    sessionId: string,
+  ): Promise<void> {
+    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: string, bridge: AgentBridge): Promise<void> {
+    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. */
+  private async ensureTitleSession(bridge: AgentBridge): Promise<string | null> {
+    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/src/types.ts

@@ -0,0 +1,81 @@
+import { z } from "zod/v4";
+import type * as acp from "@agentclientprotocol/sdk";
+
+// --- Config option (subset of ACP SessionConfigOption we care about) ---
+
+export interface ConfigOption {
+  type: "select";
+  id: string;
+  name: string;
+  category?: string | null;
+  currentValue: string;
+  options: Array<{ value: string; name: string }>;
+}
+
+// --- Agent events (server → client) ---
+
+export type AgentEvent =
+  | { type: "connected"; agent: { name: string; version: string }; configOptions: ConfigOption[]; cancelTimeout?: number }
+  | { type: "session_created"; sessionId: string; cwd?: string; title?: string | null; configOptions: ConfigOption[]; busyKind?: "agent" | "bash" }
+  | { type: "config_option_update"; sessionId: string; configOptions: ConfigOption[] }
+  | { type: "message_chunk"; sessionId: string; text: string }
+  | { type: "thought_chunk"; sessionId: string; text: string }
+  | { type: "tool_call"; sessionId: string; id: string; title: string; kind: string; rawInput?: unknown }
+  | { type: "tool_call_update"; sessionId: string; id: string; status: string; content?: unknown[] }
+  | { type: "plan"; sessionId: string; entries: unknown[] }
+  | { type: "permission_request"; requestId: string; sessionId: string; title: string; toolCallId?: string | null; options: acp.PermissionOption[] }
+  | { type: "prompt_done"; sessionId: string; stopReason: string }
+  | { type: "session_deleted"; sessionId: string }
+  | { type: "session_title_updated"; sessionId: string; title: string }
+  | { type: "session_expired"; sessionId: string }
+  | { type: "error"; message: string; sessionId?: string };
+
+// --- 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() }),
+]);
+
+export type WsMessage = z.infer<typeof WsMessageSchema>;
+
+// --- Utility ---
+
+export function errorMessage(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}