@botbuddy/cli 1.43.0 → 1.43.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.43.0",
+  "version": "1.43.1",
   "description": "BotBuddy — Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/stack.mjs

@@ -60,6 +60,13 @@ const CALLBACK_PORT_REMOTE_REFUSAL =
   "(pre-forward GatewayPorts probe). Use --local-only for a run that needs a callback port.";
 export const DEFAULT_RECEIPT_MAX_BYTES = 10240;
 export const DEFAULT_TIMEOUT_SEC = 3600;
+/**
+ * BOT-2154: how long `stack up --local-exec` lets `supabase start` run before it gives up and
+ * releases the lease itself (`--provision-timeout` overrides). Deliberately below the server's
+ * 1200 s `local_exec_provision_ttl_secs` backstop, so the CLI's own clean `stack done` wins the
+ * race against the reaper.
+ */
+export const LOCAL_EXEC_PROVISION_TIMEOUT_SEC = 900;
 /** BOT-2230: the bounds the control plane enforces on an owner place hold (hold_stack_lease_place). */
 export const HOLD_ON_TIMEOUT_MIN_SEC = 60;
 export const HOLD_ON_TIMEOUT_MAX_SEC = 14400;
@@ -122,6 +129,10 @@ ${bold("up OPTIONS")}
                          deadline (exit 2) and a failed wait (its own exit code) never retry.
   --local-exec           FALLBACK (no Helper): run 'supabase start' in an ISOLATED --stack-path
                          stack and self-activate. Refused at the worktree root (shared stack).
+  --provision-timeout N  LOCAL-EXEC: seconds 'supabase start' may run (default ${LOCAL_EXEC_PROVISION_TIMEOUT_SEC}). On
+                         timeout up runs 'stack done --local-exec' itself and exits 6 with
+                         park_reason provision_timeout (BOT-2154). The server also fails a local-exec
+                         lease still provisioning after local_exec_provision_ttl_secs (default 1200).
                          Refused (exit 4, ENGINE_PUBLISHES_BEYOND_LOOPBACK) when the Docker
                          engine would publish the stack's ports beyond loopback (BOT-2146).
   --docker-context <name> Explicit Docker context for the mandatory local preflight
@@ -1851,7 +1862,16 @@ export function localProvision(opts, dockerTarget, execution, spawn = spawnSync,
   const url = resolveIsolatedStackApiUrl(stackDir, env);
   const spawnEnv = { ...dockerEnvForTarget(dockerTarget, env), VITE_SUPABASE_URL: url };
   process.stderr.write(`${yellow("⚠ LOCAL-EXEC FALLBACK")} — no BotBuddy Helper; running ${bold("supabase start")} in ${stackDir} (VITE_SUPABASE_URL=${url}).\n`);
-  const start = spawn("supabase", ["start", "--workdir", stackDir], { encoding: "utf8", env: spawnEnv });
+  // BOT-2154: never an unbounded start — a hung `supabase start` held the host slot for hours.
+  const timeoutSec = opts?.provisionTimeout ?? LOCAL_EXEC_PROVISION_TIMEOUT_SEC;
+  const start = spawn("supabase", ["start", "--workdir", stackDir], {
+    encoding: "utf8", env: spawnEnv, timeout: timeoutSec * 1000, killSignal: "SIGTERM",
+  });
+  if (start.error?.code === "ETIMEDOUT") {
+    const timedOut = new Error(`supabase start did not finish within ${timeoutSec}s (--provision-timeout); stopping it and releasing the lease`);
+    timedOut.code = "PROVISION_TIMEOUT";
+    throw timedOut;
+  }
   if (start.status !== 0) {
     throw new Error(`supabase start failed (${start.status}): ${(start.stderr || start.stdout || "").slice(0, 400)}`);
   }
@@ -1942,11 +1962,21 @@ function emit(receipt, opts, code) {
 
 // ── command orchestration ────────────────────────────────────────────────────
 
+/** BOT-2154: run `stack done` in-process and capture its receipt instead of printing it, so
+ * `stack up` still emits exactly one receipt. */
+async function runLocalDone(leaseId, opts, deps = {}) {
+  let receipt = null;
+  const exitCode = await cmdDone(leaseId, opts, { ...deps, emitResult: (r, _o, code) => { receipt = r; return code; } });
+  return { exitCode, receipt };
+}
+
 export async function cmdUp(opts, {
   runPreflight = runLocalExecPreflight,
   callTool = callToolJson,
   authProvider = stackAuthHeader,
   localProvisionFn = localProvision,
+  // BOT-2154: the self-release after a timed-out local start (`stack done --local-exec`).
+  localDoneFn = null,
   waitFn = waitForLease,
   emitResult = emit,
   machineUuidFn = machineUuid,
@@ -2278,6 +2308,21 @@ export async function cmdUp(opts, {
         try {
           conn = connectionWithDockerTarget(localProvisionFn(opts, localDockerTarget, execution), localDockerTarget);
         } catch (e) {
+          if (e?.code === "PROVISION_TIMEOUT") {
+            // BOT-2154: a bounded start that ran out of time. Release the lease ourselves —
+            // `stack done --local-exec` stops whatever the start left behind and reaps the lease
+            // — instead of leaving it provisioning for the server's backstop to find.
+            const done = await (localDoneFn ?? ((id, doneOpts) => runLocalDone(id, doneOpts, { callTool, authProvider })))(
+              leaseId, { ...opts, localExec: true, disposition: "destroy", json: false });
+            const doneReceipt = done?.receipt ?? {};
+            const cleaned = done?.exitCode === 0;
+            return emitResult(buildReceipt({
+              command: "up", outcome: "timeout", code: "PROVISION_TIMEOUT", park_reason: "provision_timeout",
+              lease_id: leaseId, slot, error: e.message, cleanup: cleaned,
+              done: { outcome: doneReceipt.outcome ?? null, state: doneReceipt.state ?? null, exit_code: done?.exitCode ?? null },
+              ...(cleaned ? {} : { cleanup_error: doneReceipt.error ?? `stack done --local-exec exited ${done?.exitCode}` }),
+            }), opts, EXIT.LEASE_FAILED);
+          }
           // Once the local provisioner has run, `supabase start` may have created
           // (or fully started) containers even on a nonzero exit or a status-parse
           // failure. Cancelling here would reap the lease and free the slot while