@buildautomaton/cli 0.1.73 → 0.1.74

package/dist/index.js

@@ -26497,8 +26497,8 @@ var init_task_queue_types = __esm({
 });
 
 // src/code-nav/symbol-index/scheduler/task-queue-store.ts
-function setSymbolIndexWorkerRunning(running) {
-  symbolIndexWorkerRunning = running;
+function setSymbolIndexWorkerRunning(running2) {
+  symbolIndexWorkerRunning = running2;
 }
 function taskMatchesCurrentPending(task) {
   const current = pendingSymbolIndexTasks.get(symbolIndexTaskKey(task.parentPath, task.filePath));
@@ -30606,7 +30606,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.73".length > 0 ? "0.1.73" : "0.0.0-dev";
+var CLI_VERSION = "0.1.74".length > 0 ? "0.1.74" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -34524,6 +34524,7 @@ function extractSessionUpdateMessageText(params) {
 }
 
 // src/agents/planning/planning-session-turn-buffer.ts
+var MAX_PLANNING_BUFFER_CHARS = 512 * 1024;
 var buffersByRunId = /* @__PURE__ */ new Map();
 function registerPlanningSessionTurn(runId) {
   buffersByRunId.set(runId, { messageBuffer: "" });
@@ -34541,7 +34542,10 @@ function capturePlanningSessionUpdate(params) {
   });
   if (bucket !== "message") return false;
   const text = extractSessionUpdateMessageText(params.payload);
-  if (text) state.messageBuffer += text;
+  if (text && state.messageBuffer.length < MAX_PLANNING_BUFFER_CHARS) {
+    const room = MAX_PLANNING_BUFFER_CHARS - state.messageBuffer.length;
+    state.messageBuffer += room >= text.length ? text : text.slice(0, room);
+  }
   return true;
 }
 function getPlanningSessionTurnOutput(runId) {
@@ -36606,11 +36610,30 @@ function closeHttpServer(server) {
 }
 
 // src/mcp/bridge-access/read-json-body.ts
+var MAX_JSON_BODY_BYTES = 1024 * 1024;
+var RequestBodyTooLargeError = class extends Error {
+  constructor() {
+    super(`Request body exceeds ${MAX_JSON_BODY_BYTES} bytes`);
+  }
+};
 function readJsonBody(req) {
   return new Promise((resolve35, reject) => {
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    let total = 0;
+    let tooLarge = false;
+    req.on("data", (chunk) => {
+      if (tooLarge) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += buf.length;
+      if (total > MAX_JSON_BODY_BYTES) {
+        tooLarge = true;
+        reject(new RequestBodyTooLargeError());
+        return;
+      }
+      chunks.push(buf);
+    });
     req.on("end", () => {
+      if (tooLarge) return;
       try {
         const raw = Buffer.concat(chunks).toString("utf8").trim();
         if (!raw) {
@@ -36667,7 +36690,7 @@ function createBridgeAccessRequestHandler(registry2) {
         sendJsonResponse(res, 404, { ok: false, error: "Not found" });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        sendJsonResponse(res, 500, { ok: false, error: message });
+        sendJsonResponse(res, err instanceof RequestBodyTooLargeError ? 413 : 500, { ok: false, error: message });
       }
     })();
   };
@@ -46941,7 +46964,7 @@ init_yield_to_event_loop();
 
 // src/files/read/types.ts
 var LINE_CHUNK_SIZE = 64 * 1024;
-var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
+var READ_RANGE_YIELD_EVERY_BYTES = 64 * 1024;
 
 // src/files/read/guess-mime-type.ts
 var MIME_BY_EXT = {
@@ -48747,16 +48770,8 @@ var handleAgentConfigMessage = (msg, deps) => {
   handleBridgeAgentConfig(msg, deps);
 };
 
-// src/prompt-turn-queue/client-report.ts
-function sendPromptQueueClientReport(ws, queues) {
-  if (!ws) return false;
-  const wireQueues = {};
-  for (const [queueKey, rows] of Object.entries(queues)) {
-    wireQueues[queueKey] = rows.map((r) => ({ turnId: r.turnId, clientState: r.cliState }));
-  }
-  sendWsMessage(ws, { type: "prompt_queue_client_report", queues: wireQueues });
-  return true;
-}
+// src/prompt-turn-queue/runner/dispatch-started-prompt-queue-runs.ts
+init_yield_to_event_loop();
 
 // src/prompt-turn-queue/disk-store.ts
 init_cli_database();
@@ -48848,23 +48863,6 @@ function dispatchLocalPrompt(next, deps) {
   handleBridgePrompt(msg, deps);
 }
 
-// src/prompt-turn-queue/runner/queue-selection.ts
-function pickNextRunnableTurn(turns) {
-  for (const t of turns) {
-    if (t.bridgeServerState === "discarded" || t.bridgeServerState === "stopping") continue;
-    if (t.bridgeServerState === "cancel_requested") continue;
-    if (!isRunnableBridgePromptTurnServerState(t.bridgeServerState)) continue;
-    if (t.lastCliState === "running" || t.lastCliState === "stopped" || t.lastCliState === "failed" || t.lastCliState === "cancelled") {
-      continue;
-    }
-    return t;
-  }
-  return null;
-}
-function hasRunningTurn(turns) {
-  return turns.some((t) => t.lastCliState === "running");
-}
-
 // src/prompt-turn-queue/runner/run-id-queue-key-map.ts
 var runIdToQueueKey = /* @__PURE__ */ new Map();
 function getRunIdQueueKey(runId) {
@@ -48879,9 +48877,121 @@ function deleteRunIdQueueKey(runId) {
   return queueKey;
 }
 function syncRunningTurnQueueKeys(turns, queueKey) {
-  for (const running of turns.filter((t) => t.lastCliState === "running")) {
-    runIdToQueueKey.set(running.turnId, queueKey);
+  for (const running2 of turns.filter((t) => t.lastCliState === "running")) {
+    runIdToQueueKey.set(running2.turnId, queueKey);
+  }
+}
+
+// src/prompt-turn-queue/runner/dispatch-started-prompt-queue-runs.ts
+async function dispatchStartedPromptQueueRuns(entries, started, deps) {
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    const running2 = file2?.turns.find((turn) => turn.lastCliState === "running");
+    if (running2 && started.has(running2.turnId) && getRunIdQueueKey(running2.turnId) === queueKey) {
+      dispatchLocalPrompt(running2, deps);
+    }
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/handle-prompt-queue-cancellations.ts
+init_yield_to_event_loop();
+
+// src/prompt-turn-queue/client-report.ts
+function sendPromptQueueClientReport(ws, queues) {
+  if (!ws) return false;
+  const wireQueues = {};
+  for (const [queueKey, rows] of Object.entries(queues)) {
+    wireQueues[queueKey] = rows.map((r) => ({ turnId: r.turnId, clientState: r.cliState }));
+  }
+  sendWsMessage(ws, { type: "prompt_queue_client_report", queues: wireQueues });
+  return true;
+}
+
+// src/prompt-turn-queue/runner/finalize-prompt-turn-on-bridge.ts
+async function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
+  if (!runId) return false;
+  const queueKey = deleteRunIdQueueKey(runId);
+  if (!queueKey) return false;
+  const f = await readPersistedQueue(queueKey);
+  if (!f) return false;
+  const t = f.turns.find((x) => x.turnId === runId);
+  if (!t) return false;
+  t.lastCliState = opts?.terminalCliState ?? (success2 ? "stopped" : "failed");
+  await writePersistedQueue(f);
+  sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, cliState: t.lastCliState }] });
+  return true;
+}
+
+// src/prompt-turn-queue/runner/handle-prompt-queue-cancellations.ts
+async function handlePromptQueueCancellations(entries, deps) {
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    const turn = file2?.turns.find((row) => row.bridgeServerState === "cancel_requested" && row.lastCliState === "running");
+    if (!turn) {
+      await yieldToEventLoop();
+      continue;
+    }
+    deps.log(`[Queue] Cancellation request received for turn ${turn.turnId.slice(0, 8)}\u2026`);
+    if (await deps.acpManager.cancelRun(turn.turnId)) {
+      await yieldToEventLoop();
+      continue;
+    }
+    deps.log(`[Queue] cancel_requested for ${turn.turnId.slice(0, 8)}\u2026 with no local run; marking cancelled.`);
+    await finalizePromptTurnOnBridge(deps.getWs, turn.turnId, false, { terminalCliState: "cancelled" });
+    const ws = deps.getWs();
+    if (ws && turn.sessionId) {
+      sendWsMessage(ws, {
+        type: "prompt_result",
+        sessionId: turn.sessionId,
+        runId: turn.turnId,
+        success: false,
+        error: "Stopped by user",
+        stopReason: "cancelled"
+      });
+    }
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/persist-prompt-queue-snapshot.ts
+init_yield_to_event_loop();
+async function persistPromptQueueSnapshot(entries) {
+  for (const [queueKey, serverTurns] of entries) {
+    const file2 = await mergeBridgeServerQueueSnapshot(queueKey, serverTurns);
+    await writePersistedQueue(file2);
+    await yieldToEventLoop();
+  }
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    if (file2) syncRunningTurnQueueKeys(file2.turns, queueKey);
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/prompt-queue-snapshot-types.ts
+function promptQueueSnapshotEntries(queues) {
+  return Object.entries(queues).filter((entry) => Array.isArray(entry[1]));
+}
+
+// src/prompt-turn-queue/runner/start-prompt-queue-runs.ts
+init_yield_to_event_loop();
+
+// src/prompt-turn-queue/runner/queue-selection.ts
+function pickNextRunnableTurn(turns) {
+  for (const t of turns) {
+    if (t.bridgeServerState === "discarded" || t.bridgeServerState === "stopping") continue;
+    if (t.bridgeServerState === "cancel_requested") continue;
+    if (!isRunnableBridgePromptTurnServerState(t.bridgeServerState)) continue;
+    if (t.lastCliState === "running" || t.lastCliState === "stopped" || t.lastCliState === "failed" || t.lastCliState === "cancelled") {
+      continue;
+    }
+    return t;
   }
+  return null;
+}
+function hasRunningTurn(turns) {
+  return turns.some((t) => t.lastCliState === "running");
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
@@ -49001,96 +49111,41 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   return res.ok;
 }
 
-// src/prompt-turn-queue/runner/finalize-prompt-turn-on-bridge.ts
-async function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
-  if (!runId) return false;
-  const queueKey = deleteRunIdQueueKey(runId);
-  if (!queueKey) return false;
-  const f = await readPersistedQueue(queueKey);
-  if (!f) return false;
-  const t = f.turns.find((x) => x.turnId === runId);
-  if (!t) return false;
-  t.lastCliState = opts?.terminalCliState ?? (success2 ? "stopped" : "failed");
-  await writePersistedQueue(f);
-  sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, cliState: t.lastCliState }] });
-  return true;
-}
-
-// src/prompt-turn-queue/runner/apply-prompt-queue-state-from-server.ts
-async function applyPromptQueueStateFromServer(msg, deps) {
-  const raw = msg.queues;
-  if (!raw || typeof raw !== "object") return;
-  const getWs = deps.getWs;
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await mergeBridgeServerQueueSnapshot(queueKey, serverTurns);
-    await writePersistedQueue(file2);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    syncRunningTurnQueueKeys(file2.turns, queueKey);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    const cancelRow = file2.turns.find((t) => t.bridgeServerState === "cancel_requested" && t.lastCliState === "running");
-    if (cancelRow) {
-      const localCancelHandled = await deps.acpManager.cancelRun(cancelRow.turnId);
-      if (!localCancelHandled) {
-        deps.log(
-          `[Queue] bridge server cancel_requested for ${cancelRow.turnId.slice(0, 8)}\u2026 but no local agent run is active (e.g. after CLI restart); marking cancelled and notifying bridge.`
-        );
-        await finalizePromptTurnOnBridge(deps.getWs, cancelRow.turnId, false, { terminalCliState: "cancelled" });
-        const ws = deps.getWs();
-        if (ws && cancelRow.sessionId) {
-          sendWsMessage(ws, {
-            type: "prompt_result",
-            sessionId: cancelRow.sessionId,
-            runId: cancelRow.turnId,
-            success: false,
-            error: "Stopped by user",
-            stopReason: "cancelled"
-          });
-        }
-      }
-    }
-  }
+// src/prompt-turn-queue/runner/start-prompt-queue-runs.ts
+async function startPromptQueueRuns(entries, deps) {
   const report = {};
-  const startedThisTick = /* @__PURE__ */ new Set();
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
+  const started = /* @__PURE__ */ new Set();
+  for (const [queueKey] of entries) {
     const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    if (hasRunningTurn(file2.turns)) continue;
+    if (!file2 || hasRunningTurn(file2.turns)) continue;
     const next = pickNextRunnableTurn(file2.turns);
     if (!next) continue;
     if (!await runLocalRevertBeforeQueuedPrompt(next, deps)) {
       next.lastCliState = "failed";
       await writePersistedQueue(file2);
-      sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: next.turnId, cliState: "failed" }] });
+      sendPromptQueueClientReport(deps.getWs(), { [queueKey]: [{ turnId: next.turnId, cliState: "failed" }] });
       continue;
     }
     next.lastCliState = "running";
     await writePersistedQueue(file2);
     setRunIdQueueKey(next.turnId, queueKey);
-    startedThisTick.add(next.turnId);
+    started.add(next.turnId);
     report[queueKey] = [{ turnId: next.turnId, cliState: "running" }];
+    await yieldToEventLoop();
   }
-  if (Object.keys(report).length > 0) {
-    sendPromptQueueClientReport(getWs(), report);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    const running = file2.turns.find((t) => t.lastCliState === "running");
-    if (!running || !startedThisTick.has(running.turnId)) continue;
-    if (getRunIdQueueKey(running.turnId) !== queueKey) continue;
-    dispatchLocalPrompt(running, deps);
-  }
+  if (Object.keys(report).length) sendPromptQueueClientReport(deps.getWs(), report);
+  return started;
+}
+
+// src/prompt-turn-queue/runner/apply-prompt-queue-state-from-server.ts
+async function applyPromptQueueStateFromServer(msg, deps) {
+  const raw = msg.queues;
+  if (!raw || typeof raw !== "object") return;
+  const entries = promptQueueSnapshotEntries(raw);
+  await persistPromptQueueSnapshot(entries);
+  await handlePromptQueueCancellations(entries, deps);
+  const started = await startPromptQueueRuns(entries, deps);
+  await dispatchStartedPromptQueueRuns(entries, started, deps);
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-wiring.ts
@@ -49356,10 +49411,34 @@ var handlePromptMessage = (msg, deps) => {
   handleBridgePrompt(msg, deps);
 };
 
+// src/prompt-turn-queue/runner/serial-prompt-queue-work.ts
+var running = false;
+var latestWork = null;
+async function drain() {
+  while (latestWork) {
+    const work = latestWork;
+    latestWork = null;
+    await work();
+  }
+}
+function enqueueLatestPromptQueueStateWork(work) {
+  latestWork = work;
+  if (running) return;
+  running = true;
+  void drain().finally(() => {
+    running = false;
+    if (latestWork) enqueueLatestPromptQueueStateWork(latestWork);
+  });
+}
+
 // src/routing/handlers/prompt-queue-state.ts
 var handlePromptQueueStateMessage = (msg, deps) => {
-  void applyPromptQueueStateFromServer(msg, deps).catch((err) => {
-    deps.log(`[Queue] applyPromptQueueStateFromServer failed: ${err instanceof Error ? err.message : String(err)}`);
+  enqueueLatestPromptQueueStateWork(async () => {
+    try {
+      await applyPromptQueueStateFromServer(msg, deps);
+    } catch (err) {
+      deps.log(`[Queue] applyPromptQueueStateFromServer failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
   });
 };