repoburg 1.3.219 → 1.3.220

package/agent-pane/backend/dist/index.js

@@ -41076,6 +41076,14 @@ function createTables(database) {
       created_at  TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS sidebar_folders (
+      id             TEXT PRIMARY KEY,
+      workspace_path TEXT NOT NULL,
+      name           TEXT NOT NULL,
+      sort_order     INTEGER NOT NULL DEFAULT 0,
+      created_at     TEXT NOT NULL
+    );
+
     CREATE TABLE IF NOT EXISTS discussion_threads (
       id            TEXT PRIMARY KEY,
       session_id    TEXT NOT NULL,
@@ -41094,6 +41102,8 @@ function createTables(database) {
     CREATE INDEX IF NOT EXISTS idx_turns_session_id ON turns(session_id);
     CREATE INDEX IF NOT EXISTS idx_items_turn_id ON items(turn_id);
     CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
+CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
+    CREATE INDEX IF NOT EXISTS idx_sidebar_folders_workspace_path ON sidebar_folders(workspace_path);
     CREATE INDEX IF NOT EXISTS idx_discussion_threads_session_id ON discussion_threads(session_id);
     CREATE INDEX IF NOT EXISTS idx_discussion_threads_item_id ON discussion_threads(item_id);
   `);
@@ -41123,6 +41133,15 @@ function createTables(database) {
   if (!sessColumns.some((c) => c.name === "context_usage")) {
     database.exec("ALTER TABLE sessions ADD COLUMN context_usage TEXT");
   }
+  if (!sessColumns.some((c) => c.name === "folder_id")) {
+    database.exec("ALTER TABLE sessions ADD COLUMN folder_id TEXT");
+  }
+  if (!sessColumns.some((c) => c.name === "sort_order")) {
+    database.exec("ALTER TABLE sessions ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0");
+  }
+  if (!sessColumns.some((c) => c.name === "starred")) {
+    database.exec("ALTER TABLE sessions ADD COLUMN starred INTEGER NOT NULL DEFAULT 0");
+  }
   const turnColumns = database.prepare("PRAGMA table_info(turns)").all();
   if (!turnColumns.some((c) => c.name === "thread_id")) {
     database.exec("ALTER TABLE turns ADD COLUMN thread_id TEXT");
@@ -41304,21 +41323,30 @@ async function registerSessionRoutes(fastify) {
       list.push(item);
       itemsByTurn.set(item.turn_id, list);
     }
+    const hydrateTurn = (row) => ({
+      ...row,
+      token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
+      attachments: row.attachments ? JSON.parse(row.attachments) : null,
+      runtime_input_ids: row.runtime_input_ids ? JSON.parse(row.runtime_input_ids) : null,
+      items: itemsByTurn.get(row.id) ?? []
+    });
+    const mainTurns = turnRows.filter((row) => row.thread_id == null).map(hydrateTurn);
+    const threadTurns = turnRows.filter((row) => row.thread_id != null).map(hydrateTurn);
     const detail = {
       ...session,
-      turns: turnRows.map((row) => ({
-        ...row,
-        token_usage: row.token_usage ? JSON.parse(row.token_usage) : null,
-        attachments: row.attachments ? JSON.parse(row.attachments) : null,
-        runtime_input_ids: row.runtime_input_ids ? JSON.parse(row.runtime_input_ids) : null,
-        items: itemsByTurn.get(row.id) ?? []
-      }))
+      turns: mainTurns
     };
     const threadRows = db2.prepare("SELECT * FROM discussion_threads WHERE session_id = ? ORDER BY created_at ASC").all(id);
+    const turnsByThread = /* @__PURE__ */ new Map();
+    for (const t of threadTurns) {
+      const list = turnsByThread.get(t.thread_id) ?? [];
+      list.push(t);
+      turnsByThread.set(t.thread_id, list);
+    }
     if (threadRows.length > 0) {
       detail.threads = threadRows.map((tr) => ({
         ...tr,
-        turns: detail.turns.filter((t) => t.thread_id === tr.id)
+        turns: turnsByThread.get(tr.id) ?? []
       }));
     }
     const cuRow = db2.prepare("SELECT context_usage FROM sessions WHERE id = ?").get(id);
@@ -41355,11 +41383,13 @@ async function registerSessionRoutes(fastify) {
     } = request.body || {};
     const id = v4_default();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    getDb().prepare(
-      `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, created_at, updated_at, runtime_config)
-         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?, ?)`
-    ).run(id, title, runtime_type, model, model_reasoning_effort, cwd, now, now, runtime_config);
-    const session = getDb().prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    const db2 = getDb();
+    const maxOrder = db2.prepare("SELECT COALESCE(MAX(sort_order), 0) AS m FROM sessions WHERE cwd = ?").get(cwd ?? null);
+    db2.prepare(
+      `INSERT INTO sessions (id, title, runtime_type, model, model_reasoning_effort, cwd, external_thread_id, status, is_running, sort_order, created_at, updated_at, runtime_config)
+         VALUES (?, ?, ?, ?, ?, ?, NULL, 'active', 0, ?, ?, ?, ?)`
+    ).run(id, title, runtime_type, model, model_reasoning_effort, cwd, maxOrder.m + 1, now, now, runtime_config);
+    const session = db2.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
     return session;
   });
   fastify.delete("/api/sessions/:id", async (request, reply) => {
@@ -41386,13 +41416,14 @@ async function registerSessionRoutes(fastify) {
           model_reasoning_effort: { type: ["string", "null"] },
           runtime_config: { type: ["string", "null"] },
           runtime_type: { type: "string" },
-          cwd: { type: ["string", "null"] }
+          cwd: { type: ["string", "null"] },
+          starred: { type: "number" }
         }
       }
     }
   }, async (request, reply) => {
     const { id } = request.params;
-    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type, cwd } = request.body || {};
+    const { title, lifecycle, has_unreviewed, model, model_reasoning_effort, runtime_config, runtime_type, cwd, starred } = request.body || {};
     const db2 = getDb();
     const existing = db2.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
     if (!existing) {
@@ -41417,6 +41448,10 @@ async function registerSessionRoutes(fastify) {
       updates.push("has_unreviewed = ?");
       params.push(has_unreviewed);
     }
+    if (starred !== void 0) {
+      updates.push("starred = ?");
+      params.push(starred);
+    }
     if (runtime_type !== void 0 && runtime_type !== existing.runtime_type) {
       providerChanged = true;
       updates.push("runtime_type = ?");
@@ -41877,6 +41912,60 @@ ${message}`;
       return { turn };
     }
   );
+  fastify.post(
+    "/api/sessions/:sessionId/threads/:threadId/summarize",
+    {
+      schema: {
+        body: {
+          type: "object",
+          properties: {
+            directives: { type: "string" }
+          }
+        }
+      }
+    },
+    async (request, reply) => {
+      const { sessionId, threadId } = request.params;
+      const { directives } = request.body || {};
+      const db2 = getDb();
+      const session = db2.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
+      if (!session) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      const thread = db2.prepare("SELECT * FROM discussion_threads WHERE id = ? AND session_id = ?").get(threadId, sessionId);
+      if (!thread) {
+        return reply.code(404).send({ error: "Thread not found" });
+      }
+      if (thread.status !== "open") {
+        return reply.code(409).send({ error: "Thread is already resolved" });
+      }
+      const runningTurn = db2.prepare(`SELECT id FROM turns WHERE thread_id = ? AND status IN ('pending', 'running') LIMIT 1`).get(threadId);
+      if (runningTurn) {
+        return reply.code(409).send({ error: "A thread turn is still running \u2014 wait for it to finish first" });
+      }
+      const provider = getProvider(session.runtime_type);
+      if (!provider.summarizeThread) {
+        return reply.code(501).send({ error: `Summarization is not supported for runtime "${session.runtime_type}" yet` });
+      }
+      const turnRows = db2.prepare("SELECT user_prompt, agent_response, status FROM turns WHERE thread_id = ? ORDER BY created_at ASC").all(threadId);
+      const transcript = turnRows.map((t) => {
+        const agent = t.agent_response?.trim() || "(no response)";
+        return `User: ${t.user_prompt}
+
+Agent: ${agent}`;
+      }).join("\n\n---\n\n");
+      const summary = await provider.summarizeThread(session, thread, transcript, directives ?? "");
+      if (!summary) {
+        return reply.code(500).send({ error: "Summarization failed \u2014 thread was not resolved. Try again or resolve without sharing." });
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db2.prepare(
+        "UPDATE discussion_threads SET status = ?, resolved_at = ?, updated_at = ? WHERE id = ?"
+      ).run("resolved", now, now, threadId);
+      broadcast("thread:resolved", { sessionId, threadId, status: "resolved" });
+      return { summary, resolved: true };
+    }
+  );
   fastify.patch(
     "/api/sessions/:sessionId/threads/:threadId",
     {
@@ -42066,6 +42155,137 @@ async function registerWorkspaceRoutes(fastify) {
   });
 }
 
+// src/routes/folders.ts
+async function registerFolderRoutes(fastify) {
+  fastify.get("/api/folders", async () => {
+    const rows = getDb().prepare("SELECT * FROM sidebar_folders ORDER BY workspace_path ASC, sort_order ASC").all();
+    return rows;
+  });
+  fastify.post("/api/folders", {
+    schema: {
+      body: {
+        type: "object",
+        required: ["workspace_path", "name"],
+        properties: {
+          workspace_path: { type: "string" },
+          name: { type: "string" }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const { workspace_path, name } = request.body || {};
+    if (!workspace_path?.trim() || !name?.trim()) {
+      return reply.code(400).send({ error: "workspace_path and name are required" });
+    }
+    const db2 = getDb();
+    const id = v4_default();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const maxOrder = db2.prepare("SELECT COALESCE(MAX(sort_order), -1) AS m FROM sidebar_folders WHERE workspace_path = ?").get(workspace_path.trim());
+    db2.prepare(
+      "INSERT INTO sidebar_folders (id, workspace_path, name, sort_order, created_at) VALUES (?, ?, ?, ?, ?)"
+    ).run(id, workspace_path.trim(), name.trim(), maxOrder.m + 1, now);
+    const folder = db2.prepare("SELECT * FROM sidebar_folders WHERE id = ?").get(id);
+    return folder;
+  });
+  fastify.patch("/api/folders/:id", {
+    schema: {
+      body: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          sort_order: { type: "number" }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const { id } = request.params;
+    const { name, sort_order } = request.body || {};
+    const db2 = getDb();
+    const existing = db2.prepare("SELECT * FROM sidebar_folders WHERE id = ?").get(id);
+    if (!existing) {
+      return reply.code(404).send({ error: "Folder not found" });
+    }
+    if (name !== void 0 && !name.trim()) {
+      return reply.code(400).send({ error: "name cannot be empty" });
+    }
+    const updates = [];
+    const params = [];
+    if (name !== void 0) {
+      updates.push("name = ?");
+      params.push(name.trim());
+    }
+    if (sort_order !== void 0) {
+      updates.push("sort_order = ?");
+      params.push(sort_order);
+    }
+    if (updates.length > 0) {
+      db2.prepare(`UPDATE sidebar_folders SET ${updates.join(", ")} WHERE id = ?`).run(...params, id);
+    }
+    return db2.prepare("SELECT * FROM sidebar_folders WHERE id = ?").get(id);
+  });
+  fastify.delete("/api/folders/:id", async (request, reply) => {
+    const { id } = request.params;
+    const db2 = getDb();
+    const existing = db2.prepare("SELECT id FROM sidebar_folders WHERE id = ?").get(id);
+    if (!existing) {
+      return reply.code(404).send({ error: "Folder not found" });
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const move = db2.transaction(() => {
+      db2.prepare(
+        "UPDATE sessions SET folder_id = NULL, updated_at = ? WHERE folder_id = ?"
+      ).run(now, id);
+      db2.prepare("DELETE FROM sidebar_folders WHERE id = ?").run(id);
+    });
+    move();
+    return { success: true };
+  });
+  fastify.post("/api/sessions/reorder", {
+    schema: {
+      body: {
+        type: "object",
+        required: ["moves"],
+        properties: {
+          moves: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["id", "sort_order"],
+              properties: {
+                id: { type: "string" },
+                folder_id: { type: ["string", "null"] },
+                sort_order: { type: "number" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const { moves } = request.body || {};
+    const db2 = getDb();
+    for (const m of moves) {
+      if (!db2.prepare("SELECT id FROM sessions WHERE id = ?").get(m.id)) {
+        return reply.code(404).send({ error: `Session not found: ${m.id}` });
+      }
+      if (m.folder_id && !db2.prepare("SELECT id FROM sidebar_folders WHERE id = ?").get(m.folder_id)) {
+        return reply.code(404).send({ error: `Folder not found: ${m.folder_id}` });
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = db2.prepare(
+      "UPDATE sessions SET folder_id = ?, sort_order = ?, updated_at = ? WHERE id = ?"
+    );
+    const apply = db2.transaction(() => {
+      for (const m of moves) {
+        stmt.run(m.folder_id ?? null, m.sort_order, now, m.id);
+      }
+    });
+    apply();
+    return { success: true, updated: moves.length };
+  });
+}
+
 // src/routes/providers.ts
 var CODEX_PROVIDER = {
   id: "codex",
@@ -42966,6 +43186,75 @@ Agent responded: "${truncatedResponse}"`;
     }
   }
 }
+async function summarizeCodexThread(session, _thread, transcript, directives) {
+  let client = null;
+  try {
+    client = new AppServerClient({ cwd: session.cwd ?? process.cwd() });
+    await client.initialize();
+    const initResult = await client.request("thread/start", {
+      cwd: session.cwd ?? process.cwd(),
+      approvalPolicy: "never",
+      sandbox: "read-only"
+    });
+    const threadId = initResult.thread.id;
+    const directiveLine = directives.trim() ? `
+
+The user has given these summarization directives \u2014 follow them exactly:
+"${directives.trim()}"` : "";
+    const summaryPrompt = `You are summarizing a side discussion thread that forked from a main agent session. The discussion begins at the FIRST message of the transcript below \u2014 summarize ONLY the discussion itself, from its beginning up to now.${directiveLine}
+
+The discussion transcript (from the discussion's beginning):
+
+${transcript}
+
+Produce a concise summary of the discussion that preserves: concrete findings, file paths, decisions, and any unresolved questions. Reply with only the summary text, nothing else.`;
+    let summaryResolve;
+    let summaryReject;
+    const summaryPromise = new Promise((resolve, reject) => {
+      summaryResolve = resolve;
+      summaryReject = reject;
+    });
+    let summaryResponse = "";
+    client.onNotification("item/completed", (params) => {
+      const p = params;
+      if (p.threadId !== threadId) return;
+      if ((p.item.type === "agentMessage" || p.item.type === "agent_message") && p.item.text) {
+        summaryResponse = p.item.text;
+      }
+    });
+    client.onNotification("turn/completed", (params) => {
+      const p = params;
+      if (p.threadId !== threadId) return;
+      summaryResolve(summaryResponse);
+    });
+    client.onNotification("turn/failed", (params) => {
+      const p = params;
+      if (p.threadId !== threadId) return;
+      summaryReject(new Error(p.error.message));
+    });
+    const timeout = setTimeout(() => {
+      summaryReject(new Error("Thread summarization timed out"));
+    }, 6e4);
+    await client.request("turn/start", {
+      threadId,
+      input: [{ type: "text", text: summaryPrompt }],
+      approvalPolicy: "never",
+      sandbox: { type: "read-only" }
+    });
+    const summary = await summaryPromise;
+    clearTimeout(timeout);
+    const clean = summary.trim();
+    return clean || null;
+  } catch (err) {
+    console.error("[codex] summarizeThread failed:", err);
+    return null;
+  } finally {
+    if (client) {
+      await client.close().catch(() => {
+      });
+    }
+  }
+}
 var EFFORT_LABELS = {
   minimal: "Minimal",
   low: "Low",
@@ -43002,6 +43291,7 @@ var codexProvider = {
   clearThread,
   clearAllThreads,
   getModels,
+  summarizeThread: summarizeCodexThread,
   shutdown
 };
 
@@ -43209,6 +43499,7 @@ var PromptQueue = class {
     };
   }
 };
+var CLI_OVERRIDE = process.env.CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.CLAUDE_BIN } : {};
 var sessionMap2 = /* @__PURE__ */ new Map();
 var titleGenerating2 = /* @__PURE__ */ new Set();
 var cachedModels = null;
@@ -43242,7 +43533,7 @@ async function ensureSessionStarted(session, mapKey, resumeSessionId) {
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     includePartialMessages: true,
-    ...process.env.CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.CLAUDE_BIN } : {},
+    ...CLI_OVERRIDE,
     ...session.model_reasoning_effort ? { effort: session.model_reasoning_effort } : {},
     ...resumeId ? { resume: resumeId } : {}
   };
@@ -43853,7 +44144,8 @@ async function getModels2() {
       options: {
         cwd: process.cwd(),
         permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true
+        allowDangerouslySkipPermissions: true,
+        ...CLI_OVERRIDE
       }
     });
     const initResult = await q.initializationResult();
@@ -43917,7 +44209,8 @@ Agent responded: "${truncatedResponse}"`;
       options: {
         cwd: process.cwd(),
         permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true
+        allowDangerouslySkipPermissions: true,
+        ...CLI_OVERRIDE
       }
     });
     let titleResponse = "";
@@ -43944,6 +44237,66 @@ Agent responded: "${truncatedResponse}"`;
     }
   }
 }
+function buildThreadSummaryPrompt(transcript, directives, hasNativeContext) {
+  const directiveLine = directives.trim() ? `
+
+The user has given these summarization directives \u2014 follow them exactly:
+"${directives.trim()}"` : "";
+  const contextBlock = hasNativeContext ? "" : `
+
+The discussion transcript (from the discussion's beginning):
+
+${transcript}`;
+  return `You are summarizing a side discussion thread that forked from a main agent session. The discussion begins at the message that quotes a passage from a previous response (prefixed "[Quoting from your previous response]") \u2014 everything in the conversation BEFORE that message is the main session's earlier context and must NOT be included in the summary. Summarize ONLY the discussion itself, from its first message up to now \u2014 do not summarize the full conversation history.${contextBlock}${directiveLine}
+
+Produce a concise summary of the discussion that preserves: concrete findings, file paths, decisions, and any unresolved questions. The summary will be quoted back into the main session's conversation. Reply with only the summary text, nothing else.`;
+}
+async function summarizeClaudeThread(session, thread, transcript, directives) {
+  let q = null;
+  try {
+    let resumeId;
+    if (thread.external_thread_id) {
+      try {
+        const forked = await sdkForkSession(thread.external_thread_id, {
+          dir: session.cwd ?? process.cwd()
+        });
+        resumeId = forked.sessionId;
+      } catch (err) {
+        console.error("[claude] summarizeThread fork failed \u2014 falling back to embedded transcript:", err);
+      }
+    }
+    const prompt = buildThreadSummaryPrompt(transcript, directives, !!resumeId);
+    q = query({
+      prompt,
+      options: {
+        cwd: session.cwd ?? process.cwd(),
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        ...CLI_OVERRIDE,
+        ...resumeId ? { resume: resumeId } : {}
+      }
+    });
+    let summary = "";
+    for await (const message of q) {
+      if (message.type === "assistant") {
+        for (const block of message.message.content) {
+          if (block.type === "text") {
+            summary += block.text;
+          }
+        }
+      }
+    }
+    const clean = summary.trim();
+    return clean || null;
+  } catch (err) {
+    console.error("[claude] summarizeThread failed:", err);
+    return null;
+  } finally {
+    if (q) {
+      q.close();
+    }
+  }
+}
 async function forkClaudeSession(session, targetTurn) {
   if (!session.external_thread_id) return null;
   try {
@@ -43966,6 +44319,7 @@ var claudeProvider = {
   getModels: getModels2,
   getCommands,
   forkSession: forkClaudeSession,
+  summarizeThread: summarizeClaudeThread,
   setModel,
   stopTask,
   shutdown: shutdown2
@@ -45484,6 +45838,7 @@ async function createAgentPaneApp(dbPath) {
   await registerTurnRoutes(fastify);
   await registerThreadRoutes(fastify);
   await registerWorkspaceRoutes(fastify);
+  await registerFolderRoutes(fastify);
   await registerProviderRoutes(fastify);
   await registerModelRoutes(fastify);
   await registerSkillRoutes(fastify);