@botbuddy/cli 1.25.0 → 1.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "BotBuddy — Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   },
   "exports": {
     "./playwright-reporter": "./src/test/playwright-reporter.mjs",
+    "./telemetry": "./src/telemetry-outbox.mjs",
     "./package.json": "./package.json"
   },
   "files": [

package/src/agent-credential-store.mjs

@@ -1,15 +1,8 @@
-import { chmod, link, mkdir, readFile, rename, stat, unlink, utimes, writeFile } from "node:fs/promises";
-import { homedir, userInfo } from "node:os";
+import { userInfo } from "node:os";
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { dirname, join } from "node:path";
-import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 
-const STORE_SCHEMA_VERSION = 1;
-const LOCK_RETRY_MS = 10;
-const LOCK_MAX_ATTEMPTS = 100;
-const STALE_LOCK_MS = 30_000;
 const execFileAsync = promisify(execFile);
 
 // BOT-1520: is the macOS Keychain backend usable on this host? The CLI stores
@@ -24,20 +17,17 @@ export function keychainAvailable(platform = process.platform, exists = existsSy
   return platform === "darwin" && exists("/usr/bin/security");
 }
 
-export function ensureProfileCredentialBackend({ platform = process.platform, exists = existsSync } = {}) {
-  if (!keychainAvailable(platform, exists)) {
-    throw new Error("profile setup requires the macOS Keychain credential backend");
-  }
-}
-
-export function profileCredentialEnvironment(profile) {
-  return profile === "botbuddy-dev" ? "BOTBUDDY_BB_AGENT_KEY"
-    : profile === "supplyguard-dev" ? "BOTBUDDY_SG_AGENT_KEY" : null;
-}
+// BOT-1607 / BOT-1608: the canonical env/Keychain var a `.mcp.json` references.
+// The `.botbuddy-agent.json` binding's `mcp_env` defaults to this; `botbuddy mcp`
+// mints into it (or an `--env <NAME>` override). Defined here — the one module
+// both mcp-key.mjs and wait-profile.mjs already import — so neither has to import
+// the other (an api.mjs ↔ wait-profile.mjs ↔ mcp-key.mjs cycle).
+export const DEFAULT_MCP_ENV_VAR = "BOTBUDDY_MCP_KEY";
 
-function keychainService(profile) {
-  return profileCredentialEnvironment(profile);
-}
+// The pre-1607 var `profile setup` planted the reused bb_agent_ session token in.
+// A `.mcp.json` still referencing it keeps authenticating for one release; the
+// CLI recognises it as a DEPRECATED alias and tells the operator to migrate.
+export const LEGACY_MCP_ENV_VAR = "BOTBUDDY_BB_AGENT_KEY";
 
 // A keychain/credential-store write failed AFTER OAuth + registration already
 // succeeded. It carries its own code so the CLI never mislabels a storage
@@ -212,163 +202,3 @@ export async function deleteKeychainSecret(service, { execFileImpl = execFileAsy
     return false;
   }
 }
-
-export async function writeKeychain(profile, token, options = {}) {
-  const service = keychainService(profile);
-  if (!service) throw new ProfileCredentialStoreError(`unknown profile keychain service for "${profile}"`);
-  return writeKeychainSecret(service, token, options);
-}
-
-async function readKeychain(profile) {
-  // Honor the keychain escape hatch (BOTBUDDY_NO_KEYCHAIN / non-darwin) so the
-  // per-profile environment key is the sole credential source there.
-  if (!keychainAvailable()) return null;
-  return readKeychainSecret(keychainService(profile));
-}
-
-function profileCredentialStorePath(home = homedir()) {
-  return join(home, ".botbuddy", "agent-profiles.json");
-}
-
-async function readStore({ home = homedir() } = {}) {
-  try {
-    const raw = await readFile(profileCredentialStorePath(home), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed?.schema_version !== STORE_SCHEMA_VERSION || !parsed.profiles || typeof parsed.profiles !== "object") {
-      return { schema_version: STORE_SCHEMA_VERSION, profiles: {} };
-    }
-    return parsed;
-  } catch (error) {
-    if (error?.code === "ENOENT") return { schema_version: STORE_SCHEMA_VERSION, profiles: {} };
-    throw error;
-  }
-}
-
-function validIdentityEntry(entry) {
-  return entry && typeof entry === "object" && typeof entry.name === "string";
-}
-
-async function withStoreLock(path, operation) {
-  const lockPath = `${path}.lock`;
-  for (let attempt = 0; attempt < LOCK_MAX_ATTEMPTS; attempt++) {
-    const ownerPath = `${lockPath}.${process.pid}.${randomUUID()}`;
-    try {
-      await writeFile(ownerPath, JSON.stringify({ pid: process.pid, owner_path: ownerPath }), { flag: "wx", mode: 0o600 });
-      await link(ownerPath, lockPath);
-      const ownerStat = await stat(ownerPath);
-      const ownsLock = async () => {
-        try {
-          const current = await stat(lockPath);
-          return current.dev === ownerStat.dev && current.ino === ownerStat.ino;
-        } catch (error) {
-          if (error?.code === "ENOENT") return false;
-          throw error;
-        }
-      };
-      const refresh = setInterval(() => {
-        const now = new Date();
-        void ownsLock().then((owned) => owned && utimes(lockPath, now, now)).catch(() => {});
-      }, Math.floor(STALE_LOCK_MS / 3));
-      try {
-        return await operation();
-      } finally {
-        clearInterval(refresh);
-        if (await ownsLock()) await unlink(lockPath).catch(() => {});
-        await unlink(ownerPath).catch(() => {});
-      }
-    } catch (error) {
-      await unlink(ownerPath).catch(() => {});
-      if (error?.code !== "EEXIST") throw error;
-      try {
-        const lockStat = await stat(lockPath);
-        if (Date.now() - lockStat.mtimeMs > STALE_LOCK_MS) {
-          const lock = JSON.parse(await readFile(lockPath, "utf8"));
-          let ownerAlive = false;
-          try { process.kill(lock.pid, 0); ownerAlive = true; } catch (ownerError) { ownerAlive = ownerError?.code === "EPERM"; }
-          if (!ownerAlive) {
-            await unlink(lockPath);
-            if (typeof lock.owner_path === "string") await unlink(lock.owner_path).catch(() => {});
-          }
-        }
-      } catch (lockError) {
-        if (lockError?.code !== "ENOENT") throw lockError;
-      }
-      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
-    }
-  }
-  throw new Error("profile credential store is busy; retry profile setup");
-}
-
-export async function readProfileIdentity(profile, options = {}) {
-  const store = await readStore(options);
-  const entry = store.profiles[profile];
-  if (!validIdentityEntry(entry) || typeof entry.tenant !== "string" || typeof entry.agent_id !== "string") return null;
-  return { agentId: entry.agent_id, tenant: entry.tenant, name: entry.name };
-}
-
-export async function readProfileRetryIdentity(profile, options = {}) {
-  const store = await readStore(options);
-  const entry = store.profiles[profile];
-  if (!validIdentityEntry(entry)) return null;
-  const agentId = typeof entry.agent_id === "string" ? entry.agent_id : entry.pending_agent_id;
-  return typeof agentId === "string" ? { agentId, name: entry.name } : null;
-}
-
-export async function readProfileCredential(profile, options = {}) {
-  return (options.keychainRead ?? readKeychain)(profile);
-}
-
-async function writeProfileMetadata(profile, entry, {
-  home = homedir(),
-  onlyIfNoAttestedIdentity = false,
-  afterWrite = null,
-} = {}) {
-  const path = profileCredentialStorePath(home);
-  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-  await withStoreLock(path, async () => {
-    const store = await readStore({ home });
-    const current = store.profiles[profile];
-    if (onlyIfNoAttestedIdentity && validIdentityEntry(current) && typeof current.tenant === "string" && typeof current.agent_id === "string") {
-      return false;
-    }
-    const next = {
-      schema_version: STORE_SCHEMA_VERSION,
-      profiles: { ...store.profiles, [profile]: entry },
-    };
-    const temporaryPath = `${path}.${randomUUID()}.tmp`;
-    await writeFile(temporaryPath, JSON.stringify(next), { mode: 0o600 });
-    await chmod(temporaryPath, 0o600);
-    await rename(temporaryPath, path);
-    await chmod(path, 0o600);
-    await afterWrite?.();
-    return true;
-  });
-}
-
-export async function recordProfileRetryIdentity({ profile, agentId, name }, options = {}) {
-  if (![profile, agentId, name].every((value) => typeof value === "string" && value.length > 0)) {
-    throw new Error("profile retry identity requires profile, agentId, and name");
-  }
-  // This entry is explicitly not tenant-attested and contains no credential. It
-  // may only be used to reconnect with the profile's fixed tenant on retry.
-  await writeProfileMetadata(profile, { pending_agent_id: agentId, name }, {
-    ...options,
-    onlyIfNoAttestedIdentity: true,
-  });
-}
-
-export async function installProfileCredential({ profile, tenant, agentId, name, token }, { home = homedir(), keychainWrite = writeKeychain } = {}) {
-  if (![profile, tenant, agentId, name, token].every((value) => typeof value === "string" && value.length > 0)) {
-    throw new Error("profile credential store requires profile, tenant, agentId, name, and token");
-  }
-  // Keep non-secret identity metadata even if Keychain is momentarily locked.
-  // The next setup call reconnects this same server agent instead of minting a
-  // random orphan; credentials are never written to this file.
-  await writeProfileMetadata(profile, { tenant, agent_id: agentId, name }, {
-    home,
-    // Keep this Keychain operation in the same lock as the metadata write. A
-    // later setup cannot leave metadata from one agent beside another agent's
-    // credential, while a failed write still leaves resumable metadata.
-    afterWrite: () => keychainWrite(profile, token),
-  });
-}

package/src/api.mjs

@@ -1,6 +1,6 @@
 import { getConfig, SERVER_URL } from "./config.mjs";
 import { resolveOwnerToken, resolveAgentKey } from "./cli-credentials.mjs";
-import { findProfileName, getAgentProfile } from "./wait-profile.mjs";
+import { readAgentBinding } from "./wait-profile.mjs";
 import { die, cyan, dim, yellow, prettyJson } from "./utils.mjs";
 
 // Same slug shape the server accepts on `?tenant=`.
@@ -10,7 +10,7 @@ const TENANT_PIN_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 // server refuses unpinned (MCP_TENANT_PIN_REQUIRED). Generic commands
 // (`botbuddy call`, resources) therefore derive a default pin:
 //   1. BOTBUDDY_TENANT (explicit; malformed → usage error, never sent),
-//   2. the repo's .botbuddy-agent.json profile tenant (walks up from cwd),
+//   2. the repo's .botbuddy-agent.json tenant (walks up from cwd),
 //   3. the token's sole reachable tenant,
 //   4. none — the server's error names the fix.
 // A sealed (tenant-mode) or pre-1571 token gets NO derived pin: the server
@@ -21,8 +21,7 @@ export async function resolveDefaultTenantPin({
   getConfig: getCfg = getConfig,
   env = process.env,
   cwd = process.cwd(),
-  findProfile = findProfileName,
-  profileFor = getAgentProfile,
+  readBinding = readAgentBinding,
 } = {}) {
   const explicit = typeof env.BOTBUDDY_TENANT === "string" ? env.BOTBUDDY_TENANT.trim() : "";
   if (explicit) {
@@ -31,10 +30,11 @@ export async function resolveDefaultTenantPin({
   }
   const cfg = getCfg() ?? {};
   if (cfg.token_tenant_mode !== "user") return null;
-  let profileName = null;
-  try { profileName = await findProfile(cwd); } catch { profileName = null; }
-  const profileTenant = profileName ? profileFor(profileName)?.tenant ?? null : null;
-  if (profileTenant) return profileTenant;
+  // A malformed / retired-shape .botbuddy-agent.json never breaks a generic call —
+  // fall through to the sole-tenant rung rather than throwing here.
+  let bindingTenant = null;
+  try { bindingTenant = (await readBinding(cwd))?.tenant ?? null; } catch { bindingTenant = null; }
+  if (bindingTenant) return bindingTenant;
   const tenants = Array.isArray(cfg.token_tenants) ? cfg.token_tenants.filter((t) => typeof t === "string" && t) : [];
   return tenants.length === 1 ? tenants[0] : null;
 }

package/src/auth.mjs

@@ -187,7 +187,7 @@ export async function doLogin(options = {}, deps = {}) {
       }.`,
     );
     if (tenantMode === "user") {
-      log(`  Token scope: ${cyan("user")} — works for every tenant you belong to${tenants.length ? ` (${tenants.join(", ")})` : ""}; each ${cyan("botbuddy profile setup")} pins its own.`);
+      log(`  Token scope: ${cyan("user")} — works for every tenant you belong to${tenants.length ? ` (${tenants.join(", ")})` : ""}; each ${cyan("botbuddy mcp setup --tenant <slug>")} mints a key pinned to its own.`);
     } else if (tenantId) {
       log(`  Token scope: ${cyan("tenant")} — sealed to ${cyan(tenantId)}. Run ${cyan("botbuddy login")} without ${dim("--tenant")} for a token that reaches all your tenants.`);
     }

package/src/cli-credentials.mjs

@@ -23,7 +23,7 @@ import {
   readKeychainSecret,
   deleteKeychainSecret,
 } from "./agent-credential-store.mjs";
-import { resolveAgentProfile } from "./wait-profile.mjs";
+import { resolveAgentBinding } from "./wait-profile.mjs";
 
 // BOT-1574: the per-machine CLIENT KEY. `botbuddy login` mints a user-mode OAuth
 // token (BOT-1571) — tenant-agnostic, pins one tenant per request against the
@@ -267,15 +267,20 @@ export async function clearOwnerToken({
   }
 }
 
-// Resolve the tenant-bound agent key from the profile Keychain store (or the
-// per-profile environment key), without throwing when no profile is configured.
-// This is the sole source of the agent credential now that `register` is gone.
+// Resolve the agent-context credential from the worktree binding — the
+// `.botbuddy-agent.json` mcp_env var (env or Keychain) — without throwing when no
+// binding is configured. This is the fallback the owner OAuth token defers to for
+// tool-call auth now that `register` and `profile setup` are both gone.
 export async function resolveAgentKey(options = {}) {
   try {
-    const { token } = await resolveAgentProfile(options);
+    const { token } = await resolveAgentBinding(options);
     return token || null;
   } catch (error) {
-    if (error?.code === "profile_required" || error?.code === "unknown_profile") return null;
+    // A missing / malformed / retired-shape binding is not authenticated — let the
+    // caller fall through to its "not authenticated" path rather than throwing.
+    if (["agent_binding_required", "invalid_binding", "binding_migration_required"].includes(error?.code)) {
+      return null;
+    }
     throw error;
   }
 }

package/src/codex-bridge.mjs

@@ -66,14 +66,14 @@ function isAddressInUseError(text) {
 
 export async function runBridge(args) {
   const cfg = getConfig(); // non-secret metadata only (agent_name)
-  // BOT-1520: authenticate from the Keychain — the profile agent key
-  // (`botbuddy profile setup`) or the owner OAuth token (`botbuddy login`).
+  // BOT-1520: authenticate from the Keychain — the MCP key
+  // (`botbuddy mcp setup`, BOT-1608) or the owner OAuth token (`botbuddy login`).
   // Resolve ONCE here for the life of the bridge and cache it, so the relay
   // helpers don't shell out to `security` on every request.
   const agentKey = await resolveAgentKey();
   const owner = agentKey ? null : await resolveOwnerToken({ getConfig });
   if (!agentKey && !owner) {
-    die(`Not authenticated. Run: ${cyan("botbuddy start")} or ${cyan("botbuddy login")} (agents: ${cyan("botbuddy profile setup <profile>")}).`);
+    die(`Not authenticated. Run: ${cyan("botbuddy start")} or ${cyan("botbuddy login")} (agents: ${cyan("botbuddy mcp setup")}).`);
   }
   bridgeAuth = { agentKey, owner };