@botbuddy/cli 1.63.44 → 1.64.1

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.63.44",
-  "source_commit": "6fb9ea556869f4b6bb5b1851941dc348009198ff",
-  "source_sha256": "175730f9512d5a1fa81e4800f0be93420e5fd91f1968bba4cd264611b8ae0f82",
+  "release_version": "1.64.1",
+  "source_commit": "fd01ca263ebebf1dda5ec3648d5300a788ee7887",
+  "source_sha256": "75f8bdc7954b24d97d7da80abe41f3814bf9bc9f9c00558d26cb78c030b58475",
   "target": "darwin-arm64",
-  "sha256": "1740585f4d9e5ce03d798353c1c473b6b818191f83d3a6e63b8e94f6e5d975bb"
+  "sha256": "929631f9c2d05a901a16e8ba132c4166ca62b2c7b30ab5b8317cbcd59c49ee79"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.63.44",
-  "source_commit": "6fb9ea556869f4b6bb5b1851941dc348009198ff",
-  "source_sha256": "175730f9512d5a1fa81e4800f0be93420e5fd91f1968bba4cd264611b8ae0f82",
+  "release_version": "1.64.1",
+  "source_commit": "fd01ca263ebebf1dda5ec3648d5300a788ee7887",
+  "source_sha256": "75f8bdc7954b24d97d7da80abe41f3814bf9bc9f9c00558d26cb78c030b58475",
   "target": "linux-x64",
-  "sha256": "93c1837e1aad2e8cb048399e57d2d4504db08d5edda38a92369558ceb4c4e8c4"
+  "sha256": "fc806cb0d6193a2c6c55eb076a28575b1fabc80955f4f9669b9f15269cbcdabb"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.63.44",
-  "source_commit": "6fb9ea556869f4b6bb5b1851941dc348009198ff",
-  "source_sha256": "175730f9512d5a1fa81e4800f0be93420e5fd91f1968bba4cd264611b8ae0f82",
+  "release_version": "1.64.1",
+  "source_commit": "fd01ca263ebebf1dda5ec3648d5300a788ee7887",
+  "source_sha256": "75f8bdc7954b24d97d7da80abe41f3814bf9bc9f9c00558d26cb78c030b58475",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "1740585f4d9e5ce03d798353c1c473b6b818191f83d3a6e63b8e94f6e5d975bb",
+      "sha256": "929631f9c2d05a901a16e8ba132c4166ca62b2c7b30ab5b8317cbcd59c49ee79",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "93c1837e1aad2e8cb048399e57d2d4504db08d5edda38a92369558ceb4c4e8c4",
+      "sha256": "fc806cb0d6193a2c6c55eb076a28575b1fabc80955f4f9669b9f15269cbcdabb",
       "mode": "0755"
     }
   }

package/package.json

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

package/src/daemon/automatic.mjs

@@ -0,0 +1,81 @@
+import { callToolJson, resolveCallAuth } from "../api.mjs";
+import {
+  assertSshHost,
+  installedBinaryPath,
+  stageRemoteDaemonRelease,
+} from "./installer.mjs";
+import { validateDaemonRelease } from "./release.mjs";
+import { nativeHandoverCommand } from "./handover.mjs";
+const fail = (code) => {
+  throw new Error(code);
+};
+// One explicit administrator installation grants only the fixed native
+// coordinator/schedule. Persisted operator opt-in remains a separate drawer act.
+export async function installAutomaticDaemonUpdater(spec, {
+  validateRelease = validateDaemonRelease,
+  resolveAuth = resolveCallAuth,
+  identity = callToolJson,
+  stage = stageRemoteDaemonRelease,
+  native = nativeHandoverCommand,
+} = {}) {
+  if (
+    !spec || typeof spec !== "object" || Array.isArray(spec) ||
+    Object.keys(spec).some((key) =>
+      ![
+        "platform",
+        "arch",
+        "sshHost",
+        "serviceUser",
+        "releaseRoot",
+        "expectedHostKey",
+        "tenant",
+      ].includes(key)
+    ) || !["linux", "darwin"].includes(spec.platform) ||
+    typeof spec.serviceUser !== "string" || spec.serviceUser === "root" ||
+    !/^[a-z_][a-z0-9_-]*$/i.test(spec.serviceUser) ||
+    !/^bbh-[0-9a-f]{24}$/.test(spec.expectedHostKey) ||
+    typeof spec.tenant !== "string" || !spec.tenant
+  ) fail("daemon_automatic_install_spec_invalid");
+  assertSshHost(spec.sshHost);
+  const release = await validateRelease({ releaseRoot: spec.releaseRoot }, {
+    platform: spec.platform,
+    arch: spec.arch,
+  });
+  const resolved = await resolveAuth({
+    toolName: "daemon_handover",
+    preferSession: false,
+  });
+  if (resolved?.error || !resolved?.auth) {
+    fail("daemon_automatic_install_auth_required");
+  }
+  const who = await identity("whoami", {}, {
+    auth: resolved.auth,
+    tenant: spec.tenant,
+  });
+  if (
+    !who?.ok || who.isError || typeof who.data?.owner_email !== "string" ||
+    !who.data.owner_email.includes("@") || who.data.tenant_id !== spec.tenant
+  ) fail("daemon_automatic_install_owner_unavailable");
+  const staged = await stage({
+    platform: spec.platform,
+    host: spec.sshHost,
+    user: spec.serviceUser,
+    release,
+  });
+  const binary = installedBinaryPath(release);
+  if (staged?.binary !== binary) fail("daemon_automatic_install_stage_invalid");
+  const result = await native({
+    host: spec.sshHost,
+    binary,
+    mode: "automatic-install",
+    input: {
+      host_key: spec.expectedHostKey,
+      owner_email: who.data.owner_email,
+      tenant_id: who.data.tenant_id,
+    },
+  });
+  if (result?.installed !== true || result.protocol !== 2) {
+    fail("daemon_automatic_install_receipt_invalid");
+  }
+  return { installed: true, protocol: 2, host_key: spec.expectedHostKey };
+}

package/src/daemon/commands.mjs

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { registerContainerHost } from "../api.mjs";
+import { installAutomaticDaemonUpdater } from "./automatic.mjs";
 import { upgradeDaemonHost } from "./handover.mjs";
 import { awaitHostApproval } from "./approval-wait.mjs";
 import { bootstrapFreshDaemon } from "./bootstrap.mjs";
@@ -49,6 +50,7 @@ export const daemonHelp = `Usage:
   bb daemon config-render '<json host policy>'
   bb daemon enroll '<json host-bound enrollment spec>'
   bb daemon bootstrap '<json fresh-host bootstrap spec>'
+  bb daemon updater-install '<json automatic updater installation spec>'
   bb daemon upgrade '<json controlled host upgrade spec>'
 
 The Go payload is verified from the extracted universal package before sudo.
@@ -293,6 +295,7 @@ export async function cmdDaemon(args, {
   verifyRemoteHelperIdentity = verifyRemoteHelperIdentityOnTarget,
   bootstrap = bootstrapFreshDaemon,
   upgrade = upgradeDaemonHost,
+  installAutomaticUpdater = installAutomaticDaemonUpdater,
   registerHost = registerContainerHost,
   createBootstrapIdentity = createRemoteBootstrapIdentity,
   inspectBootstrapIdentity = inspectRemoteBootstrapIdentity,
@@ -305,6 +308,11 @@ export async function cmdDaemon(args, {
     log(daemonHelp);
     return 0;
   }
+  if(args[0]==="updater-install"){
+    if(args.length!==2)fail("Usage: bb daemon updater-install '<json automatic updater installation spec>'");
+    let spec;try{spec=JSON.parse(args[1]);}catch{fail("daemon_automatic_install_spec_invalid");}
+    log(JSON.stringify(await installAutomaticUpdater(spec)));return 0;
+  }
   if(args[0]==="upgrade"){
     if(args.length!==2)fail("Usage: bb daemon upgrade '<json controlled host upgrade spec>'");
     let spec;try{spec=JSON.parse(args[1]);}catch{fail("daemon_handover_spec_invalid");}

package/src/daemon/handover.mjs

@@ -27,9 +27,9 @@ export function nativeHandoverCommand(
   { spawnImpl = spawn } = {},
 ) {
   if (
-    !immutableBinaryRE.test(binary) || !["inspect", "submit"].includes(mode)
+    !immutableBinaryRE.test(binary) || !["inspect", "submit", "automatic-install"].includes(mode)
   ) fail("daemon_handover_command_invalid");
-  const flag = mode === "inspect"
+  const flag = mode === "automatic-install" ? "--native-automatic-update-install" : mode === "inspect"
     ? "--native-handover-inspect"
     : "--native-handover-submit";
   let command = "sudo", args = ["-n", binary, flag];

package/src/pw/staging-auth.mjs

@@ -263,6 +263,35 @@ export function refuse({ stdout, stderr }, code, exitCode = 3, extra = {}, vars
 async function loadPool() { return import("../staging-pool/cli.mjs"); }
 async function loadBinding() { return import("../staging-pool/binding.mjs"); }
 
+// BOT-2894: pool_empty is an agent-visible symptom, but recovery is owned by
+// the control plane. This fixed call sends only the registered tenant/pool and
+// persona; no host, path, command, credential or retry policy can cross it.
+async function requestPoolRefill({ ctxPool, persona, deps, env }) {
+  try {
+    if (deps.requestPoolRefill) return await deps.requestPoolRefill({
+      tenant: ctxPool.tenant, poolId: ctxPool.poolId, persona,
+    });
+    const bin = ctxPool.installed?.botbuddyBin;
+    if (!bin || !ctxPool.tenant) return { ok: false, code: "POOL_REFILL_UNAVAILABLE" };
+    const run = deps.poolRefillExec ?? execFileSync;
+    const stdout = String(run(bin, ["call", "request_staging_pool_refill", "--pin", ctxPool.tenant, "--json", JSON.stringify({ pool_id: ctxPool.poolId, persona })], {
+      encoding: "utf8", timeout: 10_000, env, stdio: ["ignore", "pipe", "ignore"],
+    }));
+    const parsed = JSON.parse(stdout);
+    return {
+      ok: parsed?.ok === true,
+      ...(typeof parsed?.job_id === "string" ? { job_id: parsed.job_id } : {}),
+      ...(typeof parsed?.status === "string" ? { status: parsed.status } : {}),
+      ...(typeof parsed?.code === "string" ? { code: parsed.code } : {}),
+    };
+  } catch {
+    // Recovery request failure does not turn an already truthful pool_empty
+    // into a hidden success. The one wait/retry remains bounded and reports its
+    // original symptom; the next attempt will request recovery again.
+    return { ok: false, code: "POOL_REFILL_UNAVAILABLE" };
+  }
+}
+
 /**
  * `auth --persona <alias>` after the wrapper has proven: environment=staging, a
  * lock-gated lane held by this exact agent, and a staging (or untracked) browser
@@ -316,13 +345,23 @@ 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") {
+      const refill = await requestPoolRefill({ ctxPool, persona: persona.email, deps, env });
       // 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";
+      // A terminal refill receipt is a real, durable recovery boundary. Keep
+      // the old bounded timer only when the request could not return a job id.
+      const refillNext = refill.ok === true && typeof refill.job_id === "string"
+        ? `bb wait 'staging-pool-refill:id=${refill.job_id}' && ${vars.retry ?? authLine}   # once; if it fails, report this code`
+        : undefined;
       // BOT-2836: a healthy empty pool is the agent's own wait-and-retry, so it is
       // rendered here with this lane; an unhealthy pool keeps the pool's health guidance.
       const forwarded = reasonCode === "pool_empty" ? ["reason", "detail"] : ["reason", "detail", ...GUIDED_FIELDS];
-      return refuse(io, reasonCode, 3, Object.fromEntries(forwarded.filter((key) => error[key] !== undefined).map((key) => [key, error[key]])), vars);
+      return refuse(io, reasonCode, 3, {
+        ...Object.fromEntries(forwarded.filter((key) => error[key] !== undefined).map((key) => [key, error[key]])),
+        ...(refillNext ? { next: refillNext } : {}),
+        automatic_refill: refill.ok === true ? { requested: true, ...(refill.job_id ? { job_id: refill.job_id } : {}), ...(refill.status ? { status: refill.status } : {}) } : { requested: false, code: refill.code },
+      }, 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/cli.mjs

@@ -514,6 +514,7 @@ export async function runStagingPool(argv, deps = {}) {
         rawBinding,
         poolBinding,
         botbuddyBin,
+        nodeBin,
         intervalSeconds: explicitInterval ?? existing?.intervalSeconds ?? DEFAULT_INTERVAL_SECONDS,
         existingPersonas: existing?.personas,
         tenant,

package/src/staging-pool/config.mjs

@@ -37,7 +37,7 @@ export function poolHomePaths({ home = homedir(), poolId, root } = {}) {
 }
 
 // The installed config: { version, binding: <raw .botbuddy-agent.json subset>,
-// personas: { email: count }, botbuddyBin, intervalSeconds }. Returns it with the
+// personas: { email: count }, botbuddyBin, nodeBin, intervalSeconds }. Returns it with the
 // parsed binding attached as `poolBinding`.
 export function validateInstalledConfig(config) {
   if (!config || typeof config !== "object") throw new ConfigError("Pool config is not an object.", "config_invalid");
@@ -52,6 +52,11 @@ export function validateInstalledConfig(config) {
   if (typeof config.botbuddyBin !== "string" || !config.botbuddyBin.startsWith("/")) {
     throw new ConfigError("Pool config botbuddyBin must be an absolute path (re-run install).", "config_invalid");
   }
+  // `nodeBin` is added by BOT-2894. Older human-installed pools remain valid,
+  // but an autonomous Helper may only advertise a pool that pins its runtime.
+  if (config.nodeBin !== undefined && (typeof config.nodeBin !== "string" || !config.nodeBin.startsWith("/"))) {
+    throw new ConfigError("Pool config nodeBin must be an absolute path (re-run install).", "config_invalid");
+  }
   if (!Number.isInteger(config.intervalSeconds) || config.intervalSeconds < 60 || config.intervalSeconds > 3600) {
     throw new ConfigError("Pool config intervalSeconds must be an integer 60-3600.", "config_invalid");
   }
@@ -87,7 +92,7 @@ export function readInstalledConfig(path, { readFile = readFileSync } = {}) {
 }
 
 // rawBinding: { tenant, staging_session_pool } exactly as committed.
-export function buildInstalledConfig({ rawBinding, poolBinding, botbuddyBin, intervalSeconds = DEFAULT_INTERVAL_SECONDS, existingPersonas, tenant, registry, installedAt }) {
+export function buildInstalledConfig({ rawBinding, poolBinding, botbuddyBin, nodeBin, intervalSeconds = DEFAULT_INTERVAL_SECONDS, existingPersonas, tenant, registry, installedAt }) {
   const personas = {};
   for (const persona of Object.values(poolBinding.personas)) {
     personas[persona.email] = Number.isInteger(existingPersonas?.[persona.email]) ? existingPersonas[persona.email] : persona.defaultCount;
@@ -97,6 +102,7 @@ export function buildInstalledConfig({ rawBinding, poolBinding, botbuddyBin, int
     binding: { tenant: rawBinding.tenant, staging_session_pool: rawBinding.staging_session_pool },
     personas,
     botbuddyBin,
+    ...(nodeBin ? { nodeBin } : {}),
     intervalSeconds,
     // BOT-2648: installed from the tenant's control-plane registration.
     ...(tenant ? { tenant, poolId: poolBinding.poolId, source: "control-plane" } : {}),

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

@@ -91,7 +91,7 @@ export async function refreshExistingRuntime({ options, home, uid, env, exec, bu
   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 config = validateInstalledConfig({ ...installed, binding: rawBinding, personas, nodeBin: installed.nodeBin ?? await fs.realpath(process.execPath), 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);

package/src/wait-core.mjs

@@ -216,6 +216,15 @@ const VALIDATORS = {
     }
     return { runId };
   },
+  "staging-pool-refill": (p, raw) => {
+    const pair = /^\s*id\s*=\s*([0-9A-Fa-f-]+)\s*$/.exec(raw ?? "");
+    if (!pair || Object.keys(p).length !== 1 || p.id !== pair[1]) {
+      throw new Error("staging-pool-refill needs exactly one id=<refill job UUID>");
+    }
+    const jobId = pair[1].toLowerCase();
+    if (!CANONICAL_UUID_RE.test(jobId)) throw new Error("staging-pool-refill id must be a canonical UUID");
+    return { jobId };
+  },
   // BOT-2629: this is deliberately a dedicated condition rather than a raw
   // event escape hatch. The UUID is chosen before dispatch and the exact subject
   // prevents another run on the same idle/re-adopted lease waking this waiter.
@@ -1295,6 +1304,11 @@ function conditionMatchesSignal(condition, signal, waitSessionId) {
         signal.subject_key === `run:${params.runId}` &&
         signal.payload?.run_id === params.runId &&
         COMMAND_RUN_TERMINAL_STATUSES.has(signal.payload?.status);
+    case "staging-pool-refill":
+      return signal.signal_type === "staging_pool_refill" &&
+        signal.subject_key === `staging-pool-refill:${params.jobId}` &&
+        signal.payload?.job_id === params.jobId &&
+        ["completed", "failed"].includes(signal.payload?.status);
     case "stack-run":
       return signal.signal_type === "stack_run" && signal.subject_key === `stack-run:${params.id}` &&
         signal.payload?.run_id === params.id && Number.isInteger(signal.payload?.exit_code);

package/src/wait.mjs

@@ -165,6 +165,10 @@ CONDITIONS  (TYPE:key=val,key=val — repeat for several; --any wakes on the fir
                                       condition, and keep this wait's result pending: its
                                       return is what resumes your task. A run whose worker is
                                       lost ends owner_lost (bb run inspect <run_id>).
+  staging-pool-refill:id=<job UUID>   BOT-2894: a requested staging-pool refill reaching
+                                      completed or failed. This is the only condition of its
+                                      wait and is available to each tenant agent that requested
+                                      the deduped job; its terminal receipt is safe to display.
   stack-run:id=<run UUID>             one named bb stack run reaching its terminal outcome
                                       (BOT-2629). Choose the UUID BEFORE dispatch and pass it as
                                       bb stack run --run-id <UUID>; the receipt carries exit_code,
@@ -648,6 +652,8 @@ async function registerWait(opts, conditions, deadlineIso) {
       // back to an untracked wait would only hide that error behind a timeout.
       "command_run_unavailable",
       "command_run_single_condition_required",
+      "staging_pool_refill_unavailable",
+      "staging_pool_refill_single_condition_required",
     ]);
     if (INVALID_CONDITION_CODES.has(body.error)) {
       const err = new Error(body.detail || body.error);