@botbuddy/cli 1.29.4 → 1.30.1

package/src/stack.mjs

@@ -31,7 +31,7 @@ import { callToolJson } from "./api.mjs";
 import { SERVER_URL, getConfig } from "./config.mjs";
 import { resolveOwnerToken, resolveAgentKey } from "./cli-credentials.mjs";
 import { AGENT_KEY_RE, readAgentKeyEnv } from "./agent-key.mjs";
-import { runDockerCommand, runDockerWorkflow } from "./docker-hygiene.mjs";
+import { runDockerCommand, runDockerWorkflow, ADMITTED_DOCKER_VALIDATIONS } from "./docker-hygiene.mjs";
 import { machineUuid } from "./machine-id.mjs";
 import { bold, dim, yellow } from "./utils.mjs";
 
@@ -75,15 +75,18 @@ ${bold("up OPTIONS")}
   --timeout <seconds>    Max seconds to park for capacity before giving up (default ${DEFAULT_TIMEOUT_SEC}).
   --no-wait              If the host is full, print the queue position and exit (don't park).
   --local-exec           FALLBACK (no Helper): run 'supabase start' locally and self-activate.
-  --docker-context <name> Explicit OrbStack Docker context for the mandatory local preflight.
-  --docker-endpoint <uri> Explicit OrbStack endpoint instead of --docker-context.
+  --docker-context <name> Explicit Docker context for the mandatory local preflight
+                         (an allowlisted engine: OrbStack or Docker Desktop, e.g. desktop-linux).
+  --docker-endpoint <uri> Explicit Docker endpoint instead of --docker-context.
 
 ${bold("done OPTIONS")}
   --stop                 Keep volumes (cheap re-provision next batch). Default: destroy.
   --local-exec           FALLBACK (no Helper): run 'supabase stop' locally and self-finalize.
-  --docker-context <name> Explicit OrbStack context used by the matching local-exec up.
-  --docker-endpoint <uri> Explicit OrbStack endpoint instead of --docker-context.
-                         Pre-1.5.0 leases also require exact worktree + live connection proof.
+  --docker-context <name> Explicit Docker context used by the matching local-exec up
+                         (OrbStack or Docker Desktop; must match the engine that provisioned the lease).
+  --docker-endpoint <uri> Explicit Docker endpoint instead of --docker-context.
+                         Pre-1.5.0 leases have no persisted target and stay OrbStack-only; they also
+                         require exact worktree + live connection proof.
 
 ${bold("run OPTIONS")}
   --repo <repo>          Required approved repository name.
@@ -528,7 +531,15 @@ export async function runLocalExecTargetCheck(opts, runWorkflow = runDockerWorkf
   const selector = opts.dockerContext
     ? ["--context", opts.dockerContext]
     : ["--endpoint", opts.dockerEndpoint];
-  return runWorkflow(["preflight", ...selector, "--json"]);
+  // BOT-1681 — teardown is an IDENTITY check against the daemon already persisted
+  // on the lease, not a new-admission decision. The BOTBUDDY_DOCKER_ENGINES fleet
+  // override gates PROVISIONING only; honouring it here would reject a still-valid
+  // Docker Desktop lease the moment a host is pinned to orbstack, fencing the lease
+  // and its stack slot forever (Codex P2). Validate against the full engine
+  // allowlist and let dockerTargetsMatch fence the observed daemon to the lease.
+  const env = { ...process.env };
+  delete env.BOTBUDDY_DOCKER_ENGINES;
+  return runWorkflow(["preflight", ...selector, "--json"], { env });
 }
 
 export function dockerEnvForSelector(opts, env = process.env) {
@@ -544,9 +555,14 @@ export function dockerTargetFromPreflight(receipt) {
   const context = receipt?.context;
   const endpoint = context?.resolved_endpoint;
   const serverId = context?.server?.id;
-  if (context?.validation !== "orbstack" || typeof endpoint !== "string" || !endpoint ||
+  const validation = context?.validation;
+  // BOT-1681 — accept any allowlisted engine (orbstack, docker-desktop), not a
+  // hardcoded "orbstack". Carry the real engine label so teardown fences to the
+  // exact engine that provisioned the lease. Fault labels (e.g. orbstack_unavailable)
+  // are not admitted validations, so they still return null.
+  if (!ADMITTED_DOCKER_VALIDATIONS.has(validation) || typeof endpoint !== "string" || !endpoint ||
       typeof serverId !== "string" || !serverId) return null;
-  return { validation: "orbstack", resolved_endpoint: endpoint, server_id: serverId };
+  return { validation, resolved_endpoint: endpoint, server_id: serverId };
 }
 
 export function connectionWithDockerTarget(connection, target) {
@@ -556,8 +572,12 @@ export function connectionWithDockerTarget(connection, target) {
   return { ...(connection || {}), botbuddy_docker_target: { ...target } };
 }
 
-function dockerTargetsMatch(expected, actual) {
-  return expected?.validation === "orbstack" && actual?.validation === "orbstack" &&
+export function dockerTargetsMatch(expected, actual) {
+  // BOT-1681 — the fence is still exact: provision and teardown must agree on the
+  // engine (validation), the resolved endpoint, AND the daemon server_id. Widening
+  // the allowlist must never let a cross-engine or cross-daemon target match.
+  return ADMITTED_DOCKER_VALIDATIONS.has(expected?.validation) &&
+    expected?.validation === actual?.validation &&
     expected.resolved_endpoint === actual.resolved_endpoint && expected.server_id === actual.server_id;
 }
 
@@ -705,12 +725,16 @@ export async function cmdUp(opts, {
     if (checked.exitCode !== 0 || !localDockerTarget) {
       return emitResult(buildReceipt({
         command: "up", outcome: "refused", slot,
-        error: checked.receipt.errors?.[0] || "OrbStack preflight did not return a stable Docker server identity",
+        error: checked.receipt.errors?.[0] || "the local preflight did not return a stable Docker server identity",
         preflight: localPreflight,
       }), opts, EXIT.LEASE_FAILED);
     }
     if (checked.receipt.outcome === "warn") {
-      process.stderr.write(`${yellow("⚠")} stack: OrbStack preflight warns of interface pressure; cleanup is recommended before another stack.\n`);
+      // BOT-1681: surface the engine-aware recommendation (dry-run hygiene is
+      // OrbStack-only) rather than a hardcoded OrbStack cleanup instruction.
+      const engine = checked.receipt.context?.validation === "orbstack" ? "OrbStack" : "Docker";
+      const remedy = checked.receipt.recommendation || "reduce Docker load before starting another stack";
+      process.stderr.write(`${yellow("⚠")} stack: ${engine} preflight warns of network pressure; ${remedy}.\n`);
     }
   }
   const auth = await authProvider();
@@ -926,11 +950,23 @@ export async function cmdDone(leaseId, opts, {
     dockerTarget = dockerTargetFromPreflight(checked.receipt);
     if (expected && !dockerTargetsMatch(expected, dockerTarget)) {
       return emitResult(buildReceipt({ command: "done", outcome: "refused", lease_id: leaseId,
-        error: "teardown Docker target does not exactly match the OrbStack server persisted at provisioning; lease and slot remain fenced",
+        error: "teardown Docker target does not exactly match the Docker daemon persisted at provisioning; lease and slot remain fenced",
         expected_docker_target: expected || null, observed_docker_target: dockerTarget,
       }), opts, EXIT.LEASE_FAILED);
     }
     if (!expected) {
+      // BOT-1681: legacy (pre-1.5.0) leases carry no persisted botbuddy_docker_target,
+      // and proveLegacyLocalExecTarget authorizes teardown from only the worktree +
+      // live API/DB URLs — not the engine. Those leases were created under OrbStack and
+      // the compatibility contract still pins them there, so keep this path OrbStack-only:
+      // a Docker Desktop daemon (newly admitted by the preflight allowlist for MODERN
+      // leases) must never authorize teardown of a targetless legacy OrbStack lease.
+      if (dockerTarget?.validation !== "orbstack") {
+        return emitResult(buildReceipt({ command: "done", outcome: "refused", lease_id: leaseId,
+          error: `pre-1.5.0 lease has no persisted Docker target; only an OrbStack daemon may authorize legacy teardown, not ${dockerTarget?.validation || "an unverified engine"}; lease and slot remain fenced`,
+          expected_docker_target: null, observed_docker_target: dockerTarget,
+        }), opts, EXIT.LEASE_FAILED);
+      }
       const proof = proveLegacyTarget(current.data, dockerTarget, opts);
       if (!proof?.ok) {
         return emitResult(buildReceipt({ command: "done", outcome: "refused", lease_id: leaseId,

package/src/test-lane.mjs

@@ -21,7 +21,8 @@ import { execFileSync } from "node:child_process";
 
 import { EXIT, launchRun, receiptPath, DEFAULT_TIMEOUT_SECONDS } from "./run.mjs";
 import { callToolJson } from "./api.mjs";
-import { readAgentKeyEnv } from "./agent-key.mjs";
+import { readAgentSessionTokenEnv } from "./agent-key.mjs";
+import { clearAgentState, isRejectedCachedMcpSession, resolveAgentSessionCredential } from "./agent-session.mjs";
 
 // EXIT.{OK,INVALID,BACKEND,INTERNAL} plus a --wait timeout code (AC-9).
 export const EXIT_TEST = Object.freeze({ ...EXIT, TIMEOUT: 2 });
@@ -38,9 +39,9 @@ export function parseTestArgs(argv, { env = process.env } = {}) {
   const opts = {
     sessionId: env.BOTBUDDY_SESSION_ID ?? null,
     // BOT-1572/1582 (AC-8): a session token stands in for --session-id; it flows to
-    // the sub-invoked `run`/`wait` which derive the session from it. $BOTBUDDY_AGENT_KEY
-    // is the norm ($BOTBUDDY_SESSION_TOKEN still accepted for one release).
-    sessionToken: readAgentKeyEnv(env),
+    // the sub-invoked `run`/`wait` which derive the session from it.
+    // $BOTBUDDY_AGENT_SESSION_TOKEN is canonical; former names remain aliases.
+    sessionToken: readAgentSessionTokenEnv(env),
     environment: "local",
     ticket: null, pr: null, repo: null,
     laneKind: null,
@@ -57,6 +58,8 @@ export function parseTestArgs(argv, { env = process.env } = {}) {
     const flag = flags[i];
     switch (flag) {
       case "--session-id": opts.sessionId = value(flag, i); i++; break;
+      case "--agent-session-token":
+      case "--agent-key":
       case "--session-token": opts.sessionToken = value(flag, i); i++; break;
       case "--environment": opts.environment = value(flag, i); i++; break;
       case "--ticket": opts.ticket = value(flag, i); i++; break;
@@ -139,11 +142,11 @@ export function defaultGitInfo({ cwd = process.cwd(), ticket = null, pr = null,
 // worker, carrying the telemetry env into its detached child.
 async function defaultLaunchLane({ command, sessionId, sessionToken, environment, expectedDurationSeconds, childEnv, testRun, cwd, call }) {
   // BOT-1572/1582: pass --session-id only when a plain id is used; a token-only lane
-  // relies on the inherited $BOTBUDDY_AGENT_KEY (and an explicit --session-token
+  // relies on the inherited $BOTBUDDY_AGENT_SESSION_TOKEN (and an explicit --agent-session-token
   // so the child never falls back to a machine credential).
   const argv = [
     ...(sessionId ? ["--session-id", sessionId] : []),
-    ...(sessionToken ? ["--session-token", sessionToken] : []),
+    ...(sessionToken ? ["--agent-session-token", sessionToken] : []),
     "--environment", environment, "--category", "validation", "--kind", "full_suite",
     "--expected-duration", String(expectedDurationSeconds ?? 0), "--", ...command,
   ];
@@ -152,7 +155,7 @@ async function defaultLaunchLane({ command, sessionId, sessionToken, environment
 }
 
 function waitCommand(testRunId, sessionId, sessionToken) {
-  // BOT-1572/1582: a token-armed session runs the wait with only $BOTBUDDY_AGENT_KEY.
+  // BOT-1649: a token-armed session runs the wait with only the canonical session token.
   const idFlag = sessionId && !sessionToken ? ` --session-id ${sessionId}` : "";
   return `botbuddy wait 'test-run:id=${testRunId}'${idFlag} --heartbeat`;
 }
@@ -162,6 +165,8 @@ export async function launchTestLane(argv, {
   env = process.env,
   call = callToolJson,
   launchLane = defaultLaunchLane,
+  resolveCredential = null,
+  clearState = clearAgentState,
   gitInfo = defaultGitInfo,
   eventsDir = join(homedir(), ".botbuddy", "test-lanes"),
 } = {}) {
@@ -170,9 +175,24 @@ export async function launchTestLane(argv, {
     for (const e of errors) process.stderr.write(`botbuddy test: ${e}\n`);
     return { exitCode: EXIT_TEST.INVALID, line: JSON.stringify({ outcome: "rejected", errors }) };
   }
+  let managedCredential = null;
   if (!opts.sessionId && !opts.sessionToken) {
-    process.stderr.write("botbuddy test: --session-id is required (or set $BOTBUDDY_SESSION_ID or $BOTBUDDY_AGENT_KEY)\n");
-    return { exitCode: EXIT_TEST.INVALID, line: JSON.stringify({ outcome: "rejected", errors: ["--session-id is required"] }) };
+    // Test doubles intentionally do not self-mint. The shipped command does,
+    // using exactly the same cache/re-adoption resolver as `bb wait` and `run`.
+    if (!resolveCredential && call !== callToolJson) {
+      process.stderr.write("botbuddy test: --session-id is required (or set BOTBUDDY_AGENT_SESSION_TOKEN)\n");
+      return { exitCode: EXIT_TEST.INVALID, line: JSON.stringify({ outcome: "rejected", errors: ["--session-id is required"] }) };
+    }
+    try {
+      const credential = await (resolveCredential ?? resolveAgentSessionCredential)({ argv, env, cwd });
+      managedCredential = credential;
+      opts.sessionToken = credential.token;
+      opts.sessionId = credential.sessionId ?? null;
+    } catch (error) {
+      const code = error?.code ?? "agent_session_unavailable";
+      process.stderr.write(`botbuddy test: ${error?.message ?? code}\n`);
+      return { exitCode: 3, line: JSON.stringify({ outcome: "rejected", error: code, recovery: code === "client_key_required" ? "run `bb login` then retry" : "run `bb doctor --fix` then retry" }) };
+    }
   }
 
   // BOT-1572 (Codex P1): a token-only session has no owner/profile credential, so
@@ -180,9 +200,20 @@ export async function launchTestLane(argv, {
   // otherwise both fail and the run launches with test_run_id=null, silently
   // dropping the test-run record and case telemetry. Wrap the call so the token
   // is pinned; an injected test `call` that ignores the 3rd arg is unaffected.
-  const apiCall = opts.sessionToken
-    ? (name, args) => call(name, args, { auth: { "x-agent-api-key": opts.sessionToken } })
-    : call;
+  const apiCall = (name, args) => opts.sessionToken
+    ? call(name, args, { auth: { "x-agent-api-key": opts.sessionToken } })
+    : call(name, args);
+  const callWithSessionRetry = async (name, args) => {
+    let result = await apiCall(name, args);
+    if (!isRejectedCachedMcpSession(result, managedCredential?.source, 0)) return result;
+    await clearState(cwd);
+    const credential = await (resolveCredential ?? resolveAgentSessionCredential)({ argv, env, cwd });
+    managedCredential = credential;
+    opts.sessionToken = credential.token;
+    opts.sessionId = credential.sessionId ?? opts.sessionId;
+    result = await apiCall(name, args);
+    return result;
+  };
 
   const resolved = resolveLane(laneName, { cwd });
   if (!resolved.ok) {
@@ -218,12 +249,12 @@ export async function launchTestLane(argv, {
     // BOT-1549: stamp the resolved lane kind on the run; absent ⇒ omitted (NULL).
     lane_kind: laneKind ?? undefined,
   };
-  const created = await apiCall("create_test_run", createArgs);
+  const created = await callWithSessionRetry("create_test_run", createArgs);
   const testRunId = created?.ok && !created.isError ? created.data?.id ?? null : null;
 
   if (testRunId) {
     // Step 2: attach the ticket + promote to active in one update.
-    await apiCall("update_test_run", {
+    await callWithSessionRetry("update_test_run", {
       test_run_id: testRunId,
       ticket_id: git.ticket ?? undefined,
       ticket_url: git.ticketUrl ?? undefined,