@botbuddy/cli 1.45.7 → 1.46.1

package/package.json

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

package/src/run.mjs

@@ -15,7 +15,9 @@ import { fileURLToPath } from "node:url";
 import { callToolJson } from "./api.mjs";
 import { parseLaneEvents, laneCaseCounts, flushLaneCases, buildLaneSummary, laneSummaryFilename } from "./test-lane-events.mjs";
 import { AGENT_KEY_RE, readAgentSessionTokenEnv, legacyAgentAliasHint } from "./agent-key.mjs";
-import { clearAgentState, isRejectedCachedMcpSession, resolveAgentSessionCredential } from "./agent-session.mjs";
+import { hasAgentSessionRuntime, isRejectedCachedMcpSession, resolveAgentSessionCredential, selfHealAgentSession } from "./agent-session.mjs";
+import { isAgentStateFresh, readAgentState, worktreeRoot } from "./agent-state.mjs";
+import { readAgentBinding } from "./wait-profile.mjs";
 import { createTelemetryOutbox } from "./telemetry-outbox.mjs";
 import { deliverExecutionEvent } from "./telemetry-delivery.mjs";
 import { attestTelemetryCredential, loadTelemetryIdentity } from "./telemetry-config.mjs";
@@ -231,49 +233,82 @@ function workerInvocation(context) {
   return [process.execPath, [bin, "run", "--worker", context]];
 }
 
+function sessionFailure(code) { return Object.assign(new Error(code), { code }); }
+
+// A selected ID is metadata, not a credential. Require positive private-cache
+// authority before resolving it; never let the API's ambient owner key stand in.
+async function resolveRunCredential({ cwd, env, opts, resolveCredential }) {
+  const cached = await readAgentState(cwd);
+  const explicitId = opts.sessionId;
+  const validateBinding = async (identity) => {
+    const bound = await readAgentBinding(cwd);
+    if (!bound?.tenant || identity?.tenant !== bound.tenant || !identity?.worktree
+      || await worktreeRoot(identity.worktree) !== await worktreeRoot(cwd)) {
+      throw sessionFailure("run_session_binding_mismatch");
+    }
+  };
+  if (explicitId && !cached) throw sessionFailure("run_session_authority_missing");
+  if (cached) {
+    if (explicitId && cached.session_id !== explicitId) throw sessionFailure("run_session_mismatch");
+    await validateBinding(cached);
+    if (explicitId && !isAgentStateFresh(cached, new Date())) throw sessionFailure("run_session_expired");
+  } else if (await hasAgentSessionRuntime({ cwd })) {
+    throw sessionFailure("run_session_authority_missing");
+  }
+  const credential = await (resolveCredential ?? resolveAgentSessionCredential)({ cwd, env,
+    sessionId: explicitId, flagToken: null });
+  // The resolver reads again. A concurrent replacement must satisfy the same
+  // binding and explicit ID rather than silently adopting unrelated authority.
+  if (credential.source === "cache") {
+    await validateBinding(credential.identity);
+    if (explicitId && credential.identity?.sessionId !== explicitId) throw sessionFailure("run_session_mismatch");
+  }
+  return credential;
+}
+
+function rejectedSessionReceipt(error, runId) {
+  const code = error?.code ?? "agent_session_unavailable";
+  const exitCode = ["session_mint_failed", "session_mint_invalid"].includes(code) ? EXIT.BACKEND : EXIT.AUTH;
+  return { exitCode, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "rejected",
+    ...(runId ? { run_id: runId } : {}), error: code,
+    recovery: code === "client_key_required"
+      ? "run `bb login` to install the durable client key, then retry"
+      : "run `bb doctor --fix` and select the current worktree session, then retry",
+    exit_code: exitCode } };
+}
+
 export async function launchRun(argv, {
   cwd = process.cwd(), spawnImpl = spawn, call = null, childEnv = null, testRun = null,
-  resolveCredential = null, env = process.env,
+  resolveCredential = null, renewCredential = selfHealAgentSession, env = process.env,
 } = {}) {
-  let effectiveArgv = argv;
-  let parsed = parseRunArgs(effectiveArgv, env);
+  const parsed = parseRunArgs(argv, env);
   let managedCredential = null;
   // A local test double owns its credential boundary; production invocations
   // self-heal when the session credential was not supplied by flag or env.
   // Keep all other usage failures local and deterministic before minting.
   const onlyMissingIdentity = parsed.errors.length === 1 && parsed.errors[0].includes("session-id");
-  if (!parsed.opts.foreground && !parsed.opts.sessionId && !parsed.opts.sessionToken
-    && onlyMissingIdentity && (resolveCredential || call === null)) {
+  if (!parsed.opts.foreground && !parsed.opts.sessionToken
+    && (parsed.errors.length === 0 || onlyMissingIdentity)
+    && (resolveCredential || call === null || call === callToolJson)) {
     try {
-      const credential = await (resolveCredential ?? resolveAgentSessionCredential)({ argv, env, cwd });
+      const credential = await resolveRunCredential({ cwd, env, opts: parsed.opts, resolveCredential });
       managedCredential = credential;
-      effectiveArgv = ["--agent-session-token", credential.token, ...argv];
-      parsed = parseRunArgs(effectiveArgv, env);
+      parsed.opts.sessionToken = credential.token;
+      if (!SESSION_TOKEN_RE.test(credential.token)) throw sessionFailure("session_mint_invalid");
+      if (onlyMissingIdentity) parsed.errors.length = 0;
     } catch (error) {
-      return {
-        exitCode: EXIT.AUTH,
-        receipt: {
-          schema_version: RUN_SCHEMA_VERSION,
-          outcome: "rejected",
-          error: error?.code ?? "agent_session_unavailable",
-          recovery: error?.code === "client_key_required"
-            ? "run `bb login` to install the durable client key, then retry"
-            : "run `bb doctor --fix` to repair agent authentication, then retry",
-          exit_code: EXIT.AUTH,
-        },
-      };
+      return rejectedSessionReceipt(error);
     }
   }
   const { opts, command, errors } = parsed;
   if (errors.length) return { exitCode: EXIT.INVALID, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "rejected", errors, exit_code: EXIT.INVALID } };
   // BOT-1572 (AC-8): when a session token is present it is the credential — pin it
   // so register_command authenticates as the session's agent and derives session_id
-  // from the token. Tests inject `call` directly and bypass this.
-  const effectiveCall = call ?? (opts.sessionToken
-    ? (t, a) => callToolJson(t, a, { auth: { "x-agent-api-key": opts.sessionToken } })
-    : callToolJson);
+  // from the token. Read the current token on each call, including after renewal.
+  const effectiveCall = (t, a) => (call ?? callToolJson)(t, a,
+    opts.sessionToken ? { auth: { "x-agent-api-key": opts.sessionToken } } : {});
   const runId = randomUUID();
-  const registerArgs = {
+  const registerArgs = () => ({
     // Omit session_id entirely when only a token is present — the backend derives
     // it. A plain id is still sent (and honoured) when supplied.
     ...(opts.sessionId ? { session_id: opts.sessionId } : {}),
@@ -281,18 +316,22 @@ export async function launchRun(argv, {
     command_hash: commandHash(command), environment_hash: environmentHash(cwd, opts.environment),
     environment: opts.environment, command_kind: opts.kind, expected_duration_seconds: opts.expectedDuration,
     rerun_reason: opts.rerunReason,
-  };
-  let registration = await effectiveCall("register_command", registerArgs);
+  });
+  let registration = await effectiveCall("register_command", registerArgs());
   // A cached session can be revoked server-side before its local expiry.  The
   // managed cache is ours to replace once; explicit flag/env credentials belong
   // to the caller and are never silently rotated.
   if (isRejectedCachedMcpSession(registration, managedCredential?.source, 0)) {
-    await clearAgentState(cwd);
-    const credential = await (resolveCredential ?? resolveAgentSessionCredential)({ argv, env, cwd });
-    managedCredential = credential;
-    opts.sessionToken = credential.token;
-    opts.sessionId = credential.sessionId ?? opts.sessionId;
-    registration = await effectiveCall("register_command", registerArgs);
+    try {
+      const credential = await renewCredential({ cwd, env, force: true, rejectedCredential: {
+        token: managedCredential.token, identity: managedCredential.identity,
+      } });
+      managedCredential = credential;
+      opts.sessionToken = credential.token;
+      opts.sessionId = credential.identity?.sessionId ?? credential.sessionId;
+      if (!SESSION_TOKEN_RE.test(opts.sessionToken) || !opts.sessionId) throw sessionFailure("session_mint_invalid");
+      registration = await effectiveCall("register_command", registerArgs());
+    } catch (error) { return rejectedSessionReceipt(error, runId); }
   }
   if (!registration.ok || registration.isError || !registration.data?.accepted || !registration.data?.run_credential) {
     return { exitCode: EXIT.BACKEND, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "rejected", run_id: runId, error: registration.data?.error ?? registration.error ?? "durable_owner_not_established", exit_code: EXIT.BACKEND } };
@@ -310,7 +349,10 @@ export async function launchRun(argv, {
     await effectiveCall("update_command_run", { run_id: runId, run_credential: registration.data.run_credential, status: "owner_lost", invalidated_reason: `launcher_failed:${error instanceof Error ? error.message : String(error)}` });
     return { exitCode: EXIT.INTERNAL, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "owner_lost", run_id: runId, exit_code: EXIT.INTERNAL } };
   }
-  return { exitCode: EXIT.OK, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "launched", run_id: runId, session_id: opts.sessionId, durable_owner: "detached_worker", receipt_path: receipt, reentry: "update_command_run publishes the terminal callback for this run_id", exit_code: EXIT.OK } };
+  const knownSession = opts.sessionId ?? managedCredential?.identity?.sessionId ?? managedCredential?.sessionId;
+  return { exitCode: EXIT.OK, receipt: { schema_version: RUN_SCHEMA_VERSION, outcome: "launched", run_id: runId,
+    ...(knownSession ? { session_id: knownSession } : { session_binding: "server_derived" }),
+    durable_owner: "detached_worker", receipt_path: receipt, reentry: "update_command_run publishes the terminal callback for this run_id", exit_code: EXIT.OK } };
 }
 
 export async function runWorker(contextFile, { spawnImpl = spawn, call = callToolJson } = {}) {