@tstax/coding-tab 0.1.2 → 0.2.0

package/dist/server.js

@@ -162,7 +162,11 @@ function makeAuthRouter(opts) {
 
 // src/server/agentRoutes.ts
 import { Router as Router2 } from "express";
-import { Agent, CursorAgentError } from "@cursor/sdk";
+import {
+  Agent,
+  CursorAgentError
+} from "@cursor/sdk";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/server/models.ts
 import { Cursor } from "@cursor/sdk";
@@ -203,7 +207,6 @@ async function resolveModel(apiKey, choice) {
 }
 
 // src/server/sessions.ts
-import { randomUUID } from "crypto";
 var SESSION_IDLE_TTL_MS = 30 * 60 * 1e3;
 var sessions = /* @__PURE__ */ new Map();
 var sweeperStarted = false;
@@ -214,35 +217,41 @@ function startSweeper() {
     const now = Date.now();
     for (const [id, s] of sessions) {
       if (now - s.lastUsedAt > SESSION_IDLE_TTL_MS) {
-        disposeSession(id).catch((e) => console.error("[coding-tab] session sweep dispose failed", e));
+        disposeSessionsForChat(id).catch(
+          (e) => console.error("[coding-tab] session sweep dispose failed", e)
+        );
       }
     }
   }, 5 * 60 * 1e3).unref?.();
 }
-function registerSession(opts) {
+function registerLiveSession(opts) {
   startSweeper();
-  const id = randomUUID();
+  const prev = sessions.get(opts.chatId);
+  if (prev) {
+    sessions.delete(opts.chatId);
+    prev.agent[Symbol.asyncDispose]().catch(() => {
+    });
+  }
   const session = {
-    id,
+    chatId: opts.chatId,
     githubLogin: opts.githubLogin,
     agent: opts.agent,
-    repoUrl: opts.repoUrl,
-    startingRef: opts.startingRef,
+    agentId: opts.agentId,
     createdAt: Date.now(),
     lastUsedAt: Date.now()
   };
-  sessions.set(id, session);
+  sessions.set(opts.chatId, session);
   return session;
 }
-function getSession2(id) {
-  const s = sessions.get(id);
+function getLiveSession(chatId) {
+  const s = sessions.get(chatId);
   if (s) s.lastUsedAt = Date.now();
   return s;
 }
-async function disposeSession(id) {
-  const s = sessions.get(id);
+async function disposeSessionsForChat(chatId) {
+  const s = sessions.get(chatId);
   if (!s) return;
-  sessions.delete(id);
+  sessions.delete(chatId);
   try {
     await s.agent[Symbol.asyncDispose]();
   } catch (err) {
@@ -250,6 +259,235 @@ async function disposeSession(id) {
   }
 }
 
+// src/server/storage.ts
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { randomUUID } from "crypto";
+function safeId(s) {
+  return s.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+async function ensureDir(p) {
+  await mkdir(p, { recursive: true });
+}
+async function readJson(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeJsonAtomic(path, data) {
+  await ensureDir(dirname(path));
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  await writeFile(tmp, JSON.stringify(data, null, 2), "utf8");
+  await rename(tmp, path);
+}
+var MAX_BLOB_BYTES = 32 * 1024;
+function truncateBlob(value) {
+  if (value === void 0 || value === null) return value;
+  try {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    if (str.length <= MAX_BLOB_BYTES) return value;
+    const head = str.slice(0, MAX_BLOB_BYTES);
+    return `${head}
+
+\u2026[truncated ${str.length - MAX_BLOB_BYTES} chars]`;
+  } catch {
+    return "[unserializable]";
+  }
+}
+function sanitizeEvent(evt) {
+  if (evt.kind === "tool") {
+    return {
+      ...evt,
+      args: truncateBlob(evt.args),
+      result: truncateBlob(evt.result)
+    };
+  }
+  return evt;
+}
+var FileChatStorage = class {
+  dataDir;
+  /** Per-chat write mutex chain to keep concurrent appends consistent. */
+  chains = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dataDir = resolve(opts.dataDir);
+  }
+  chatPath(id) {
+    return join(this.dataDir, "chats", `${safeId(id)}.json`);
+  }
+  indexPath(login) {
+    return join(this.dataDir, "index", `${safeId(login.toLowerCase())}.json`);
+  }
+  /** Serialize all reads/writes for a single chat through a chained promise. */
+  withChat(id, fn) {
+    const prev = this.chains.get(id) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.chains.set(
+      id,
+      next.finally(() => {
+        if (this.chains.get(id) === next) this.chains.delete(id);
+      })
+    );
+    return next;
+  }
+  async readChat(id) {
+    return readJson(this.chatPath(id));
+  }
+  async writeChat(file) {
+    await writeJsonAtomic(this.chatPath(file.chat.id), file);
+  }
+  async readIndex(login) {
+    const list = await readJson(this.indexPath(login));
+    return list ?? [];
+  }
+  async writeIndex(login, items) {
+    items.sort((a, b) => b.updatedAt - a.updatedAt);
+    await writeJsonAtomic(this.indexPath(login), items);
+  }
+  /**
+   * Rebuild the index for a user by scanning every chat file. Used as a
+   * self-heal path when the index gets out of sync (e.g. crash mid-write).
+   */
+  async rebuildIndex(login) {
+    const dir = join(this.dataDir, "chats");
+    let entries = [];
+    try {
+      entries = await readdir(dir);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    const items = [];
+    const target = login.toLowerCase();
+    for (const name of entries) {
+      if (!name.endsWith(".json")) continue;
+      const file = await readJson(join(dir, name));
+      if (!file?.chat) continue;
+      if (file.chat.githubLogin.toLowerCase() !== target) continue;
+      items.push(this.toListItem(file.chat));
+    }
+    await this.writeIndex(login, items);
+    return items;
+  }
+  toListItem(c) {
+    return {
+      id: c.id,
+      title: c.title,
+      mode: c.mode,
+      model: c.model,
+      createdAt: c.createdAt,
+      updatedAt: c.updatedAt
+    };
+  }
+  async upsertIndex(chat) {
+    const items = await this.readIndex(chat.githubLogin);
+    const idx = items.findIndex((c) => c.id === chat.id);
+    const item = this.toListItem(chat);
+    if (idx >= 0) items[idx] = item;
+    else items.push(item);
+    await this.writeIndex(chat.githubLogin, items);
+  }
+  async removeFromIndex(login, chatId) {
+    const items = await this.readIndex(login);
+    const filtered = items.filter((c) => c.id !== chatId);
+    if (filtered.length !== items.length) {
+      await this.writeIndex(login, filtered);
+    }
+  }
+  async listChats(login) {
+    const items = await this.readIndex(login);
+    if (items.length > 0) return items;
+    return this.rebuildIndex(login);
+  }
+  async loadChat(id, login) {
+    return this.withChat(id, async () => {
+      const file = await this.readChat(id);
+      if (!file) return null;
+      if (file.chat.githubLogin.toLowerCase() !== login.toLowerCase()) {
+        return null;
+      }
+      const turns = [...file.turns].sort((a, b) => a.seq - b.seq);
+      return { ...file.chat, turns };
+    });
+  }
+  async createChat(chat) {
+    await this.withChat(chat.id, async () => {
+      await this.writeChat({ chat, turns: [] });
+    });
+    await this.upsertIndex(chat);
+  }
+  async patchChat(id, login, patch) {
+    const updated = await this.withChat(id, async () => {
+      const file = await this.readChat(id);
+      if (!file) return null;
+      if (file.chat.githubLogin.toLowerCase() !== login.toLowerCase()) {
+        return null;
+      }
+      const next = {
+        ...file.chat,
+        ...patch,
+        updatedAt: Date.now()
+      };
+      await this.writeChat({ chat: next, turns: file.turns });
+      return next;
+    });
+    if (updated) await this.upsertIndex(updated);
+    return updated;
+  }
+  async appendTurn(turn) {
+    const sanitized = {
+      ...turn,
+      events: turn.events.map(sanitizeEvent)
+    };
+    let chat = null;
+    await this.withChat(turn.chatId, async () => {
+      const file = await this.readChat(turn.chatId);
+      if (!file) throw new Error(`chat_not_found:${turn.chatId}`);
+      file.turns = file.turns.filter((t) => t.id !== sanitized.id);
+      file.turns.push(sanitized);
+      file.chat = { ...file.chat, updatedAt: Date.now() };
+      chat = file.chat;
+      await this.writeChat(file);
+    });
+    if (chat) await this.upsertIndex(chat);
+  }
+  async patchTurn(chatId, turnId, patch) {
+    let chat = null;
+    await this.withChat(chatId, async () => {
+      const file = await this.readChat(chatId);
+      if (!file) return;
+      const idx = file.turns.findIndex((t) => t.id === turnId);
+      if (idx < 0) return;
+      const current = file.turns[idx];
+      const events = patch.events ? patch.events.map(sanitizeEvent) : current.events;
+      file.turns[idx] = { ...current, ...patch, events };
+      file.chat = { ...file.chat, updatedAt: Date.now() };
+      chat = file.chat;
+      await this.writeChat(file);
+    });
+    if (chat) await this.upsertIndex(chat);
+  }
+  async deleteChat(id, login) {
+    const removed = await this.withChat(id, async () => {
+      const file = await this.readChat(id);
+      if (!file) return false;
+      if (file.chat.githubLogin.toLowerCase() !== login.toLowerCase()) {
+        return false;
+      }
+      await rm(this.chatPath(id), { force: true });
+      return true;
+    });
+    if (removed) await this.removeFromIndex(login, id);
+    return removed;
+  }
+};
+function createDefaultStorage(dataDir) {
+  const dir = dataDir ?? join(process.cwd(), ".coding-tab-data");
+  return new FileChatStorage({ dataDir: dir });
+}
+
 // src/server/agentRoutes.ts
 var PLAN_INSTRUCTION = `You are operating in PLAN MODE.
 
@@ -291,39 +529,221 @@ function setupSseHeaders(res) {
   });
   res.flushHeaders?.();
 }
-async function streamRun(res, run) {
+function deriveTitle(prompt) {
+  const trimmed = prompt.trim().replace(/\s+/g, " ");
+  if (trimmed.length <= 60) return trimmed || "New chat";
+  return `${trimmed.slice(0, 57)}\u2026`;
+}
+var TurnBuffer = class {
+  events = [];
+  lastWasText = false;
+  pushText(text) {
+    if (this.lastWasText) {
+      const last = this.events[this.events.length - 1];
+      if (last.kind === "text") {
+        last.text += text;
+        return last;
+      }
+    }
+    const evt = { kind: "text", id: randomUUID2(), text };
+    this.events.push(evt);
+    this.lastWasText = true;
+    return evt;
+  }
+  /**
+   * Mark the next text event as starting a new block (called when the SDK
+   * emits a non-streaming-delta boundary, e.g. a tool call or a new assistant
+   * message). The next `pushText` will start a fresh paragraph.
+   */
+  endTextBlock() {
+    this.lastWasText = false;
+  }
+  upsertTool(args) {
+    this.endTextBlock();
+    const existing = this.events.find(
+      (e) => e.kind === "tool" && e.callId === args.callId
+    );
+    if (existing) {
+      existing.status = args.status;
+      if (args.args !== void 0) existing.args = args.args;
+      if (args.result !== void 0) existing.result = args.result;
+      return existing;
+    }
+    const evt = {
+      kind: "tool",
+      id: randomUUID2(),
+      callId: args.callId,
+      name: args.name,
+      status: args.status,
+      args: args.args,
+      result: args.result
+    };
+    this.events.push(evt);
+    return evt;
+  }
+  snapshot() {
+    return this.events.map(sanitizeEvent);
+  }
+};
+async function streamRun(res, run, ctx) {
+  const flushDebounceMs = 750;
+  let flushPending = false;
+  let lastFlush = 0;
+  const persist = async (status, pr) => {
+    try {
+      await ctx.storage.patchTurn(ctx.chat.id, ctx.turn.id, {
+        events: ctx.buffer.snapshot(),
+        ...status ? { status } : {},
+        ...pr ? { pr } : {}
+      });
+      lastFlush = Date.now();
+    } catch (err) {
+      console.error("[coding-tab] patchTurn failed", err);
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushPending) return;
+    flushPending = true;
+    setTimeout(async () => {
+      flushPending = false;
+      const elapsed = Date.now() - lastFlush;
+      if (elapsed < flushDebounceMs) return;
+      await persist();
+    }, flushDebounceMs).unref?.();
+  };
+  let finalStatus = "finished";
+  let finalPr;
   try {
     for await (const message of run.stream()) {
       if (res.writableEnded) break;
       if (message.type === "assistant") {
+        ctx.buffer.endTextBlock();
         for (const block of message.message.content) {
-          if (block.type === "text" && block.text) sse(res, { kind: "text", text: block.text });
-          else if (block.type === "tool_use") sse(res, { kind: "tool", name: block.name, status: "running", callId: block.id, args: block.input });
+          if (block.type === "text" && block.text) {
+            ctx.buffer.pushText(block.text);
+            ctx.buffer.endTextBlock();
+            sse(res, { kind: "text", text: block.text });
+          } else if (block.type === "tool_use") {
+            ctx.buffer.upsertTool({
+              callId: block.id,
+              name: block.name,
+              status: "running",
+              args: block.input
+            });
+            sse(res, {
+              kind: "tool",
+              name: block.name,
+              status: "running",
+              callId: block.id,
+              args: block.input
+            });
+          }
         }
       } else if (message.type === "thinking") {
         sse(res, { kind: "thinking", text: message.text });
       } else if (message.type === "tool_call") {
-        sse(res, { kind: "tool", name: message.name, status: message.status, callId: message.call_id, args: message.args, result: message.result });
+        ctx.buffer.upsertTool({
+          callId: message.call_id,
+          name: message.name,
+          status: message.status,
+          args: message.args,
+          result: message.result
+        });
+        sse(res, {
+          kind: "tool",
+          name: message.name,
+          status: message.status,
+          callId: message.call_id,
+          args: message.args,
+          result: message.result
+        });
       } else if (message.type === "status") {
         sse(res, { kind: "status", status: message.status, message: message.message });
       }
+      scheduleFlush();
     }
     const result = await run.wait();
     const prUrl = result.git?.branches?.find((b) => b.prUrl)?.prUrl;
+    finalPr = parsePrUrl(prUrl);
+    finalStatus = result.status ?? "finished";
     sse(res, {
       kind: "result",
       status: result.status,
-      pr: parsePrUrl(prUrl),
+      pr: finalPr,
       durationMs: result.durationMs
     });
   } catch (err) {
+    finalStatus = "error";
     const message = err instanceof Error ? err.message : String(err);
     const retryable = err instanceof CursorAgentError ? Boolean(err.isRetryable) : false;
     sse(res, { kind: "error", message, retryable });
   } finally {
+    await persist(finalStatus, finalPr);
     if (!res.writableEnded) res.end();
   }
 }
+async function ensureAgentForChat(storage, chat, user, opts, modelChoice) {
+  const existing = getLiveSession(chat.id);
+  if (existing && existing.githubLogin.toLowerCase() === user.githubLogin.toLowerCase()) {
+    return { agent: existing.agent, agentId: existing.agentId, resumed: true };
+  }
+  const resolved = await resolveModel(opts.cursorApiKey, modelChoice);
+  const cloud = {
+    repos: [
+      {
+        url: chat.repoUrl,
+        startingRef: chat.startingRef
+      }
+    ],
+    autoCreatePR: chat.mode === "agent",
+    skipReviewerRequest: opts.skipReviewerRequest ?? true,
+    envVars: { GITHUB_TOKEN: user.accessToken },
+    ...opts.envName ? { env: { type: "cloud", name: opts.envName } } : {}
+  };
+  if (chat.agentId) {
+    try {
+      const resumed = await Agent.resume(chat.agentId, {
+        apiKey: opts.cursorApiKey,
+        model: { id: resolved.cursorModelId },
+        cloud
+      });
+      registerLiveSession({
+        chatId: chat.id,
+        githubLogin: user.githubLogin,
+        agent: resumed,
+        agentId: resumed.agentId
+      });
+      if (resumed.agentId !== chat.agentId) {
+        await storage.patchChat(chat.id, user.githubLogin, { agentId: resumed.agentId });
+      }
+      return { agent: resumed, agentId: resumed.agentId, resumed: true };
+    } catch (err) {
+      console.warn(
+        `[coding-tab] resume failed for chat=${chat.id} agentId=${chat.agentId}; creating fresh agent`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  const fresh = await Agent.create({
+    apiKey: opts.cursorApiKey,
+    model: { id: resolved.cursorModelId },
+    cloud
+  });
+  registerLiveSession({
+    chatId: chat.id,
+    githubLogin: user.githubLogin,
+    agent: fresh,
+    agentId: fresh.agentId
+  });
+  await storage.patchChat(chat.id, user.githubLogin, { agentId: fresh.agentId });
+  return { agent: fresh, agentId: fresh.agentId, resumed: false };
+}
+async function nextSeq(storage, chatId, login) {
+  const full = await storage.loadChat(chatId, login);
+  if (!full) throw Object.assign(new Error("chat_not_found"), { status: 404 });
+  const max = full.turns.reduce((acc, t) => Math.max(acc, t.seq), -1);
+  return max + 1;
+}
 function makeAgentRouter(opts) {
   const router = Router2();
   router.get("/models", async (_req, res) => {
@@ -335,144 +755,236 @@ function makeAgentRouter(opts) {
       res.status(500).json({ error: err instanceof Error ? err.message : "models_failed" });
     }
   });
-  router.post("/agent/start", async (req, res) => {
+  const handleSend = async (req, res, isExecute) => {
     const user = req.user;
-    const { prompt, mode, model, repoUrl, startingRef } = req.body ?? {};
-    if (!prompt || mode !== "plan" && mode !== "agent" || model !== "sonnet" && model !== "opus") {
+    const body = req.body ?? {};
+    if (!body.chatId) {
+      res.status(400).json({ error: "missing_chatId" });
+      return;
+    }
+    if (!isExecute && (!body.prompt || body.mode !== "plan" && body.mode !== "agent")) {
       res.status(400).json({ error: "invalid_request" });
       return;
     }
+    const chat = await opts.storage.loadChat(body.chatId, user.githubLogin);
+    if (!chat) {
+      res.status(404).json({ error: "chat_not_found" });
+      return;
+    }
     setupSseHeaders(res);
-    let agent;
+    let assistantTurn = null;
     try {
-      const resolved = await resolveModel(opts.cursorApiKey, model);
-      agent = await Agent.create({
-        apiKey: opts.cursorApiKey,
-        model: { id: resolved.cursorModelId },
-        cloud: {
-          repos: [
-            {
-              url: repoUrl ?? opts.defaultRepo.url,
-              startingRef: startingRef ?? opts.defaultRepo.ref
-            }
-          ],
-          autoCreatePR: mode === "agent",
-          skipReviewerRequest: opts.skipReviewerRequest ?? true,
-          envVars: { GITHUB_TOKEN: user.accessToken },
-          ...opts.envName ? { env: { type: "cloud", name: opts.envName } } : {}
+      if (!isExecute && body.mode && body.mode !== chat.mode) {
+        chat.mode = body.mode;
+        await opts.storage.patchChat(chat.id, user.githubLogin, { mode: body.mode });
+      }
+      let seq = await nextSeq(opts.storage, chat.id, user.githubLogin);
+      if (!isExecute) {
+        const userTurn = {
+          id: randomUUID2(),
+          chatId: chat.id,
+          seq: seq++,
+          role: "user",
+          isPlan: chat.mode === "plan",
+          status: "finished",
+          events: [{ kind: "text", id: randomUUID2(), text: body.prompt }],
+          prompt: body.prompt,
+          createdAt: Date.now()
+        };
+        await opts.storage.appendTurn(userTurn);
+        if (chat.title === "New chat") {
+          const title = deriveTitle(body.prompt);
+          chat.title = title;
+          await opts.storage.patchChat(chat.id, user.githubLogin, { title });
         }
+      }
+      assistantTurn = {
+        id: randomUUID2(),
+        chatId: chat.id,
+        seq,
+        role: "assistant",
+        isPlan: !isExecute && chat.mode === "plan",
+        status: "running",
+        events: [],
+        createdAt: Date.now()
+      };
+      await opts.storage.appendTurn(assistantTurn);
+      const { agent } = await ensureAgentForChat(opts.storage, chat, user, opts, chat.model);
+      const sendText = isExecute ? EXECUTE_INSTRUCTION : modeInstructionPrefix(body.mode, body.prompt);
+      const run = await agent.send(sendText);
+      sse(res, {
+        kind: "ready",
+        chatId: chat.id,
+        turnId: assistantTurn.id,
+        agentId: agent.agentId,
+        runId: run.id
       });
-      const session = registerSession({
-        githubLogin: user.githubLogin,
-        agent,
-        repoUrl: repoUrl ?? opts.defaultRepo.url,
-        startingRef: startingRef ?? opts.defaultRepo.ref
+      console.log(
+        `[coding-tab] ${isExecute ? "execute" : "send"} agent=${agent.agentId} run=${run.id} chat=${chat.id} login=${user.githubLogin}`
+      );
+      const buffer = new TurnBuffer();
+      await streamRun(res, run, {
+        storage: opts.storage,
+        chat,
+        turn: assistantTurn,
+        buffer
       });
-      const run = await agent.send(modeInstructionPrefix(mode, prompt));
-      sse(res, { kind: "ready", sessionId: session.id, agentId: agent.agentId, runId: run.id });
-      console.log(`[coding-tab] start agent=${agent.agentId} run=${run.id} session=${session.id} login=${user.githubLogin}`);
-      await streamRun(res, run);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       const retryable = err instanceof CursorAgentError ? Boolean(err.isRetryable) : false;
-      console.error("[coding-tab] /agent/start failed", err);
+      console.error(`[coding-tab] /agent/${isExecute ? "execute" : "send"} failed`, err);
       sse(res, { kind: "error", message, retryable });
+      if (assistantTurn) {
+        await opts.storage.patchTurn(assistantTurn.chatId, assistantTurn.id, {
+          status: "error",
+          events: [
+            ...assistantTurn.events,
+            { kind: "text", id: randomUUID2(), text: `[error] ${message}` }
+          ]
+        }).catch(() => {
+        });
+      }
       if (!res.writableEnded) res.end();
-      if (agent) await agent[Symbol.asyncDispose]().catch(() => {
-      });
     }
     req.on("close", () => {
       if (!res.writableEnded) res.end();
     });
-  });
-  router.post("/agent/send", async (req, res) => {
-    const { sessionId, prompt, mode } = req.body ?? {};
-    if (!sessionId || !prompt || mode !== "plan" && mode !== "agent") {
+  };
+  router.post("/agent/start", (req, res) => handleSend(req, res, false));
+  router.post("/agent/send", (req, res) => handleSend(req, res, false));
+  router.post("/agent/execute", (req, res) => handleSend(req, res, true));
+  router.post("/agent/cancel", async (req, res) => {
+    const { chatId, runId } = req.body ?? {};
+    if (!chatId || !runId) {
       res.status(400).json({ error: "invalid_request" });
       return;
     }
-    const session = getSession2(sessionId);
-    if (!session) {
+    const live = getLiveSession(chatId);
+    if (!live) {
       res.status(404).json({ error: "session_not_found" });
       return;
     }
-    setupSseHeaders(res);
     try {
-      const run = await session.agent.send(modeInstructionPrefix(mode, prompt));
-      sse(res, { kind: "ready", sessionId: session.id, agentId: session.agent.agentId, runId: run.id });
-      console.log(`[coding-tab] send agent=${session.agent.agentId} run=${run.id} session=${session.id}`);
-      await streamRun(res, run);
+      await Agent.cancelRun(runId, {
+        runtime: "cloud",
+        agentId: live.agentId,
+        apiKey: opts.cursorApiKey
+      });
+      res.json({ ok: true });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error("[coding-tab] /agent/send failed", err);
-      sse(res, { kind: "error", message });
-      if (!res.writableEnded) res.end();
+      console.error("[coding-tab] /agent/cancel failed", err);
+      res.status(500).json({ error: message });
     }
-    req.on("close", () => {
-      if (!res.writableEnded) res.end();
-    });
   });
-  router.post("/agent/execute", async (req, res) => {
-    const { sessionId } = req.body ?? {};
-    if (!sessionId) {
+  router.post("/agent/dispose", async (req, res) => {
+    const { chatId } = req.body ?? {};
+    if (!chatId) {
       res.status(400).json({ error: "invalid_request" });
       return;
     }
-    const session = getSession2(sessionId);
-    if (!session) {
-      res.status(404).json({ error: "session_not_found" });
-      return;
-    }
-    setupSseHeaders(res);
+    await disposeSessionsForChat(chatId);
+    res.json({ ok: true });
+  });
+  return router;
+}
+
+// src/server/chatRoutes.ts
+import { Router as Router3 } from "express";
+import { randomUUID as randomUUID3 } from "crypto";
+var VALID_MODES = ["plan", "agent"];
+var VALID_MODELS = ["sonnet", "opus"];
+function makeChatRouter(opts) {
+  const router = Router3();
+  router.get("/chats", async (req, res) => {
+    const user = req.user;
     try {
-      const run = await session.agent.send(EXECUTE_INSTRUCTION);
-      sse(res, { kind: "ready", sessionId: session.id, agentId: session.agent.agentId, runId: run.id });
-      console.log(`[coding-tab] execute agent=${session.agent.agentId} run=${run.id} session=${session.id}`);
-      await streamRun(res, run);
+      const items = await opts.storage.listChats(user.githubLogin);
+      res.json({ chats: items });
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.error("[coding-tab] /agent/execute failed", err);
-      sse(res, { kind: "error", message });
-      if (!res.writableEnded) res.end();
+      console.error("[coding-tab] /chats list failed", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "list_failed" });
     }
-    req.on("close", () => {
-      if (!res.writableEnded) res.end();
-    });
   });
-  router.post("/agent/cancel", async (req, res) => {
-    const { sessionId, runId } = req.body ?? {};
-    if (!sessionId || !runId) {
-      res.status(400).json({ error: "invalid_request" });
-      return;
+  router.post("/chats", async (req, res) => {
+    const user = req.user;
+    const body = req.body ?? {};
+    const mode = VALID_MODES.includes(body.mode) ? body.mode : "plan";
+    const model = VALID_MODELS.includes(body.model) ? body.model : "sonnet";
+    const now = Date.now();
+    const chat = {
+      id: randomUUID3(),
+      githubLogin: user.githubLogin,
+      title: (body.title ?? "").trim() || "New chat",
+      mode,
+      model,
+      repoUrl: body.repoUrl?.trim() || opts.defaultRepo.url,
+      startingRef: body.startingRef ?? opts.defaultRepo.ref,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      await opts.storage.createChat(chat);
+      res.status(201).json({ chat });
+    } catch (err) {
+      console.error("[coding-tab] /chats create failed", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "create_failed" });
     }
-    const session = getSession2(sessionId);
-    if (!session) {
-      res.status(404).json({ error: "session_not_found" });
-      return;
+  });
+  router.get("/chats/:id", async (req, res) => {
+    const user = req.user;
+    try {
+      const full = await opts.storage.loadChat(req.params.id, user.githubLogin);
+      if (!full) {
+        res.status(404).json({ error: "chat_not_found" });
+        return;
+      }
+      res.json({ chat: full });
+    } catch (err) {
+      console.error("[coding-tab] /chats/:id load failed", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "load_failed" });
     }
+  });
+  router.patch("/chats/:id", async (req, res) => {
+    const user = req.user;
+    const body = req.body ?? {};
+    const patch = {};
+    if (typeof body.title === "string") patch.title = body.title.trim() || "Untitled";
+    if (body.mode && VALID_MODES.includes(body.mode)) patch.mode = body.mode;
+    if (body.model && VALID_MODELS.includes(body.model)) patch.model = body.model;
     try {
-      await Agent.cancelRun(runId, { runtime: "cloud", agentId: session.agent.agentId, apiKey: opts.cursorApiKey });
-      res.json({ ok: true });
+      const updated = await opts.storage.patchChat(req.params.id, user.githubLogin, patch);
+      if (!updated) {
+        res.status(404).json({ error: "chat_not_found" });
+        return;
+      }
+      res.json({ chat: updated });
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.error("[coding-tab] /agent/cancel failed", err);
-      res.status(500).json({ error: message });
+      console.error("[coding-tab] /chats/:id patch failed", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "patch_failed" });
     }
   });
-  router.post("/agent/dispose", async (req, res) => {
-    const { sessionId } = req.body ?? {};
-    if (!sessionId) {
-      res.status(400).json({ error: "invalid_request" });
-      return;
+  router.delete("/chats/:id", async (req, res) => {
+    const user = req.user;
+    try {
+      const removed = await opts.storage.deleteChat(req.params.id, user.githubLogin);
+      if (!removed) {
+        res.status(404).json({ error: "chat_not_found" });
+        return;
+      }
+      await disposeSessionsForChat(req.params.id).catch(() => {
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      console.error("[coding-tab] /chats/:id delete failed", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "delete_failed" });
     }
-    await disposeSession(sessionId);
-    res.json({ ok: true });
   });
   return router;
 }
 
 // src/server/githubRoutes.ts
-import { Router as Router3 } from "express";
+import { Router as Router4 } from "express";
 import { Octokit } from "@octokit/rest";
 function parsePrUrl2(prUrl) {
   const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
@@ -480,7 +992,7 @@ function parsePrUrl2(prUrl) {
   return { owner: match[1], repo: match[2], number: Number(match[3]) };
 }
 function makeGitHubRouter() {
-  const router = Router3();
+  const router = Router4();
   router.get("/pr/status", async (req, res) => {
     const prUrl = typeof req.query.prUrl === "string" ? req.query.prUrl : null;
     if (!prUrl) {
@@ -559,26 +1071,26 @@ function makeGitHubRouter() {
 }
 
 // src/server/staticAssets.ts
-import { Router as Router4 } from "express";
-import { readFile } from "fs/promises";
-import { resolve, dirname } from "path";
+import { Router as Router5 } from "express";
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-var here = dirname(fileURLToPath(import.meta.url));
+var here = dirname2(fileURLToPath(import.meta.url));
 var ASSET_CANDIDATES = [
-  resolve(here, "browser.js"),
-  resolve(here, "..", "dist", "browser.js"),
-  resolve(here, "..", "browser.js")
+  resolve2(here, "browser.js"),
+  resolve2(here, "..", "dist", "browser.js"),
+  resolve2(here, "..", "browser.js")
 ];
 var STYLE_CANDIDATES = [
-  resolve(here, "style.css"),
-  resolve(here, "..", "dist", "style.css"),
-  resolve(here, "..", "style.css")
+  resolve2(here, "style.css"),
+  resolve2(here, "..", "dist", "style.css"),
+  resolve2(here, "..", "style.css")
 ];
 async function readFirst(paths) {
   let lastErr;
   for (const p of paths) {
     try {
-      const data = await readFile(p);
+      const data = await readFile2(p);
       return { path: p, data };
     } catch (err) {
       lastErr = err;
@@ -587,7 +1099,7 @@ async function readFirst(paths) {
   throw lastErr instanceof Error ? lastErr : new Error("asset not found");
 }
 function makeAssetRouter(basePath) {
-  const router = Router4();
+  const router = Router5();
   router.get("/browser.js", async (_req, res) => {
     try {
       const { data } = await readFirst(ASSET_CANDIDATES);
@@ -654,6 +1166,7 @@ function mountCodingTab(app, options) {
   if (!options.githubOAuth.allowedLogins || options.githubOAuth.allowedLogins.length === 0) {
     console.warn("[coding-tab] WARNING: allowedLogins is empty \u2014 anyone with a GitHub account can sign in.");
   }
+  const storage = options.storage ?? createDefaultStorage(options.dataDir);
   const router = express.Router();
   router.use(express.json({ limit: "1mb" }));
   const assetRouter = makeAssetRouter(basePath);
@@ -672,11 +1185,14 @@ function mountCodingTab(app, options) {
     secure,
     allowedLogins: options.githubOAuth.allowedLogins
   });
+  const chatRouter = makeChatRouter({ storage, defaultRepo: options.defaultRepo });
+  router.use(requireAuth, chatRouter);
   const agentRouter = makeAgentRouter({
     cursorApiKey: options.cursorApiKey,
     defaultRepo: options.defaultRepo,
     envName: options.envName,
-    skipReviewerRequest: options.skipReviewerRequest
+    skipReviewerRequest: options.skipReviewerRequest,
+    storage
   });
   router.use(requireAuth, agentRouter);
   const githubRouter = makeGitHubRouter();
@@ -686,6 +1202,8 @@ function mountCodingTab(app, options) {
   return router;
 }
 export {
+  FileChatStorage,
+  createDefaultStorage,
   mountCodingTab
 };
 //# sourceMappingURL=server.js.map