@botbuddy/cli 1.68.0 → 1.69.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.68.1
+
+- The bb-status band now binds a Claude Code session whose repo has no BotBuddy SessionStart hook, such as Supply Guard worktrees, instead of showing "BB identity belongs to another session". When the worktree has no session cache, an unbound one or an expired one, `bb status-band read` bootstraps this session once (ticketless, the same bootstrap `bb bootstrap` runs) and reads again. A cache another live session holds is never taken over.
+
 ## 1.68.0
 
 - The bb-status band for Claude Code now ships in this package. `bb setup` and `bb update` install it once, at user scope, through `bb status-band install`. They point the `botbuddy-labs` marketplace at the plugin inside the installed CLI, so every worktree shows the band with no plugin command, and no repo checkout is needed. The band's reads and live wake run from the installed CLI (`bb status-band read` and `bb status-band relay`).

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.68.0",
-  "source_commit": "dacd86b04baacbb89711e0a72c52ee036fd17721",
-  "source_sha256": "f857817d22c1d475d9b53f86b0ea73f2e6e0af18f306b1d079b21cc844413260",
+  "release_version": "1.69.0",
+  "source_commit": "843a7cf3ec82011015ab46bc9f40454083375df2",
+  "source_sha256": "058e319761db47ddd1b9967bbb6016e01689eef53d18c8639f7fc8cb9d1a6ded",
   "target": "darwin-arm64",
-  "sha256": "3a9d33c8cfd04bd4844025552464c02b55399fab1c5352fdc86799a62c8bec5e"
+  "sha256": "8938908530358c262670cb5c3b1114ce993c187f0dfe27943cc9a6498e9d4fb9"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.68.0",
-  "source_commit": "dacd86b04baacbb89711e0a72c52ee036fd17721",
-  "source_sha256": "f857817d22c1d475d9b53f86b0ea73f2e6e0af18f306b1d079b21cc844413260",
+  "release_version": "1.69.0",
+  "source_commit": "843a7cf3ec82011015ab46bc9f40454083375df2",
+  "source_sha256": "058e319761db47ddd1b9967bbb6016e01689eef53d18c8639f7fc8cb9d1a6ded",
   "target": "linux-x64",
-  "sha256": "15fde9d3dd872809e9cc0aead517e7aef9a5398af55b4543269cdd90a6ffc96b"
+  "sha256": "dc8d2b619f15baa928a500a2420160c9a67924f71defc3d16f32617d0a6543a0"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.68.0",
-  "source_commit": "dacd86b04baacbb89711e0a72c52ee036fd17721",
-  "source_sha256": "f857817d22c1d475d9b53f86b0ea73f2e6e0af18f306b1d079b21cc844413260",
+  "release_version": "1.69.0",
+  "source_commit": "843a7cf3ec82011015ab46bc9f40454083375df2",
+  "source_sha256": "058e319761db47ddd1b9967bbb6016e01689eef53d18c8639f7fc8cb9d1a6ded",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "3a9d33c8cfd04bd4844025552464c02b55399fab1c5352fdc86799a62c8bec5e",
+      "sha256": "8938908530358c262670cb5c3b1114ce993c187f0dfe27943cc9a6498e9d4fb9",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "15fde9d3dd872809e9cc0aead517e7aef9a5398af55b4543269cdd90a6ffc96b",
+      "sha256": "dc8d2b619f15baa928a500a2420160c9a67924f71defc3d16f32617d0a6543a0",
       "mode": "0755"
     }
   }

package/package.json

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

package/src/commands.mjs

@@ -1543,9 +1543,11 @@ export function mcpRecovery(code) {
     case "reserved_env_var":
       return "that --env name belongs to another BotBuddy credential (it would clobber that Keychain slot) — pick a distinct MCP var like BOTBUDDY_MCP_KEY_WORK.";
     case "env_var_in_use":
-      return "that Keychain slot already holds a key — revoke the old server key (`botbuddy mcp revoke <agent_id>`) if it is still live, then clear the local slot with `security delete-generic-password -s <NAME>`; or use a different --env, or pass --force to replace it in place.";
+      return "that Keychain slot already holds a key — revoke the old server key (`botbuddy mcp revoke <agent_id>`) if it is still live, then clear the local slot with `security delete-generic-password -s <NAME>`; or use a different --env, or pass --force to replace it in place (the replaced key is revoked).";
+    case "previous_key_unconfirmed":
+      return "couldn't confirm which key --force would replace (BotBuddy unreachable or the reply was unclear), so nothing was minted — retry when BotBuddy answers; the old key is unchanged.";
     case "keychain_read_failed":
-      return "couldn't read the Keychain to check the slot (locked/unavailable) — unlock it (`security unlock-keychain`) and retry, or pass --force to skip the check.";
+      return "couldn't read the Keychain slot (locked/unavailable) — unlock it (`security unlock-keychain`) and retry. --force also reads the slot, to revoke the key it replaces.";
     case "not_an_mcp_key":
       return "that agent_id is not a bb_mcp_ key — pass the agent_id `botbuddy mcp setup` returned.";
     case "not_found":
@@ -1665,7 +1667,10 @@ export async function cmdMcp(args, {
       // Parse inside the try so a bad --env (missing value / reserved name) becomes
       // an error receipt rather than an uncaught throw (Codex P2).
       const opts = parseMcpSetupArgs(args);
-      log(JSON.stringify(await setup({ envVar: opts.envVar, tenant: opts.tenant, label: opts.label, expiryDays: opts.expiryDays, force: opts.force })));
+      const receipt = await setup({ envVar: opts.envVar, tenant: opts.tenant, label: opts.label, expiryDays: opts.expiryDays, force: opts.force });
+      log(JSON.stringify(receipt));
+      // BOT-3196 AC-4: a replaced key that could not be revoked is still live.
+      if (receipt?.previous_key_revoked === false) setExitCode(3);
     } catch (error) {
       const code = (error instanceof McpKeyError || error instanceof McpKeyStoreError) ? error.code : "mint_failed";
       const extra = {};

package/src/mcp-key.mjs

@@ -214,11 +214,19 @@ export async function setupMcpKey({
   writeKeychain = writeKeychainSecret,
   readKeychain = readKeychainSecret,
   mcpUrl = SERVER_URL,
+  env = process.env,
 } = {}) {
   const pinned = await resolveAuth();
   if (pinned?.error) throw new McpKeyError("not_authenticated");
   const auth = pinned?.auth ?? null;
 
+  // BOT-3196 AC-4: --force REPLACES the key in this slot, so the key it replaces
+  // must stop working at once. Overwriting only the local secret left the old
+  // bb_mcp_ row live on the server (its 401 never came). Identify the old key
+  // BEFORE minting (fail closed: an unreadable slot is refused, never treated
+  // as empty), then revoke it once the new key is safely stored.
+  const replacing = force ? await findReplacedMcpKey({ envVar, env, call, keychainAvail, readKeychain }) : null;
+
   // Codex P1/P2: refuse to mint into an OCCUPIED Keychain slot unless --force.
   // Re-running setup would `security -U`-overwrite the local secret AFTER a
   // second server credential is minted, silently orphaning the previous, still
@@ -298,9 +306,36 @@ export async function setupMcpKey({
     }
   }
 
+  // BOT-3196 AC-4: revoke the replaced key now that the new one is stored (or,
+  // with no Keychain, about to be printed). A failed revoke never hides the new
+  // key: the receipt says so, and the command exits non-zero (cmdMcp).
+  let replaced = {};
+  if (replacing) {
+    let revoked = false;
+    try {
+      const undo = await call("revoke_mcp_key", { agent_id: replacing.agentId }, { auth, ...(replacing.tenant ? { tenant: replacing.tenant } : {}) });
+      // Only BotBuddy's affirmative answer for THIS key counts: a 2xx carrying
+      // { ok: true, revoked: true, agent_id }. A gateway 5xx with a JSON body can
+      // parse as an empty tool answer and must never read as revoked (Codex P2).
+      revoked = undo?.ok === true && !undo.isError
+        && typeof undo.status === "number" && undo.status >= 200 && undo.status < 300
+        && undo.data?.ok === true && undo.data?.revoked === true && undo.data?.agent_id === replacing.agentId;
+    } catch {
+      revoked = false;
+    }
+    replaced = revoked
+      ? { replaced_agent_id: replacing.agentId, previous_key_revoked: true }
+      : {
+        replaced_agent_id: replacing.agentId,
+        previous_key_revoked: false,
+        previous_key_recovery: `the replaced key is STILL LIVE — revoke it with \`botbuddy mcp revoke ${replacing.agentId}${replacing.tenant ? ` --tenant ${replacing.tenant}` : ""}\`.`,
+      };
+  }
+
   return {
     schema_version: 1,
     outcome: stored ? "installed" : "minted_no_keychain",
+    ...replaced,
     // Codex P1: storing ≠ exporting. When stored in the Keychain, the key is not
     // yet in the environment the MCP client reads — spell out the loader so the
     // operator doesn't launch Claude/Codex with $envVar unset.
@@ -320,6 +355,38 @@ export async function setupMcpKey({
   };
 }
 
+/**
+ * BOT-3196 AC-4: the live bb_mcp_ key a forced setup replaces, or null. Reads
+ * the slot (the Keychain item, or with no Keychain the variable itself) and asks
+ * the server who that key is. A key the server rejects with a plain 401, or one
+ * that is not a bb_mcp_ key, has nothing to revoke. An unreadable Keychain or
+ * an unconfirmed identity fails closed before anything is minted.
+ */
+export async function findReplacedMcpKey({ envVar, env = process.env, call = callToolJson, keychainAvail = keychainAvailable, readKeychain = readKeychainSecret }) {
+  let previous = null;
+  if (keychainAvail()) {
+    try {
+      previous = await readKeychain(envVar, { strict: true });
+    } catch (error) {
+      throw new McpKeyError("keychain_read_failed", { detail: error?.message ?? String(error) });
+    }
+  } else {
+    previous = env?.[envVar] ?? null;
+  }
+  if (typeof previous !== "string" || !previous.startsWith("bb_mcp_")) return null;
+  const who = await call("whoami", {}, { auth: { "x-agent-api-key": previous } });
+  // Only a plain 401 (no structured refusal code) proves the old key is already
+  // dead. Anything else — a transport error, a 5xx, a tenant refusal, a reply
+  // without the key's identity — leaves its state unknown, so refuse before
+  // minting rather than orphan a key that may still be live (Codex P2, #1625).
+  if (who?.ok === false && who.auth === true && who.status === 401 && !who.code) return null;
+  const agentId = who?.ok && !who.isError ? who.data?.agent?.id : null;
+  if (typeof agentId !== "string" || !agentId) {
+    throw new McpKeyError("previous_key_unconfirmed", { detail: who?.error ?? "no identity in the whoami reply" });
+  }
+  return { agentId, tenant: typeof who.data?.tenant_id === "string" ? who.data.tenant_id : null };
+}
+
 // Map a revoke_mcp_key server refusal to a CLI error code.
 function mapRevokeCode(code) {
   if (code === "MCP_TENANT_PIN_REQUIRED" || code === "MCP_TENANT_SELECTION_REQUIRED") return "tenant_pin_required";

package/src/status-band-read.mjs

@@ -473,7 +473,48 @@ export async function readStatus({
       : null,
   };
 }
-export async function main(args, { out = process.stdout, cwd = process.cwd(), env = process.env } = {}) {
+// BOT-3152 AC-5: a repo with no SessionStart bootstrap hook (Supply Guard) leaves
+// the worktree cache missing, unbound (no harness id) or expired, so the band
+// binds this session itself, once per read, through the same bootstrap
+// `bb bootstrap` runs. A cache another harness session holds is never
+// bootstrapped over: that session owns the worktree's identity.
+const BINDABLE = new Set(["session_missing", "session_mismatch", "session_expired"]);
+async function bindable(cwd, harnessSessionId, now) {
+  let state;
+  try {
+    state = JSON.parse(await readFile(join(await realpath(cwd), ".botbuddy/agent-state.json"), "utf8"));
+  } catch (error) {
+    return error?.code === "ENOENT";
+  }
+  const holder = typeof state?.harness_session_id === "string" ? state.harness_session_id.toLowerCase() : "";
+  if (!holder || holder === harnessSessionId.toLowerCase()) return true;
+  return !(Date.parse(state.expires_at) > now());
+}
+async function bootstrapBand({ cwd, harnessSessionId, branch }) {
+  const [{ bootstrapHarnessSession }, { getConfig }, { hostname }] = await Promise.all([
+    import("./session-bootstrap.mjs"),
+    import("./config.mjs"),
+    import("node:os"),
+  ]);
+  await bootstrapHarnessSession({
+    name: `${getConfig()?.agent_name || `botbuddy-${hostname()}`}-${harnessSessionId.slice(0, 8)}`,
+    type: "claude",
+    harnessSessionId,
+    cwd,
+    branch,
+    noTicketReason: "bb-status band bound a Claude Code session its repo did not bootstrap",
+    harness: "botbuddy-claude-band",
+  });
+}
+
+export async function main(args, {
+  out = process.stdout,
+  cwd = process.cwd(),
+  env = process.env,
+  read = readStatus,
+  bootstrap = bootstrapBand,
+  now = () => Date.now(),
+} = {}) {
   try {
     args = [...args];
     const skipEpic = args.at(-1) === "--skip-epic";
@@ -484,13 +525,23 @@ export async function main(args, { out = process.stdout, cwd = process.cwd(), en
       (args.length === 4 && args[2] !== "--ticket-id")
     )
       refuse("invalid_arguments");
-    const snapshot = await readStatus({
-      cwd,
-      harnessSessionId: args[1],
-      ticketId: args[3],
-      linearKey: env.LINEAR_BB_API_KEY,
-      skipEpic,
-    });
+    const request = { cwd, harnessSessionId: args[1], ticketId: args[3], linearKey: env.LINEAR_BB_API_KEY, skipEpic };
+    let snapshot;
+    try {
+      snapshot = await read(request);
+    } catch (error) {
+      if (!BINDABLE.has(error?.message) || !UUID.test(args[1]) || !(await bindable(cwd, args[1], now))) throw error;
+      let branch = null;
+      try {
+        branch = (await execFileAsync("git", ["branch", "--show-current"], { cwd })).stdout.trim() || null;
+      } catch { /* detached or not a repo: bootstrap without a branch */ }
+      try {
+        await bootstrap({ cwd, harnessSessionId: args[1].toLowerCase(), branch });
+      } catch {
+        throw error;
+      }
+      snapshot = await read(request);
+    }
     out.write(JSON.stringify(snapshot) + "\n");
     return 0;
   } catch (error) {