@botbuddy/cli 1.61.0 → 1.61.2

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.61.0",
-  "source_commit": "5661e7d4d29c975fc925b0a6c47741db33598642",
-  "source_sha256": "c5c57ed492234165bee179842456b3bebce505b36145e96551c0ddbd0cdf605a",
+  "release_version": "1.61.2",
+  "source_commit": "dd1a661ff53e723ffff2ac338d38254016838555",
+  "source_sha256": "d6f135948d8106303c7cabdc54e507e93c84c2d96a11bf457eaaf6c3a5f49898",
   "target": "darwin-arm64",
-  "sha256": "afadb8e224f68209f4a2a0f8367d4aa289a76ac21f2ee57cbd376b90ab569469"
+  "sha256": "a3210e7bf1e6d2f7d181665b272d7b61dc85e3502612126e007cd2e0296ab469"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.61.0",
-  "source_commit": "5661e7d4d29c975fc925b0a6c47741db33598642",
-  "source_sha256": "c5c57ed492234165bee179842456b3bebce505b36145e96551c0ddbd0cdf605a",
+  "release_version": "1.61.2",
+  "source_commit": "dd1a661ff53e723ffff2ac338d38254016838555",
+  "source_sha256": "d6f135948d8106303c7cabdc54e507e93c84c2d96a11bf457eaaf6c3a5f49898",
   "target": "linux-x64",
-  "sha256": "830ff851e5d9d85957855af52a7c372cde56e2f9ddb315a31f5d2477c1c7d9d7"
+  "sha256": "acb7cd4a38d41d3865cfa774263fd3681e02ff1ff22fa94046332cda0159d0de"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.61.0",
-  "source_commit": "5661e7d4d29c975fc925b0a6c47741db33598642",
-  "source_sha256": "c5c57ed492234165bee179842456b3bebce505b36145e96551c0ddbd0cdf605a",
+  "release_version": "1.61.2",
+  "source_commit": "dd1a661ff53e723ffff2ac338d38254016838555",
+  "source_sha256": "d6f135948d8106303c7cabdc54e507e93c84c2d96a11bf457eaaf6c3a5f49898",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "afadb8e224f68209f4a2a0f8367d4aa289a76ac21f2ee57cbd376b90ab569469",
+      "sha256": "a3210e7bf1e6d2f7d181665b272d7b61dc85e3502612126e007cd2e0296ab469",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "830ff851e5d9d85957855af52a7c372cde56e2f9ddb315a31f5d2477c1c7d9d7",
+      "sha256": "acb7cd4a38d41d3865cfa774263fd3681e02ff1ff22fa94046332cda0159d0de",
       "mode": "0755"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.61.0",
+  "version": "1.61.2",
   "description": "BotBuddy \u2014 Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/commands.mjs

@@ -278,6 +278,8 @@ ${bold("STAGING SIGN-IN")} (BOT-2084)
                               persona, no password (${cyan("bb pw auth --help")})
   staging-pool status [--check]
                               Pool health: one reason, who acts, the next command
+  staging-pool refresh-runtime --tenant <slug> --pool <id>
+                              Refresh an existing producer; never signs in
   staging-pool install --tenant <slug> | tick | mint-one | uninstall
                               Human only, any directory (${cyan("bb staging-pool --help")})
   help symptom staging-pool   Every refusal code with its cause and next command

package/src/pw/staging-auth.mjs

@@ -314,7 +314,10 @@ export async function runStagingAuth({ plan, host, env, deps, socketRun, resolve
     claim = await poolModule.takeForLane({ persona: persona.email, owner: `lane-${plan.lane}@${host}`, poolId: ctxPool.poolId, tenantHint, ...poolOptions });
   } catch (error) {
     if (error?.code === "pool_empty") {
-      return refuse(io, "pool_empty", 3, Object.fromEntries(["reason", "detail", ...GUIDED_FIELDS].filter((key) => error[key] !== undefined).map((key) => [key, error[key]])), vars);
+      // The refusal's code is the pool's health reason when it is unhealthy (e.g. a
+      // count-0 persona is persona_not_configured), so code, message and help agree.
+      const reasonCode = typeof error.reason === "string" && error.reason !== "healthy" && isKnownCode(error.reason) ? error.reason : "pool_empty";
+      return refuse(io, reasonCode, 3, Object.fromEntries(["reason", "detail", ...GUIDED_FIELDS].filter((key) => error[key] !== undefined).map((key) => [key, error[key]])), vars);
     }
     const code = typeof error?.code === "string" && isKnownCode(error.code) ? error.code : "pool_take_failed";
     return refuse(io, code, 3, { detail: String(error?.message ?? error).slice(0, 300) }, vars);

package/src/staging-pool/binding.mjs

@@ -73,7 +73,12 @@ export function parsePoolBinding(raw) {
   for (const [alias, persona] of Object.entries(personas)) {
     need(ALIAS_RE.test(alias), `persona alias "${alias}" must be a short lowercase slug`);
     need(persona && typeof persona.email === "string" && EMAIL_RE.test(persona.email), `persona ${alias} needs a seeded email`);
-    need(/\.(local|test)$/i.test(persona.email), `persona ${alias} must use a non-routable .local/.test seeded email`);
+    // BOT-2673: mirror the authenticated registry's single inbox exception.
+    const approvedInbox = raw.tenant === "supply-guard"
+      && section.app_origin === "https://enterprise-staging.vercel.app"
+      && section.supabase_url === "https://ikdoydgubernmxzdqtxz.supabase.co"
+      && persona.email.toLowerCase() === "staging+ent4086ac6@dorouarkii.resend.app";
+    need(/\.(local|test)$/i.test(persona.email) || approvedInbox, `persona ${alias} must use a non-routable .local/.test seed or the approved inbox for its staging target`);
     need(!emails.has(persona.email.toLowerCase()), `persona email ${persona.email} is listed twice`);
     emails.add(persona.email.toLowerCase());
     need(typeof persona.password_env === "string" && ENV_RE.test(persona.password_env), `persona ${alias} needs password_env (an UPPER_SNAKE env var name in password_env_file)`);

package/src/staging-pool/cli.mjs

@@ -40,6 +40,7 @@ import { createBotBuddyTotpProvider, probeBotBuddy } from "./totp-botbuddy.mjs";
 import { HUMAN_ONLY_COMMANDS, formatGuidance, guidance, installLine, isKnownCode, remedyLine } from "./errors.mjs";
 import { RegistryError, choosePool, fetchRegisteredPools, whoamiTenant } from "./registry.mjs";
 import { STAGING_POOL_HELP } from "./help.mjs";
+import { refreshExistingRuntime } from "./refresh-runtime.mjs";
 
 export const BUNDLE_FILES = Object.freeze([
   "binding.mjs",
@@ -54,6 +55,7 @@ export const BUNDLE_FILES = Object.freeze([
   "policy.mjs",
   "pool.mjs",
   "registry.mjs",
+  "refresh-runtime.mjs",
   "signin-gotrue-totp.mjs",
   "state-file.mjs",
   "totp-botbuddy.mjs",
@@ -359,6 +361,8 @@ export async function refusalFor({ argv, command, error, options = {}, home = ho
   // A pool refusal (pool_empty / unhealthy) already carries its health guidance;
   // an ordinary error's own message stays in `detail`.
   if (typeof error?.reason === "string") for (const field of GUIDANCE_FIELDS) if (error[field] !== undefined) record[field] = error[field];
+  // An unhealthy pool's refusal carries its health reason's guidance, so its code is that reason.
+  if (typeof error?.reason === "string" && error.reason !== code && error.reason !== "healthy" && isKnownCode(error.reason)) record.code = error.reason;
   record.remedy ??= remedyLine(g);
   if (humanOnly) Object.assign(record, { actor: g.actor_label, agentAction: "report_blocker" });
   // An empty pool is explained by its health reason (e.g. job_not_loaded).
@@ -453,6 +457,11 @@ export async function runStagingPool(argv, deps = {}) {
   }
 
   const commands = {
+    async "refresh-runtime"(options) {
+      emit(await refreshExistingRuntime({ options, home, uid, env, exec, bundleFiles: BUNDLE_FILES }));
+      return 0;
+    },
+
     async install(options) {
       // Human-only: refuse an agent session before any network or file call.
       assertMintAllowed({ target: { name: "staging", appOrigin: "the tenant's staging app", loopback: false }, env, listAncestors });

package/src/staging-pool/help.mjs

@@ -90,6 +90,13 @@ ANYONE (agents too) — read-only
       Prints the launchd plist install would write. Writes nothing.
       e.g. bb staging-pool print-plist
 
+ANYONE (agents too) — existing runtime maintenance, never sign-in
+  refresh-runtime --tenant <slug> --pool <pool_id>
+      Refreshes an already installed pool from its authenticated registration
+      and this published CLI package. Preserves credentials, sessions, counts,
+      interval and plist. The existing launchd job refills on its next tick.
+      No caller path or runtime content is accepted; no sign-in is performed.
+
 HUMAN ONLY (Jono, from Terminal.app or iTerm) — refused inside a Claude or Codex session
   These sign in with the persona password or change the standing sessions.
   install --tenant <slug> [--pool <pool_id>] --botbuddy-bin <absolute path> [--interval <seconds>]

package/src/staging-pool/refresh-runtime.mjs

@@ -0,0 +1,135 @@
+// BOT-2673: maintenance of an existing pool, never session production.
+// The shipped package is the only runtime source. The existing launchd job keeps
+// its stable entrypoint; a versioned runtime is published before its new config.
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import * as fs from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { ConfigError, serialiseInstalledConfig, validateInstalledConfig } from "./config.mjs";
+import { parsePoolBinding } from "./binding.mjs";
+import { stagingTargetFromBinding } from "./policy.mjs";
+import { choosePool, fetchRegisteredPools } from "./registry.mjs";
+
+const SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const denied = (message) => { throw new ConfigError(message, "config_invalid"); };
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+
+export async function refreshExistingRuntime({ options, home, uid, env, exec, bundleFiles }) {
+  if (Object.keys(options).some(key => !["tenant", "pool"].includes(key))) throw new ConfigError("refresh-runtime accepts only --tenant and --pool; it cannot select a path, binary, interval or persona.", "usage");
+  const { tenant, pool: poolId } = options;
+  if (!SLUG.test(tenant ?? "") || !SLUG.test(poolId ?? "")) throw new ConfigError("refresh-runtime requires --tenant <slug> and --pool <pool_id>.", "usage");
+  const root = join(home, ".botbuddy", "staging-session-pool", poolId);
+  const app = join(root, "app");
+  const configPath = join(root, "config.json");
+  const jobPath = join(app, "job.mjs");
+  async function owned(path, directory = false, privateFile = false) {
+    const info = await fs.lstat(path);
+    if (info.isSymbolicLink() || info.uid !== uid || (directory ? !info.isDirectory() : !info.isFile()) || (info.mode & (privateFile ? 0o077 : 0o022))) denied("Existing pool paths must be owned by this user, non-symlink and not writable by others.");
+    return info;
+  }
+  for (const path of [home, join(home, ".botbuddy"), join(home, ".botbuddy", "staging-session-pool"), root, app]) await owned(path, true);
+  await owned(jobPath);
+  async function configBytes() {
+    const handle = await fs.open(configPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      const info = await handle.stat();
+      if (!info.isFile() || info.uid !== uid || (info.mode & 0o077)) denied("Existing pool config must be an owner-only regular file.");
+      return await handle.readFile("utf8");
+    } finally { await handle.close(); }
+  }
+  const before = await configBytes();
+  const installed = validateInstalledConfig(JSON.parse(before));
+  const previous = installed.poolBinding;
+  if (previous.tenant !== tenant || previous.poolId !== poolId || (installed.tenant && installed.tenant !== tenant) || (installed.poolId && installed.poolId !== poolId)) denied("The existing pool identity does not match the requested authenticated tenant and pool.");
+  if (installed.source !== "control-plane") denied("refresh-runtime requires an existing control-plane pool; legacy installation migration remains human-owned.");
+  stagingTargetFromBinding(previous);
+
+  // No caller flag/dependency can choose the runtime source or CLI entrypoint.
+  const source = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = resolve(source, "../..");
+  const metadata = JSON.parse(await fs.readFile(join(packageRoot, "package.json"), "utf8"));
+  if (metadata.name !== "@botbuddy/cli" || !/^\d+\.\d+\.\d+$/.test(metadata.version)) denied("refresh-runtime requires an installed stable @botbuddy/cli package.");
+  for (const path of [join(packageRoot, ".git"), join(dirname(packageRoot), ".git")]) {
+    try { await fs.lstat(path); denied("Run refresh-runtime from the published CLI package, never a repository checkout."); }
+    catch (error) { if (error?.code !== "ENOENT") throw error; }
+  }
+  const cliEntry = join(packageRoot, "bin", "botbuddy.mjs");
+  const cliInfo = await fs.lstat(cliEntry);
+  if (!cliInfo.isFile() || cliInfo.isSymbolicLink() || (cliInfo.mode & 0o022)) denied("The package CLI entrypoint is not a safe regular file.");
+  const rows = await fetchRegisteredPools({
+    exec: (file, args, callOptions) => exec(process.execPath, [file, ...args], callOptions),
+    botbuddyBin: cliEntry, env, tenant, poolId, preserveAgentContext: true, requireTenantMatch: true,
+  });
+  const row = choosePool(rows, { tenant, poolId });
+  const rawBinding = { tenant, staging_session_pool: row.binding };
+  const next = parsePoolBinding(rawBinding);
+  stagingTargetFromBinding(next);
+  for (const field of ["tenant", "poolId", "environment", "appSlug", "adapter", "appOrigin", "supabaseUrl", "publishableKey", "storageKey", "passwordEnvFile", "launchdLabel"]) if (next[field] !== previous[field]) denied(`The registered pool changed its existing ${field}; refresh-runtime cannot retarget or reconfigure a standing job.`);
+  if (JSON.stringify([...next.productionOrigins].sort()) !== JSON.stringify([...previous.productionOrigins].sort())) denied("The registered production-origin policy changed; refresh-runtime cannot change a standing target policy.");
+  for (const [alias, persona] of Object.entries(previous.personas)) {
+    const registered = next.personas[alias];
+    if (!registered || registered.email !== persona.email || registered.passwordEnv !== persona.passwordEnv) denied("Existing persona aliases, emails and password variable names must be preserved.");
+  }
+  // Omission is an operator disable, not a missing default (Codex review).
+  const previousEmails = new Set(Object.values(previous.personas).map(persona => persona.email));
+  const personas = { ...installed.personas };
+  for (const persona of Object.values(next.personas)) if (!previousEmails.has(persona.email)) personas[persona.email] = persona.defaultCount;
+  const files = new Map();
+  const hash = createHash("sha256").update(metadata.version);
+  for (const name of bundleFiles) {
+    if (!/^[a-z0-9][a-z0-9.-]*\.mjs$/.test(name)) denied("The package runtime manifest is invalid.");
+    const path = join(source, name);
+    const info = await fs.lstat(path);
+    if (!info.isFile() || info.isSymbolicLink() || (info.mode & 0o022)) denied("Package runtime files must be safe regular files.");
+    const bytes = await fs.readFile(path);
+    files.set(name, bytes);
+    hash.update(name).update("\0").update(bytes);
+  }
+  files.set("package.json", Buffer.from('{"type":"module"}\n'));
+  const contentDigest = hash.digest("hex");
+  const runtimeName = `runtime-${metadata.version}-${contentDigest}`;
+  const runtime = join(root, runtimeName);
+  const config = validateInstalledConfig({ ...installed, binding: rawBinding, personas, source: "control-plane", tenant, poolId, registry: { commit_sha: row.commit_sha ?? null, updated_at: row.updated_at ?? null }, runtime: { version: metadata.version, sha256: contentDigest } });
+  const token = randomUUID();
+  const lockPath = join(root, ".runtime-refresh.lock");
+  const lock = await fs.open(lockPath, "wx", 0o600);
+  const lockInfo = await lock.stat();
+  let stage;
+  const configTemp = join(root, `.refresh-${token}.config.json`);
+  const jobTemp = join(app, `.refresh-${token}.job.mjs`);
+  try {
+    await lock.writeFile(token);
+    if (digest(await configBytes()) !== digest(before)) denied("The existing pool config changed during registry validation; no stale configuration is published.");
+    stage = await fs.mkdtemp(join(root, ".runtime-stage-"));
+    await fs.chmod(stage, 0o700);
+    for (const [name, bytes] of files) await fs.writeFile(join(stage, name), bytes, { mode: 0o600, flag: "wx" });
+    try { await fs.rename(stage, runtime); stage = undefined; }
+    catch (error) {
+      if (!["EEXIST", "ENOTEMPTY"].includes(error?.code)) throw error;
+      await owned(runtime, true);
+      if (JSON.stringify((await fs.readdir(runtime)).sort()) !== JSON.stringify([...files.keys()].sort())) denied("Existing versioned runtime differs from the package manifest.");
+      for (const [name, bytes] of files) {
+        await owned(join(runtime, name), false, true);
+        if (!(await fs.readFile(join(runtime, name))).equals(bytes)) denied("Existing versioned runtime differs from the package contents.");
+      }
+    }
+    await fs.writeFile(jobTemp, `// BotBuddy published runtime ${metadata.version} (${contentDigest})\nimport "../${runtimeName}/job.mjs";\n`, { mode: 0o600, flag: "wx" });
+    await owned(jobPath);
+    await fs.rename(jobTemp, jobPath);
+    // New code accepts the old config too. A crash between the two atomic
+    // publications leaves a valid standing job, never a partial JSON config.
+    if (digest(await configBytes()) !== digest(before)) denied("The pool config changed before publication; the existing config is preserved.");
+    await fs.writeFile(configTemp, serialiseInstalledConfig(config), { mode: 0o600, flag: "wx" });
+    await fs.rename(configTemp, configPath);
+    return { ok: true, command: "refresh-runtime", tenant, poolId, runtimeVersion: metadata.version, runtimeSha256: contentDigest, personaAliases: Object.keys(next.personas), producer: "existing launchd job; no sign-in or launchctl command was invoked" };
+  } finally {
+    if (stage) await fs.rm(stage, { recursive: true, force: true });
+    await fs.rm(configTemp, { force: true });
+    await fs.rm(jobTemp, { force: true });
+    const current = await fs.lstat(lockPath).catch(error => { if (error?.code === "ENOENT") return null; throw error; });
+    if (current?.ino === lockInfo.ino && current.dev === lockInfo.dev) await fs.unlink(lockPath);
+    await lock.close();
+  }
+}

package/src/staging-pool/registry.mjs

@@ -28,12 +28,12 @@ function childEnv(env) {
 }
 
 /** The tenant's registered pools: [{ pool_id, binding, commit_sha, updated_at }]. */
-export async function fetchRegisteredPools({ exec = defaultExec, botbuddyBin, env = process.env, tenant, poolId = null }) {
+export async function fetchRegisteredPools({ exec = defaultExec, botbuddyBin, env = process.env, tenant, poolId = null, preserveAgentContext = false, requireTenantMatch = false }) {
   if (!SLUG_RE.test(String(tenant ?? ""))) throw new RegistryError("tenant_required", "A --tenant slug is required.");
   let stdout;
   try {
     ({ stdout } = await exec(botbuddyBin, ["call", "get_staging_pool", "--pin", tenant, "--json", JSON.stringify(poolId ? { pool_id: poolId } : {})], {
-      env: childEnv(env),
+      env: preserveAgentContext ? { ...env } : childEnv(env),
       timeout: 60_000,
       maxBuffer: 1024 * 1024,
     }));
@@ -51,6 +51,7 @@ export async function fetchRegisteredPools({ exec = defaultExec, botbuddyBin, en
     const code = body.code === "tenant_required" ? "tenant_required" : "pool_registry_unavailable";
     throw new RegistryError(code, `get_staging_pool refused: ${String(body.code ?? "error")}`, { tenant });
   }
+  if (requireTenantMatch && body?.tenant !== tenant) throw new RegistryError("pool_registry_unavailable", "get_staging_pool returned a different or unknown authenticated tenant.", { tenant });
   if (!Array.isArray(body?.pools)) throw new RegistryError("pool_registry_unavailable", "get_staging_pool returned no pool list.", { tenant });
   return body.pools.filter((row) => row && typeof row.pool_id === "string" && row.binding && typeof row.binding === "object");
 }