@botbuddy/cli 1.19.0 → 1.19.1

package/package.json

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

package/src/stack.mjs

@@ -665,6 +665,7 @@ export async function cmdUp(opts, {
   callTool = callToolJson,
   authProvider = stackAuthHeader,
   localProvisionFn = localProvision,
+  waitFn = waitForLease,
   emitResult = emit,
 } = {}) {
   let slot;
@@ -720,7 +721,7 @@ export async function cmdUp(opts, {
       return emitResult(buildReceipt({ command: "up", outcome: "queued", lease_id: leaseId, state, host_key: d.host_key, slot, queued: true, queue_position: d.queue_position, holders: d.holders }), opts, EXIT.QUEUED);
     }
     // Park zero-poll until the lease leaves the queue (granted in BOT-1187 order).
-    const parked = await waitForLease(leaseId, nonQueued, () => false, { timeoutSec: opts.timeout, auth });
+    const parked = await waitFn(leaseId, nonQueued, () => false, { timeoutSec: opts.timeout, auth });
     if (parked.timeout) return emitResult(buildReceipt({ command: "up", outcome: "timeout", lease_id: leaseId, state: "queued", slot, error: `parked ${opts.timeout}s without capacity` }), opts, EXIT.TIMEOUT);
     if (parked.auth) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: "unauthorized on wait stream" }), opts, EXIT.AUTH);
     if (parked.error) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: parked.error }), opts, EXIT.BACKEND);
@@ -762,36 +763,67 @@ export async function cmdUp(opts, {
         connection: connectionWithDockerTarget({}, localDockerTarget),
       });
       if (!reserved.ok || !reserved.data?.success) {
-        const cancelled = await callTool("cancel_unclaimed_stack_lease", { lease_id: leaseId });
-        const leaseCancellation = cancelled.ok && cancelled.data?.success
-          ? { success: true, state: cancelled.data.state, provision_job_cancelled: cancelled.data.provision_job_cancelled === true }
-          : { success: false, error: cancelled.error || cancelled.data?.code || "atomic cancellation failed" };
-        return emitResult(buildReceipt({
-          command: "up", outcome: "error", lease_id: leaseId, state, slot,
-          error: reserved.data?.code || reserved.error || "could not reserve the provision job for local execution",
-          lease_cancellation: leaseCancellation,
-        }), opts, EXIT.LEASE_FAILED);
-      }
-      let conn;
-      try {
-        conn = connectionWithDockerTarget(localProvisionFn(opts, localDockerTarget), localDockerTarget);
-      } catch (e) {
-        // 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
-        // that stack is still up — the exact orphaned/contended-slot hazard this
-        // change closes. Leave the lease FENCED (provisioning, reserved to us) so
-        // `botbuddy stack done` / the reaper tears the stack down first (BOT-1421
-        // review); do NOT cancel.
-        return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: e.message }), opts, EXIT.LEASE_FAILED);
-      }
-      const act = await callTool("activate_stack_lease", { lease_id: leaseId, connection: conn });
-      if (!act.ok || !act.data?.success) {
-        return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: act.error || act.data?.code || "activate failed" }), opts, EXIT.BACKEND);
+        // A Helper can win the reservation race by taking the queued provision
+        // job between `request_stack_lease` and `reserve_stack_lease`. That is NOT
+        // a failure — nothing local has started, and the Helper owns (or is about
+        // to activate) a live stack for this same lease. Cancelling here would
+        // abandon that stack until idle reaping. Two shapes signal the takeover,
+        // both from `reserve_stack_lease` which checks lease state before job
+        // status (BOT-1587):
+        //   • PROVISION_JOB_HELPER_CLAIMED — Helper claimed the job, lease still
+        //     `provisioning`: wait for it to reach active.
+        //   • LEASE_NOT_PROVISIONING with state `active` — the Helper both claimed
+        //     AND activated before reserve acquired its locks: already live, so
+        //     skip the wait (the edge-triggered stream would park until timeout on
+        //     an already-active lease) and go straight to the read.
+        // Either way, follow the Helper to the shared authoritative final read
+        // below; only a genuine reserve failure is terminal.
+        const helperClaimed = reserved.data?.code === "PROVISION_JOB_HELPER_CLAIMED";
+        const helperAlreadyActive = reserved.data?.code === "LEASE_NOT_PROVISIONING" && reserved.data?.state === "active";
+        if (helperClaimed || helperAlreadyActive) {
+          if (!helperAlreadyActive) {
+            const active = await waitFn(leaseId, isActive, isReaped, { timeoutSec: opts.timeout, auth });
+            if (active.timeout) return emitResult(buildReceipt({ command: "up", outcome: "timeout", lease_id: leaseId, state, slot, error: `a Helper claimed the provision job but it did not reach active in ${opts.timeout}s` }), opts, EXIT.TIMEOUT);
+            if (active.auth) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: "unauthorized on wait stream" }), opts, EXIT.AUTH);
+            if (active.failed) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, state: active.state, error: "lease was reaped before it became active" }), opts, EXIT.LEASE_FAILED);
+            if (active.error) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: active.error }), opts, EXIT.BACKEND);
+          }
+          // Fall through to the authoritative `get_stack_lease` read below — do
+          // NOT run the local provisioner; the Helper owns this stack.
+        } else {
+          const cancelled = await callTool("cancel_unclaimed_stack_lease", { lease_id: leaseId });
+          const leaseCancellation = cancelled.ok && cancelled.data?.success
+            ? { success: true, state: cancelled.data.state, provision_job_cancelled: cancelled.data.provision_job_cancelled === true }
+            : { success: false, error: cancelled.error || cancelled.data?.code || "atomic cancellation failed" };
+          return emitResult(buildReceipt({
+            command: "up", outcome: "error", lease_id: leaseId, state, slot,
+            error: reserved.data?.code || reserved.error || "could not reserve the provision job for local execution",
+            lease_cancellation: leaseCancellation,
+          }), opts, EXIT.LEASE_FAILED);
+        }
+      } else {
+        let conn;
+        try {
+          conn = connectionWithDockerTarget(localProvisionFn(opts, localDockerTarget), localDockerTarget);
+        } catch (e) {
+          // 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
+          // that stack is still up — the exact orphaned/contended-slot hazard this
+          // change closes. Leave the lease FENCED (provisioning, reserved to us) so
+          // `botbuddy stack done` / the reaper tears the stack down first (BOT-1421
+          // review); do NOT cancel.
+          return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: e.message }), opts, EXIT.LEASE_FAILED);
+        }
+        const act = await callTool("activate_stack_lease", { lease_id: leaseId, connection: conn });
+        if (!act.ok || !act.data?.success) {
+          return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: act.error || act.data?.code || "activate failed" }), opts, EXIT.BACKEND);
+        }
       }
     } else {
-      const active = await waitForLease(leaseId, isActive, isReaped, { timeoutSec: opts.timeout, auth });
+      const active = await waitFn(leaseId, isActive, isReaped, { timeoutSec: opts.timeout, auth });
       if (active.timeout) return emitResult(buildReceipt({ command: "up", outcome: "timeout", lease_id: leaseId, state, slot, error: `provisioning did not reach active in ${opts.timeout}s (Helper may be down — retry with --local-exec)` }), opts, EXIT.TIMEOUT);
+      if (active.auth) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: "unauthorized on wait stream" }), opts, EXIT.AUTH);
       if (active.failed) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, state: active.state, error: "lease was reaped before it became active" }), opts, EXIT.LEASE_FAILED);
       if (active.error) return emitResult(buildReceipt({ command: "up", outcome: "error", lease_id: leaseId, error: active.error }), opts, EXIT.BACKEND);
     }