@buildautomaton/cli 0.1.72 → 0.1.74

package/dist/cli.js

@@ -11850,8 +11850,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));
@@ -31064,7 +31064,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.72".length > 0 ? "0.1.72" : "0.0.0-dev";
+var CLI_VERSION = "0.1.74".length > 0 ? "0.1.74" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -35985,12 +35985,32 @@ function attachSdkStdioStderrAuthWatch(options) {
 
 // src/agents/acp/clients/sdk/spawn-sdk-stdio-process.ts
 import { spawn } from "node:child_process";
+
+// src/agents/acp/clients/bridge-installed-agent-auth-env.ts
+var authEnv = /* @__PURE__ */ new Map();
+function setBridgeInstalledAgentAuthEnv(entries) {
+  authEnv.clear();
+  for (const entry of entries) {
+    const envVar = typeof entry.envVar === "string" ? entry.envVar.trim() : "";
+    const token = typeof entry.token === "string" ? entry.token.trim() : "";
+    if (envVar && token) authEnv.set(envVar, token);
+  }
+}
+function bridgeInstalledAgentAuthProcessEnv(base = process.env) {
+  if (authEnv.size === 0) return base;
+  return { ...base, ...Object.fromEntries(authEnv) };
+}
+function cursorAgentUsesApiKeyAuth(env = process.env) {
+  return Boolean(env.CURSOR_API_KEY?.trim() || env.CURSOR_AUTH_TOKEN?.trim());
+}
+
+// src/agents/acp/clients/sdk/spawn-sdk-stdio-process.ts
 function spawnSdkStdioProcess(options) {
   const isWindows = process.platform === "win32";
   const child = spawn(options.command[0], options.command.slice(1), {
     cwd: options.cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: process.env,
+    env: bridgeInstalledAgentAuthProcessEnv(process.env),
     shell: isWindows
   });
   const stderrCapture = createStderrCapture(child);
@@ -36450,10 +36470,11 @@ function createCursorAcpIncomingLineHandler(deps) {
 
 // src/agents/acp/clients/cursor/cursor-json-rpc-acp-transport.ts
 function createCursorJsonRpcAcpTransport(deps) {
-  const { send, cancelSessionNotification } = deps;
+  const { send, cancelSessionNotification, skipBrowserAuthenticate } = deps;
   return {
     initialize: (request) => send("initialize", request),
     afterInitialize: async () => {
+      if (skipBrowserAuthenticate) return;
       await send("authenticate", { methodId: "cursor_login" });
     },
     resumeSession: (p) => send("session/resume", p),
@@ -36562,7 +36583,8 @@ async function initCursorAcpWire(options) {
   rl.on("line", (line) => incoming.handleLine(line));
   const transport = createCursorJsonRpcAcpTransport({
     send: wire.send,
-    cancelSessionNotification: wire.cancelSessionNotification
+    cancelSessionNotification: wire.cancelSessionNotification,
+    skipBrowserAuthenticate: options.skipBrowserAuthenticate
   });
   const established = await bootstrapAcpWireSession(transport, options.sessionCtx, CURSOR_ACP_CLIENT_INFO);
   return { wire, transport, established, incoming, pendingRequests: pendingRequests2 };
@@ -36575,7 +36597,7 @@ function spawnCursorAcpProcess(options) {
   const child = spawn2(options.command[0], options.command.slice(1), {
     cwd: options.cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: process.env,
+    env: bridgeInstalledAgentAuthProcessEnv(process.env),
     shell: isWindows
   });
   const stderrCapture = createStderrCapture(child);
@@ -36607,11 +36629,13 @@ async function createCursorAcpClient(options) {
     onAgentSubprocessExit
   } = options;
   const dbgFs = process.env.BUILDAUTOMATON_DEBUG_ACP_FS === "1";
+  const spawnEnv = bridgeInstalledAgentAuthProcessEnv(process.env);
   const { child, stderrCapture } = spawnCursorAcpProcess({
     command,
     cwd,
     onAgentSubprocessExit
   });
+  const skipBrowserAuthenticate = cursorAgentUsesApiKeyAuth(spawnEnv);
   const sessionCtx = createCursorAcpSessionContext({
     cwd,
     mcpServers: options.mcpServers,
@@ -36634,6 +36658,7 @@ async function createCursorAcpClient(options) {
         const { wire, transport, established, incoming, pendingRequests: pendingRequests2 } = await initCursorAcpWire({
           child,
           sessionCtx,
+          skipBrowserAuthenticate,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
         resolve37(
@@ -37480,6 +37505,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: "" });
@@ -37497,7 +37523,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) {
@@ -39391,11 +39420,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((resolve37, 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) {
@@ -39452,7 +39500,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 });
       }
     })();
   };
@@ -49962,7 +50010,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 = {
@@ -51554,6 +51602,7 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
 var API_TO_BRIDGE_MESSAGE_TYPES = [
   "auth_token",
   "bridge_identified",
+  "installed_agent_auth_sync",
   "ha",
   "preview_environments_config",
   "preview_environment_control",
@@ -51642,6 +51691,16 @@ var handleBridgeIdentified = (msg, deps) => {
   });
 };
 
+// src/routing/handlers/installed-agent-auth-sync.ts
+var handleInstalledAgentAuthSync = (msg) => {
+  const entries = Array.isArray(msg.entries) ? msg.entries : [];
+  setBridgeInstalledAgentAuthEnv(
+    entries.filter(
+      (e) => e != null && typeof e === "object" && typeof e.envVar === "string" && typeof e.token === "string"
+    )
+  );
+};
+
 // src/connection/heartbeat/ack.ts
 var handleBridgeHeartbeatAck = (msg, deps) => {
   const raw = msg.s;
@@ -51658,6 +51717,9 @@ function dispatchBridgeConnectionMessage(msg, deps) {
     case "bridge_identified":
       handleBridgeIdentified(msg, deps);
       break;
+    case "installed_agent_auth_sync":
+      handleInstalledAgentAuthSync(msg, deps);
+      break;
     case "ha":
       handleBridgeHeartbeatAck(msg, deps);
       break;
@@ -51754,16 +51816,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();
@@ -51855,23 +51909,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) {
@@ -51886,11 +51923,123 @@ 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
 import fs59 from "node:fs";
 
@@ -52008,96 +52157,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
@@ -52363,10 +52457,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)}`);
+    }
   });
 };
 
@@ -53512,6 +53630,7 @@ function dispatchBridgeMessage(msg, deps) {
   switch (msg.type) {
     case "auth_token":
     case "bridge_identified":
+    case "installed_agent_auth_sync":
     case "ha":
       dispatchBridgeConnectionMessage(msg, deps);
       break;