@botbuddy/cli 1.63.6 → 1.63.8

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.63.6",
-  "source_commit": "5c72f5b01f85d06bd437e50a6d3515bbf9871230",
-  "source_sha256": "f96b0407034852d7a2c255176a4dcce9297fe6aaec8311f4b25bb70ffbfa5fa8",
+  "release_version": "1.63.8",
+  "source_commit": "f26ae5e2838d2cd2bb8125f238e48ea9ae87c74c",
+  "source_sha256": "4e4cf641d3c4675efbf172dfa759d31c016d30700ca195f7b3cbc399459ede98",
   "target": "darwin-arm64",
-  "sha256": "f31b5ae401c2b404d0b321f2ed7864afbeadb45080069daf6fd5a4830b1c0546"
+  "sha256": "cba79a67f58f0bde2d0f20b5c92c2734b468b0ca038ee83d020e325ab06c79fe"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.63.6",
-  "source_commit": "5c72f5b01f85d06bd437e50a6d3515bbf9871230",
-  "source_sha256": "f96b0407034852d7a2c255176a4dcce9297fe6aaec8311f4b25bb70ffbfa5fa8",
+  "release_version": "1.63.8",
+  "source_commit": "f26ae5e2838d2cd2bb8125f238e48ea9ae87c74c",
+  "source_sha256": "4e4cf641d3c4675efbf172dfa759d31c016d30700ca195f7b3cbc399459ede98",
   "target": "linux-x64",
-  "sha256": "ca5a27989617f81c17b84ef2b160a845b7f65017aada19ec032853d826eaf713"
+  "sha256": "bf0458ea4d5a2aa36d5de5b374283a3f21c677f42a9afe5f3dcaf1a74807809a"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.63.6",
-  "source_commit": "5c72f5b01f85d06bd437e50a6d3515bbf9871230",
-  "source_sha256": "f96b0407034852d7a2c255176a4dcce9297fe6aaec8311f4b25bb70ffbfa5fa8",
+  "release_version": "1.63.8",
+  "source_commit": "f26ae5e2838d2cd2bb8125f238e48ea9ae87c74c",
+  "source_sha256": "4e4cf641d3c4675efbf172dfa759d31c016d30700ca195f7b3cbc399459ede98",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "f31b5ae401c2b404d0b321f2ed7864afbeadb45080069daf6fd5a4830b1c0546",
+      "sha256": "cba79a67f58f0bde2d0f20b5c92c2734b468b0ca038ee83d020e325ab06c79fe",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "ca5a27989617f81c17b84ef2b160a845b7f65017aada19ec032853d826eaf713",
+      "sha256": "bf0458ea4d5a2aa36d5de5b374283a3f21c677f42a9afe5f3dcaf1a74807809a",
       "mode": "0755"
     }
   }

package/package.json

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

package/src/run-delivery.mjs

@@ -467,7 +467,7 @@ export async function runDelivery({
  * small reads. Never throws into the caller's command.
  */
 export async function ensureRunDelivery({
-  home = homedir(), env = process.env, spawnImpl = spawn, isAlive = pidAlive, force = false, cooldownMs = DELIVERY_RESCAN_COOLDOWN_MS,
+  home = homedir(), env = process.env, spawnImpl = spawn, isAlive = pidAlive, force = false, cooldownMs = DELIVERY_RESCAN_COOLDOWN_MS, now = Date.now, stateStat = stat,
 } = {}) {
   try {
     if (env.BOTBUDDY_RUN_DELIVERY === "off") return { started: false, reason: "disabled" };
@@ -480,7 +480,8 @@ export async function ensureRunDelivery({
     // starts us itself (force) when it parks, so otherwise scan at most once
     // per cooldown. Both times are this machine's filesystem clock.
     if (!force && state) {
-      const stateAge = Date.now() - (await stat(deliveryStatePath(home))).mtimeMs;
+      // Date.now() has millisecond precision; APFS mtime may carry fractions.
+      const stateAge = now() - Math.floor((await stateStat(deliveryStatePath(home))).mtimeMs);
       if (stateAge >= 0 && stateAge < cooldownMs) return { started: false, reason: "cooldown" };
     }
     const holder = await readJson(deliveryLockPath(home));

package/src/stack-service-discovery.mjs

@@ -0,0 +1,114 @@
+// BOT-2776: fixed compatibility names for the verified Supabase HTTP/database
+// services. This is deliberately not a suffix rule or an endpoint registry.
+const known = new Map([
+  ["api", ["api", "api", "http"]], ["api-port", ["api", "api", "http"]],
+  ["db", ["db", "db", "postgres"]], ["db-port", ["db", "db", "postgres"]],
+  ["inbucket", ["inbucket", "mail_http", "http"]], ["inbucket-port", ["inbucket", "mail_http", "http"]],
+  ["mailpit", ["mailpit", "mail_http", "http"]], ["mailpit-port", ["mailpit", "mail_http", "http"]],
+  ["local_smtp", ["inbucket", "mail_http", "http"]], ["local_smtp-port", ["inbucket", "mail_http", "http"]],
+]);
+const port = (n) => Number.isInteger(n) && n > 0 && n <= 65535;
+const fail = (message, code = "STACK_SERVICE_AMBIGUOUS") => Object.assign(new Error(message), { code });
+
+function declaredSchema(connection) {
+  if (!connection || typeof connection !== "object" || Array.isArray(connection)) throw fail("invalid producer connection", "REMOTE_CONNECTION_INVALID");
+  if (connection.services == null) return;
+  if (connection.services.schema_version !== 1) throw fail("unsupported stack service schema", "STACK_SERVICE_SCHEMA_UNSUPPORTED");
+  if (!Array.isArray(connection.services.entries) || connection.services.entries.length > 3
+    || connection.services.entries.some((e) => !["api", "db", "mail_http"].includes(e?.id))
+    || new Set(connection.services.entries.map((e) => e.id)).size !== connection.services.entries.length) {
+    throw fail("invalid or unknown declared stack service");
+  }
+}
+
+function metadata(ports, producerPorts, forwards) {
+  const entries = [];
+  for (const row of ports) {
+    const forward = forwards.find((f) => f.name === row.name && f.remote === row.port);
+    if (!forward) throw fail("service forward does not match the producer target");
+    const descriptor = known.get(row.name);
+    if (!descriptor) continue;
+    const [, id, protocol] = descriptor;
+    entries.push({ id, name: row.name, protocol, port: forward.local, remote_port: forward.remote,
+      producer_names: producerPorts.filter((p) => known.get(p.name)?.[1] === id).map((p) => p.name) });
+  }
+  return { schema_version: 1, producer_ports: producerPorts, entries };
+}
+
+function validateDeclaredMetadata(declared, expected) {
+  if (declared == null) return;
+  const keys = (object, fields) => Object.keys(object).length === fields.length && fields.every((k) => Object.hasOwn(object, k));
+  if (!keys(declared, ["schema_version", "producer_ports", "entries"])
+    || !Array.isArray(declared.producer_ports) || declared.producer_ports.length !== expected.producer_ports.length
+    || declared.entries.length !== expected.entries.length) throw fail("declared services contradict producer targets");
+  for (const [i, row] of declared.producer_ports.entries()) {
+    if (!row || !keys(row, ["name", "port"]) || row.name !== expected.producer_ports[i].name || row.port !== expected.producer_ports[i].port) throw fail("declared service provenance contradicts producer ports");
+  }
+  for (const entry of declared.entries) {
+    const target = expected.entries.find((row) => row.id === entry.id);
+    if (!target || !keys(entry, ["id", "name", "protocol", "port", "remote_port", "producer_names"])
+      || ["name", "protocol", "port", "remote_port"].some((k) => entry[k] !== target[k])
+      || !Array.isArray(entry.producer_names) || JSON.stringify(entry.producer_names) !== JSON.stringify(target.producer_names)) throw fail("declared service contradicts its canonical target");
+  }
+}
+
+function urlPort(raw, protocols, label) {
+  try {
+    if (typeof raw !== "string" || /[\u0000-\u0020\u007f]/.test(raw)) throw new Error();
+    const u = new URL(raw);
+    const literal = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]*@)?(?:127\.0\.0\.1|localhost|\[::1\]):(\d+)(?:[/?#]|$)/i.exec(raw);
+    const number = Number(literal?.[1]);
+    // Match the existing transport's literal rewrite contract too: URL() alone
+    // normalizes e.g. 127.1 and erases explicitly declared HTTP80/HTTPS443.
+    // A literal port is always required; normalization must agree with it.
+    const agrees = u.port ? Number(u.port) === number
+      : u.protocol === "http:" && number === 80 || u.protocol === "https:" && number === 443;
+    if (!protocols.includes(u.protocol) || !["127.0.0.1", "localhost", "[::1]"].includes(u.hostname) || !port(number) || !agrees) throw new Error();
+    return number;
+  } catch { throw fail(`invalid ${label} service URL`, "REMOTE_CONNECTION_INVALID"); }
+}
+
+/** Keep one row per physical port. URL anchors are not duplicate producer rows. */
+export function canonicalStackPorts(connection) {
+  declaredSchema(connection);
+  const api = urlPort(connection?.api_url, ["http:", "https:"], "api_url");
+  let db = connection?.db_port;
+  const dbURL = connection?.db_url == null ? null : urlPort(connection.db_url, ["postgres:", "postgresql:"], "db_url");
+  if (db != null && (!port(db) || dbURL != null && db !== dbURL)) throw fail("database service port conflicts with db_url");
+  db ??= dbURL;
+  const anchors = new Map([["api", api], ...(db == null ? [] : [["db", db]])]);
+  const raw = connection.ports ?? [];
+  if (!Array.isArray(raw) || raw.length > 32) throw fail("invalid producer service port table", "REMOTE_CONNECTION_INVALID");
+  const names = new Set(), numbers = new Set(), ids = new Set();
+  const result = [...anchors].map(([name, value]) => ({ name, port: value }));
+  if (new Set(result.map((r) => r.port)).size !== result.length) throw fail("API and database cannot share a service port");
+  for (const row of raw) {
+    if (typeof row?.name !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(row.name) || !port(row.port)) {
+      throw fail("invalid port or producer service name", "REMOTE_CONNECTION_INVALID");
+    }
+    if (names.has(row.name) || numbers.has(row.port)) throw fail("duplicate producer service names or ports");
+    names.add(row.name); numbers.add(row.port);
+    const descriptor = known.get(row.name);
+    const [name, id] = descriptor ?? [row.name, null];
+    if (id && ids.has(id)) throw fail(`conflicting aliases for ${id}`);
+    if (id) ids.add(id);
+    if (anchors.has(id)) {
+      if (anchors.get(id) !== row.port) throw fail(`${id} producer port conflicts with its service URL`);
+      continue;
+    }
+    if (result.some((r) => r.name === name || r.port === row.port)) throw fail("ambiguous producer service target");
+    result.push({ name, port: row.port });
+  }
+  validateDeclaredMetadata(connection.services, metadata(result, raw.map(({ name, port }) => ({ name, port })), result.map(({ name, port }) => ({ name, local: port, remote: port }))));
+  return result;
+}
+
+/** Additive discovery only: authority remains the live owning tunnel's table. */
+export function stackServicesForForwards(connection, forwards) {
+  const ports = canonicalStackPorts(connection);
+  if (!Array.isArray(forwards) || forwards.length !== ports.length
+    || forwards.some((f) => !port(f?.local) || !port(f?.remote))
+    || ["name", "local", "remote"].some((key) => new Set(forwards.map((f) => f[key])).size !== forwards.length)) throw fail("invalid live service forward table");
+  const producerPorts = (connection.ports ?? []).map(({ name, port }) => ({ name, port }));
+  return metadata(ports, producerPorts, forwards);
+}

package/src/stack-tunnel.mjs

@@ -23,6 +23,7 @@
 
 import { spawn, spawnSync } from "node:child_process";
 import { connect, createServer, isIP } from "node:net";
+import { canonicalStackPorts, stackServicesForForwards } from "./stack-service-discovery.mjs";
 
 export const SSH_FORWARD_OPTIONS = Object.freeze([
   "-N", "-T",
@@ -90,30 +91,8 @@ function validPort(value) {
   return Number.isInteger(n) && n > 0 && n <= 65535 ? n : null;
 }
 
-function urlPort(url) {
-  if (typeof url !== "string") return null;
-  const match = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]*@)?(?:\[[^\]]+\]|[^:/?#]+):(\d+)/i.exec(url.trim());
-  return match ? validPort(match[1]) : null;
-}
-
 /** Every stack port the child may touch: api + db always, then `connection.ports[]`. */
-export function remotePortsFromConnection(connection) {
-  const ports = [];
-  const add = (name, raw) => {
-    const port = validPort(raw);
-    if (port == null) throw tunnelError("REMOTE_CONNECTION_INVALID", `the remote lease connection has an invalid port for ${name}: ${raw}`);
-    if (!ports.some((p) => p.port === port)) ports.push({ name, port });
-  };
-  const api = urlPort(connection?.api_url);
-  if (api == null) throw tunnelError("REMOTE_CONNECTION_INVALID", "the remote lease connection has no api_url with an explicit port");
-  add("api", api);
-  const db = validPort(connection?.db_port) ?? urlPort(connection?.db_url);
-  if (db != null) add("db", db);
-  for (const entry of Array.isArray(connection?.ports) ? connection.ports : []) {
-    add(String(entry?.name ?? "port"), entry?.port);
-  }
-  return ports;
-}
+export function remotePortsFromConnection(connection) { return canonicalStackPorts(connection); }
 
 /** True when 127.0.0.1:<port> can be bound right now. */
 export function isLocalPortFree(port) {
@@ -186,6 +165,7 @@ export function rewriteConnectionForForwards(connection, forwards) {
   const db = validPort(connection?.db_port);
   if (db != null && byRemote.has(db)) out.db_port = byRemote.get(db);
   out.ports = forwards.map((f) => ({ name: f.name, port: f.local, remote_port: f.remote }));
+  out.services = stackServicesForForwards(connection, forwards);
   out.transport = "ssh-forward";
   return out;
 }

package/src/stack.mjs

@@ -50,6 +50,7 @@ import { machineUuid } from "./machine-id.mjs";
 import { DEFAULT_BUNDLE_MAX_BYTES, buildStackBundle, uploadStackBundle, validateBundleIncludePath } from "./stack-bundle.mjs";
 import { assertSshTarget, establishSshTunnel } from "./stack-tunnel.mjs";
 import { FORWARD_ATTESTATION_ENV, startForwardAttestation, readForwardAttestation } from "./stack-forward-attestation.mjs";
+import { stackServicesForForwards } from "./stack-service-discovery.mjs";
 import { ENGINE_PUBLISHES_BEYOND_LOOPBACK, engineSocketIsLocal, formatPublishIp, isLoopbackIp, publishIpFix, resolvePublishIp } from "./docker-publish-ip.mjs";
 import { bold, dim, yellow } from "./utils.mjs";
 import { reportStackRunOutcome } from "./stack-run-outcome.mjs";
@@ -3004,13 +3005,18 @@ export async function cmdStatus(leaseId, opts, {
     : emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, error: got.error }), opts, EXIT.BACKEND);
   const g = got.data;
   if (!g.success) return emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, code: g.code, error: g.code }), opts, EXIT.BACKEND);
-  let forwards;
+  let forwards, services;
   if (g.state === "active" && forwardSocket) {
     try {
       forwards = await readForwardAttestation({ socketPath: forwardSocket, leaseId, sshTarget: g.connection?.ssh_target ?? g.ssh_target });
     } catch {
       return emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, code: "FORWARD_ATTESTATION_UNAVAILABLE", error: "live stack forward attestation unavailable" }), opts, EXIT.BACKEND);
     }
+    try {
+      services = stackServicesForForwards(g.connection, forwards);
+    } catch (error) {
+      return emitResult(buildReceipt({ command: "status", outcome: "error", lease_id: leaseId, code: error?.code ?? "STACK_SERVICE_AMBIGUOUS", error: "live service forwards do not match the authenticated producer connection" }), opts, EXIT.BACKEND);
+    }
   }
   // BOT-2019: a queued lease names its server dispatch rank (or why it has none) and the
   // ticket it is scored under; a null position is reported, never a crash.
@@ -3022,6 +3028,7 @@ export async function cmdStatus(leaseId, opts, {
     host_key: g.host_key, slot: g.slot,
     connection: forwards ? { ...g.connection, ssh_target: g.connection?.ssh_target ?? g.ssh_target } : g.connection,
     ...(forwards ? { forwards } : {}),
+    ...(services ? { services } : {}),
     ...(queued ? queueReceiptFields(g) : { queue_position: g.queue_position }),
     idle_ttl_secs: g.idle_ttl_secs, queued: g.queued,
     // BOT-2099 (Codex #1057 R3): machine callers get the unit ledger of a queued lease too.