@sideboard-ai/core 0.1.291 → 0.1.293

package/dist/agents/cursor-runner.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/agents/cursor-runner.ts
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_readline2 = require("readline");
 
 // src/hook/nested-electron-env.ts
@@ -346,14 +346,288 @@ function ensureCursorRipgrepPath(opts) {
   return path;
 }
 
-// src/agents/cursor-store.ts
+// src/agents/cursor-catalog.ts
+var import_node_fs14 = require("fs");
 var import_node_path15 = require("path");
+var import_proper_lockfile = __toESM(require("proper-lockfile"), 1);
+var CATALOG_FILES = ["agents.ndjson", "runs.ndjson", "run_events.ndjson", "checkpoints.ndjson"];
+var INTERRUPTED_TMP = /^\.(agents|runs|run_events|checkpoints)\.ndjson\.[0-9a-f]{16}\.tmp$/;
+async function acquireCursorCatalogLock(storeDir) {
+  (0, import_node_fs14.mkdirSync)(storeDir, { recursive: true });
+  const lockPath = (0, import_node_path15.join)(storeDir, ".catalog.lock");
+  (0, import_node_fs14.writeFileSync)(lockPath, "", { flag: "a" });
+  try {
+    return await import_proper_lockfile.default.lock(lockPath, {
+      retries: { retries: 40, minTimeout: 50, maxTimeout: 500 },
+      stale: 5e3,
+      update: 2e3
+    });
+  } catch {
+    return async () => {
+    };
+  }
+}
+var heldCatalogRelease;
+function publishRepair(repair, note) {
+  for (const line of repair.notes) note(line);
+}
+async function openCursorCatalogTurn(storeDir, note) {
+  (0, import_node_fs14.mkdirSync)(storeDir, { recursive: true });
+  heldCatalogRelease = await acquireCursorCatalogLock(storeDir);
+  publishRepair(repairCursorLocalCatalog(storeDir), note);
+}
+function repairCursorCatalogForResume(storeDir, note) {
+  const repair = repairCursorLocalCatalog(storeDir);
+  publishRepair(repair, note);
+  return repair.repaired;
+}
+async function closeCursorCatalogTurn() {
+  const release = heldCatalogRelease;
+  heldCatalogRelease = void 0;
+  if (release) await release().catch(() => void 0);
+}
+function repairCursorLocalCatalog(storeDir) {
+  if (!(0, import_node_fs14.existsSync)(storeDir)) return { repaired: false, notes: [] };
+  const notes = [];
+  let repaired = false;
+  const loaded = /* @__PURE__ */ new Map();
+  for (const file of CATALOG_FILES) {
+    loaded.set(file, loadCatalogFile(storeDir, file));
+  }
+  const checkpoints = mergeByKey(
+    loaded.get("checkpoints.ndjson").main,
+    loaded.get("checkpoints.ndjson").tmpRows,
+    (row) => checkpointKey(row),
+    (main2) => main2
+  );
+  const blobs = checkpointBlobs(checkpoints.rows);
+  const agents = mergeByKey(
+    loaded.get("agents.ndjson").main,
+    loaded.get("agents.ndjson").tmpRows,
+    (row) => typeof row.agentId === "string" ? row.agentId : null,
+    (main2, extra) => preferAgent(main2, extra, blobs)
+  );
+  const runs = mergeByKey(
+    loaded.get("runs.ndjson").main,
+    loaded.get("runs.ndjson").tmpRows,
+    (row) => runKey(row),
+    (main2, extra) => num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2
+  );
+  const events = mergeByKey(
+    loaded.get("run_events.ndjson").main,
+    loaded.get("run_events.ndjson").tmpRows,
+    (row) => eventKey(row),
+    (main2) => main2
+  );
+  const merged = {
+    "checkpoints.ndjson": checkpoints.rows,
+    "agents.ndjson": agents.rows,
+    "runs.ndjson": runs.rows,
+    "run_events.ndjson": events.rows
+  };
+  for (const agent of merged["agents.ndjson"]) {
+    if (restoreAgentCheckpoint(agent, merged["runs.ndjson"], blobs, notes)) repaired = true;
+    if (clearMissingActiveRun(agent, merged["runs.ndjson"], notes)) repaired = true;
+  }
+  for (const file of CATALOG_FILES) {
+    const prior = loaded.get(file);
+    const next = merged[file];
+    const recovered = countNewKeys(prior.main, next, keyFor(file));
+    if (recovered > 0) {
+      notes.push(`Cursor catalog recovered ${recovered} ${file} row(s) from an interrupted write`);
+      repaired = true;
+    }
+    if (!sameRows(prior.main, next)) {
+      writeCatalogFile((0, import_node_path15.join)(storeDir, file), next);
+      repaired = true;
+    }
+    for (const tmp of prior.tmps) {
+      try {
+        (0, import_node_fs14.unlinkSync)(tmp);
+      } catch {
+      }
+    }
+  }
+  return { repaired, notes };
+}
+function loadCatalogFile(storeDir, file) {
+  const tmps = interruptedTmps(storeDir, file);
+  return {
+    main: readRows((0, import_node_path15.join)(storeDir, file)),
+    tmps,
+    tmpRows: tmps.flatMap((tmp) => readRows(tmp))
+  };
+}
+function keyFor(file) {
+  if (file === "checkpoints.ndjson") return checkpointKey;
+  if (file === "agents.ndjson") return (row) => typeof row.agentId === "string" ? row.agentId : null;
+  if (file === "runs.ndjson") return runKey;
+  return eventKey;
+}
+function countNewKeys(main2, next, keyOf) {
+  const had = new Set(main2.map(keyOf).filter((key) => Boolean(key)));
+  let n = 0;
+  for (const row of next) {
+    const key = keyOf(row);
+    if (key && !had.has(key)) n += 1;
+  }
+  return n;
+}
+function interruptedTmps(storeDir, file) {
+  let names = [];
+  try {
+    names = (0, import_node_fs14.readdirSync)(storeDir);
+  } catch {
+    return [];
+  }
+  const prefix = `.${file}.`;
+  return names.filter((name) => name.startsWith(prefix) && INTERRUPTED_TMP.test(name)).map((name) => (0, import_node_path15.join)(storeDir, name));
+}
+function readRows(file) {
+  if (!(0, import_node_fs14.existsSync)(file)) return [];
+  let raw = "";
+  try {
+    raw = (0, import_node_fs14.readFileSync)(file, "utf8");
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isRow(parsed)) rows.push(parsed);
+    } catch {
+    }
+  }
+  return rows;
+}
+function writeCatalogFile(file, rows) {
+  if (rows.length === 0 && !(0, import_node_fs14.existsSync)(file)) return;
+  const body = rows.map((row) => JSON.stringify(row)).join("\n");
+  const dir = (0, import_node_path15.dirname)(file);
+  (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
+  const tmp = (0, import_node_path15.join)(dir, `.${(0, import_node_path15.basename)(file)}.repair.tmp`);
+  (0, import_node_fs14.writeFileSync)(tmp, body);
+  (0, import_node_fs14.renameSync)(tmp, file);
+}
+function mergeByKey(main2, extra, keyOf, prefer) {
+  const out = [];
+  const index = /* @__PURE__ */ new Map();
+  for (const row of main2) {
+    const key = keyOf(row);
+    if (!key || index.has(key)) continue;
+    index.set(key, out.length);
+    out.push(structuredClone(row));
+  }
+  for (const row of extra) {
+    const key = keyOf(row);
+    if (!key) continue;
+    const at = index.get(key);
+    if (at == null) {
+      index.set(key, out.length);
+      out.push(structuredClone(row));
+      continue;
+    }
+    out[at] = structuredClone(prefer(out[at], row));
+  }
+  return { rows: out };
+}
+function restoreAgentCheckpoint(agent, runs, blobs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const current = rootBlobId(agent.latestCheckpoint);
+  if (!agentId || !current || blobs.has(`${agentId}\0${current}`)) return false;
+  const fallback = fallbackCheckpoint(runs, agentId, blobs);
+  const fallbackId = rootBlobId(fallback);
+  if (!fallback || !fallbackId) return false;
+  agent.latestCheckpoint = fallback;
+  agent.updatedAt = Date.now();
+  notes.push(
+    `Cursor catalog restored agent ${agentId} to checkpoint ${fallbackId} (root blob ${current} was missing)`
+  );
+  return true;
+}
+function clearMissingActiveRun(agent, runs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const active = typeof agent.activeRunId === "string" ? agent.activeRunId : "";
+  if (!agentId || !active) return false;
+  const live = runs.some((run2) => run2.agentId === agentId && run2.runId === active);
+  if (live) return false;
+  agent.activeRunId = null;
+  if (agent.status === "running") agent.status = "idle";
+  notes.push(`Cursor catalog cleared missing run ${active} on agent ${agentId}`);
+  return true;
+}
+function fallbackCheckpoint(runs, agentId, blobs) {
+  const mine = runs.filter((run2) => run2.agentId === agentId).slice().sort((a, b) => num(b.updatedAt) - num(a.updatedAt));
+  for (const run2 of mine) {
+    for (const field of ["latestCheckpointRef", "startCheckpointRef"]) {
+      const ref = run2[field];
+      const id = rootBlobId(ref);
+      if (id && blobs.has(`${agentId}\0${id}`) && isRow(ref)) return ref;
+    }
+  }
+  return null;
+}
+function preferAgent(main2, extra, blobs) {
+  const mainOk = checkpointPresent(main2, blobs);
+  const extraOk = checkpointPresent(extra, blobs);
+  if (mainOk && !extraOk) return main2;
+  if (extraOk && !mainOk) return extra;
+  return num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2;
+}
+function checkpointPresent(agent, blobs) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const id = rootBlobId(agent.latestCheckpoint);
+  if (!id) return true;
+  return blobs.has(`${agentId}\0${id}`);
+}
+function checkpointBlobs(rows) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row.agentId !== "string" || typeof row.blobId !== "string") continue;
+    if (typeof row.dataBase64 !== "string" || !row.dataBase64) continue;
+    ids.add(`${row.agentId}\0${row.blobId}`);
+  }
+  return ids;
+}
+function checkpointKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.blobId !== "string") return null;
+  return `${row.agentId}\0${row.blobId}`;
+}
+function runKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.runId !== "string") return null;
+  return `${row.agentId}\0${row.runId}`;
+}
+function eventKey(row) {
+  if (typeof row.runId !== "string") return null;
+  if (typeof row.seq === "number") return `${row.runId}\0${row.seq}`;
+  if (typeof row.offset === "string") return `${row.runId}\0${row.offset}`;
+  return null;
+}
+function rootBlobId(ref) {
+  if (!isRow(ref) || typeof ref.rootBlobId !== "string" || !ref.rootBlobId) return null;
+  return ref.rootBlobId;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function sameRows(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isRow(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/agents/cursor-store.ts
+var import_node_path16 = require("path");
 var CURSOR_SDK_STORE_DIR = "cursor-sdk-store";
 function cursorSdkStoreDir(threadId) {
-  const root = (0, import_node_path15.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
+  const root = (0, import_node_path16.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
   const id = sanitizeCursorStoreSegment(threadId);
   if (!id) return root;
-  return (0, import_node_path15.join)(root, "threads", id);
+  return (0, import_node_path16.join)(root, "threads", id);
 }
 function sanitizeCursorStoreSegment(threadId) {
   return (threadId ?? "").trim().replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -590,8 +864,8 @@ async function* iterateUntilIdle(iterable, idleMs, onIdle, activity) {
 }
 
 // src/agents/sliced-file-read.ts
-var import_node_fs14 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path17 = require("path");
 var SLICED_READ_DEFAULT_LIMIT = 200;
 var SLICED_READ_MAX_LINE_CHARS = 2e3;
 var SLICED_READ_DESCRIPTION = "Read a text file. Defaults to 200 lines (and a small char budget). Pass offset (1-based) + limit to continue \u2014 never request the whole file when it is large.";
@@ -615,18 +889,18 @@ var SLICED_READ_INPUT_SCHEMA = {
 };
 function realpathOrSelf(path) {
   try {
-    return (0, import_node_fs14.realpathSync)(path);
+    return (0, import_node_fs15.realpathSync)(path);
   } catch {
-    return (0, import_node_path16.resolve)(path);
+    return (0, import_node_path17.resolve)(path);
   }
 }
 function isOutsideWorktree(root, abs) {
-  const rel = (0, import_node_path16.relative)(root, abs);
-  return rel === ".." || rel.startsWith(`..${import_node_path16.sep}`) || (0, import_node_path16.isAbsolute)(rel);
+  const rel = (0, import_node_path17.relative)(root, abs);
+  return rel === ".." || rel.startsWith(`..${import_node_path17.sep}`) || (0, import_node_path17.isAbsolute)(rel);
 }
 function resolveWithinCwd(cwd, input) {
   const root = realpathOrSelf(cwd);
-  const abs = (0, import_node_path16.isAbsolute)(input) ? (0, import_node_path16.resolve)(input) : (0, import_node_path16.resolve)(root, input);
+  const abs = (0, import_node_path17.isAbsolute)(input) ? (0, import_node_path17.resolve)(input) : (0, import_node_path17.resolve)(root, input);
   if (isOutsideWorktree(root, abs)) {
     throw new Error(`Path is outside the worktree: ${input}`);
   }
@@ -663,9 +937,9 @@ function executeSlicedFileRead(cwd, args) {
   }
   let buf;
   try {
-    const st = (0, import_node_fs14.statSync)(abs);
+    const st = (0, import_node_fs15.statSync)(abs);
     if (!st.isFile()) return `Error: not a file: ${rawPath}`;
-    buf = (0, import_node_fs14.readFileSync)(abs);
+    buf = (0, import_node_fs15.readFileSync)(abs);
   } catch (err) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -745,14 +1019,14 @@ function parseRpcFrame(raw) {
 }
 
 // src/agent-rpc/metadata.ts
-var import_node_fs15 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path18 = require("path");
 function agentRuntimeMetadataPath() {
-  return (0, import_node_path17.join)(appDataDir(), "agent-runtime.json");
+  return (0, import_node_path18.join)(appDataDir(), "agent-runtime.json");
 }
 function readAgentRuntimeMetadata() {
   try {
-    const raw = JSON.parse((0, import_node_fs15.readFileSync)(agentRuntimeMetadataPath(), "utf8"));
+    const raw = JSON.parse((0, import_node_fs16.readFileSync)(agentRuntimeMetadataPath(), "utf8"));
     if (!raw || typeof raw !== "object") return null;
     const rec = raw;
     if (typeof rec.runtimeId !== "string" || !rec.runtimeId.trim()) return null;
@@ -1078,8 +1352,8 @@ function sideboardCursorRpcTools(opts) {
 }
 
 // src/agents/tool-result-clip.ts
-var import_node_fs16 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs17 = require("fs");
+var import_node_path19 = require("path");
 
 // src/paths/workspace-scratch.ts
 var CLI_DIR = ".context/cli";
@@ -1088,15 +1362,15 @@ var CLI_DIR = ".context/cli";
 function spillPath(cwd, prefix) {
   const stamp = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   const safe = prefix.replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "tool";
-  return (0, import_node_path18.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
+  return (0, import_node_path19.join)(cwd, CLI_DIR, `${safe}-${stamp}.txt`);
 }
 function spillToolResultToCli(content, opts) {
   const cwd = opts?.cwd?.trim();
   if (!cwd || !content) return null;
   const file = spillPath(cwd, opts?.prefix ?? "tool-result");
   try {
-    (0, import_node_fs16.mkdirSync)((0, import_node_path18.join)(cwd, CLI_DIR), { recursive: true });
-    (0, import_node_fs16.writeFileSync)(file, content, "utf8");
+    (0, import_node_fs17.mkdirSync)((0, import_node_path19.join)(cwd, CLI_DIR), { recursive: true });
+    (0, import_node_fs17.writeFileSync)(file, content, "utf8");
     return file;
   } catch {
     return null;
@@ -1507,7 +1781,7 @@ function emit(event) {
 }
 function localAgentStore(Store, threadId) {
   const root = cursorSdkStoreDir(threadId);
-  (0, import_node_fs17.mkdirSync)(root, { recursive: true });
+  (0, import_node_fs18.mkdirSync)(root, { recursive: true });
   return new Store(root);
 }
 async function cancelStaleRuns(Agent, agentId, opts) {
@@ -1597,6 +1871,9 @@ async function main() {
     fast: Boolean(req.fast)
   });
   const mode = req.planMode ? "plan" : "agent";
+  const storeRoot = cursorSdkStoreDir(req.threadId);
+  const note = (line) => emit({ type: "stderr", data: line });
+  await openCursorCatalogTurn(storeRoot, note);
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
   let onRpcProgress = () => {
@@ -1645,20 +1922,22 @@ async function main() {
   async function createAgent() {
     return retryTransport(() => Agent.create(createOpts));
   }
+  function resumeAgent(agentId) {
+    const { name: _name, ...opts } = createOpts;
+    return retryTransport(() => Agent.resume(agentId, opts));
+  }
   async function openAgent() {
     try {
-      return req.agentId ? await retryTransport(
-        () => Agent.resume(req.agentId, {
-          apiKey,
-          model,
-          mode,
-          local,
-          disallowedTools: ["read"],
-          ...mcpServers ? { mcpServers } : {}
-        })
-      ) : await createAgent();
+      return req.agentId ? await resumeAgent(req.agentId) : await createAgent();
     } catch (err) {
       if (!isUnresumableCursorSession(err)) throw err;
+      if (repairCursorCatalogForResume(storeRoot, note) && req.agentId) {
+        try {
+          return await resumeAgent(req.agentId);
+        } catch (err2) {
+          if (!isUnresumableCursorSession(err2)) throw err2;
+        }
+      }
       emit({
         type: "stderr",
         data: cursorSessionRecoveryMessage(err, req.agentId)
@@ -1712,7 +1991,9 @@ async function main() {
       new Promise((resolve2) => {
         setTimeout(resolve2, 2e3);
       })
-    ]).finally(() => process.exit(1));
+    ]).finally(() => {
+      void closeCursorCatalogTurn().finally(() => process.exit(1));
+    });
   };
   process.once("SIGTERM", onSignal);
   process.once("SIGINT", onSignal);
@@ -1810,11 +2091,21 @@ async function main() {
           return await runTurn(agent);
         }
         if (!isUnresumableCursorSession(err)) throw err;
+        const agentId = agent.agentId;
+        await agent[Symbol.asyncDispose]().catch(() => void 0);
+        const repaired = repairCursorCatalogForResume(storeRoot, note);
+        if (repaired) {
+          try {
+            agent = await resumeAgent(agentId);
+            return await runTurn(agent);
+          } catch (err2) {
+            if (!isUnresumableCursorSession(err2)) throw err2;
+          }
+        }
         emit({
           type: "stderr",
-          data: cursorSessionRecoveryMessage(err, agent.agentId)
+          data: cursorSessionRecoveryMessage(err, agentId)
         });
-        await agent[Symbol.asyncDispose]().catch(() => void 0);
         agent = await createAgent();
         return await runTurn(agent);
       }
@@ -1832,6 +2123,8 @@ async function main() {
     const message = err instanceof Error ? err.message : String(err);
     emit({ type: "stderr", data: message });
     return 1;
+  } finally {
+    await closeCursorCatalogTurn();
   }
 }
 main().then(