@botbuddy/cli 1.8.3 → 1.8.4

package/package.json

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

package/src/botbuddy-release-repair.json

@@ -0,0 +1 @@
+{"schema_version":1,"source_version":"1.8.3","source_identity":"8a450fe651f42fc96f9fd713da5fe707ff48a914c174496337495adf0c425588"}

package/src/docker-hygiene.mjs

@@ -8,6 +8,7 @@ import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
 import { callToolJson } from "./api.mjs";
 import { acquireStackLock, lockPathForProject, projectIdFromConfig } from "./stack-file-lock.mjs";
+import { machineUuid } from "./machine-id.mjs";
 
 export const SCHEMA_VERSION = 1;
 export const DEFAULT_PROJECTED_ENDPOINTS = 10;
@@ -1118,6 +1119,7 @@ async function runDockerCommandWithBotBuddyLock(argv, {
   runWorkflow = runDockerWorkflow,
   workflowOptions = {},
   machineHost = hostname(),
+  machineId = machineUuid(),
   monotonicNow = Date.now,
 } = {}) {
   const parsed = parseDockerArgs(argv);
@@ -1131,6 +1133,10 @@ async function runDockerCommandWithBotBuddyLock(argv, {
     host: machineHost,
     slot: parsed.opts.lockSlot,
     mode: "lock",
+    // BOT-1239: report THIS machine's unique id so the supabase_local stack lock states
+    // which physical machine holds it (host is a hostname two machines can share). Only
+    // sent when the probe found one — a NULL degrades to hostname grouping.
+    ...(machineId ? { machine_uuid: machineId } : {}),
     ticket_id: parsed.opts.ticket,
     no_pr_reason: "local OrbStack hygiene",
   });

package/src/machine-id.mjs

@@ -0,0 +1,70 @@
+// BOT-1239 — the machine-UNIQUE identity of THIS physical machine.
+//
+// A hostname is not machine-unique (two machines can both be "ubuntu"), so a
+// supabase_local lock keyed only on hostname cannot be attributed to the machine
+// that holds it. This reads the same machine-unique token a BotBuddy Helper attests
+// at enrollment (container_hosts.hardware_uuid) so a lock the CLI acquires reports the
+// SAME identity — letting /docker merge a machine's Helper with its own stack lock and
+// never with a foreign machine's under a shared hostname.
+//
+//   * macOS : IOPlatformUUID from `ioreg -rd1 -c IOPlatformExpertDevice` (what the
+//             Helper attests, so the two identities match for one machine).
+//   * Linux : /etc/machine-id (falling back to /var/lib/dbus/machine-id).
+//   * else / on any error : null — the lock then degrades to hostname grouping, never
+//             a wrong merge. This must NEVER throw or block a lock acquisition.
+//
+// `BOTBUDDY_MACHINE_UUID` overrides the probe (explicit operator control / tests).
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const IOREG_UUID_RE = /"IOPlatformUUID"\s*=\s*"([^"]+)"/;
+
+export function readMachineUuid({
+  platform = process.platform,
+  env = process.env,
+  exec = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", timeout: 4000 }),
+  readFile = (p) => readFileSync(p, "utf8"),
+} = {}) {
+  try {
+    const override = (env.BOTBUDDY_MACHINE_UUID || "").trim();
+    if (override) return override;
+
+    if (platform === "darwin") {
+      const out = exec("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
+      if (out && out.status === 0 && typeof out.stdout === "string") {
+        const m = out.stdout.match(IOREG_UUID_RE);
+        const uuid = m && m[1] ? m[1].trim() : "";
+        return uuid || null;
+      }
+      return null;
+    }
+
+    if (platform === "linux") {
+      for (const path of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+          const id = String(readFile(path) || "").trim();
+          if (id) return id;
+        } catch { /* try the next source */ }
+      }
+      return null;
+    }
+
+    return null;
+  } catch {
+    // A machine id is a best-effort disambiguator; never let it fail an acquire.
+    return null;
+  }
+}
+
+let _cached;
+let _cachedComputed = false;
+
+// Cached, zero-argument accessor for the real process. Tests call readMachineUuid
+// directly with injected dependencies instead of hitting this cache.
+export function machineUuid() {
+  if (!_cachedComputed) {
+    _cached = readMachineUuid();
+    _cachedComputed = true;
+  }
+  return _cached;
+}