@beeos-ai/cli 1.1.2 → 1.1.3

package/dist/index.js

@@ -6583,6 +6583,60 @@ function printFleetNotRunningHint() {
   console.log("  device-agent fleet start     # foreground (debug-friendly)");
   console.log("");
 }
+async function getFleetDeviceSnapshotBestEffort(serial, baseUrl = FLEET_STATUS_BASE_URL) {
+  let res;
+  try {
+    res = await fetch(
+      `${baseUrl}/fleet/devices/${encodeURIComponent(serial)}`,
+      {
+        method: "GET",
+        signal: AbortSignal.timeout(FLEET_NOTIFY_TIMEOUT_MS)
+      }
+    );
+  } catch {
+    return null;
+  }
+  if (!res.ok) {
+    return null;
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return null;
+  }
+  return parseFleetDeviceSnapshot(body);
+}
+function parseFleetDeviceSnapshot(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (typeof r.serial !== "string" || r.serial.length === 0) return null;
+  if (!isFleetDeviceState(r.state)) return null;
+  return {
+    serial: r.serial,
+    state: r.state,
+    instanceId: typeof r.instanceId === "string" ? r.instanceId : null,
+    mcpPid: typeof r.mcpPid === "number" ? r.mcpPid : null,
+    daemonPid: typeof r.daemonPid === "number" ? r.daemonPid : null,
+    sinceMs: typeof r.sinceMs === "number" ? r.sinceMs : 0
+  };
+}
+function isFleetDeviceState(v) {
+  switch (v) {
+    case "adb_offline":
+    case "adb_unauthorized":
+    case "awaiting_bind":
+    case "spawning":
+    case "healthy":
+    case "grace":
+    case "degraded":
+    case "gone":
+    case "crashed":
+      return true;
+    default:
+      return false;
+  }
+}
 var FLEET_STATUS_BASE_URL, FLEET_NOTIFY_TIMEOUT_MS, FLEET_SHUTDOWN_TIMEOUT_MS;
 var init_fleet_notify = __esm({
   "src/commands/device/fleet-notify.ts"() {
@@ -6855,6 +6909,169 @@ var init_instance_picker = __esm({
   }
 });
 
+// src/commands/device/wait-for-fleet-healthy.ts
+import ora2 from "ora";
+async function waitForFleetHealthy(opts) {
+  const timeoutMs = resolveTimeoutMs(opts.timeoutMs);
+  if (timeoutMs <= 0) {
+    return { kind: "skipped", reason: "opt_out" };
+  }
+  const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const useSpinner = (opts.spinner ?? true) && Boolean(process.stdout?.isTTY);
+  const reporter = useSpinner ? new SpinnerReporter() : new BareReporter();
+  reporter.start(opts.serial, timeoutMs);
+  const startedAt = Date.now();
+  let nullStreak = 0;
+  let lastSnapshot = null;
+  try {
+    while (true) {
+      const snapshot = await getFleetDeviceSnapshotBestEffort(
+        opts.serial,
+        opts.fleetBaseUrl
+      );
+      const elapsedMs = Date.now() - startedAt;
+      if (snapshot === null) {
+        nullStreak += 1;
+        if (nullStreak >= FLEET_DEAD_NULL_THRESHOLD) {
+          reporter.skipFleetDown();
+          return { kind: "skipped", reason: "fleet_not_running" };
+        }
+      } else {
+        nullStreak = 0;
+        lastSnapshot = snapshot;
+        if (snapshot.state === "healthy") {
+          reporter.online(snapshot, elapsedMs);
+          return { kind: "online", elapsedMs, snapshot };
+        }
+        reporter.update(snapshot, elapsedMs);
+      }
+      if (elapsedMs + intervalMs >= timeoutMs) {
+        reporter.timeout(lastSnapshot, elapsedMs);
+        return { kind: "timeout", elapsedMs, lastSnapshot };
+      }
+      await sleep6(intervalMs);
+    }
+  } finally {
+    reporter.dispose();
+  }
+}
+function resolveTimeoutMs(optsTimeoutMs) {
+  const envRaw = process.env.BEEOS_AGENT_WAIT_TIMEOUT_MS;
+  if (envRaw !== void 0 && envRaw !== "") {
+    const parsed = Number(envRaw);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+  if (process.env.BEEOS_NO_WAIT_AGENT === "1") return 0;
+  if (optsTimeoutMs !== void 0) return optsTimeoutMs;
+  return DEFAULT_TIMEOUT_MS2;
+}
+function sleep6(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatSec(ms) {
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatOnline(snapshot, elapsedMs) {
+  const mcp = snapshot.mcpPid ?? "?";
+  const daemon = snapshot.daemonPid ?? "?";
+  return `Device fleet healthy: mcp_pid=${mcp} daemon_pid=${daemon} (${formatSec(elapsedMs)})`;
+}
+function formatTimeout(serial, lastSnapshot, elapsedMs) {
+  const state = lastSnapshot?.state ?? "unknown";
+  const daemonPid = lastSnapshot?.daemonPid ?? null;
+  return `Waiting for ${serial} healthy timed out after ${formatSec(elapsedMs)} \u2014 current state: ${state}, daemon_pid=${daemonPid ?? "null"}`;
+}
+var DEFAULT_TIMEOUT_MS2, DEFAULT_INTERVAL_MS, FLEET_DEAD_NULL_THRESHOLD, SpinnerReporter, BareReporter;
+var init_wait_for_fleet_healthy = __esm({
+  "src/commands/device/wait-for-fleet-healthy.ts"() {
+    "use strict";
+    init_fleet_notify();
+    DEFAULT_TIMEOUT_MS2 = 3e4;
+    DEFAULT_INTERVAL_MS = 1e3;
+    FLEET_DEAD_NULL_THRESHOLD = 3;
+    SpinnerReporter = class {
+      spinner = null;
+      serial = "";
+      start(serial, timeoutMs) {
+        this.serial = serial;
+        this.spinner = ora2({
+          text: `Waiting for device-agent fleet to mark ${serial} healthy (timeout=${formatSec(timeoutMs)})...`,
+          stream: process.stderr
+        }).start();
+      }
+      update(snapshot, elapsedMs) {
+        if (!this.spinner) return;
+        this.spinner.text = `Waiting for ${this.serial} healthy \u2014 current state=${snapshot.state} (${formatSec(elapsedMs)})`;
+      }
+      online(snapshot, elapsedMs) {
+        if (!this.spinner) return;
+        this.spinner.succeed(formatOnline(snapshot, elapsedMs));
+        this.spinner = null;
+        console.log(
+          "  Agent may take ~1-2s more to register on dashboard."
+        );
+      }
+      timeout(lastSnapshot, elapsedMs) {
+        if (!this.spinner) return;
+        this.spinner.warn(formatTimeout(this.serial, lastSnapshot, elapsedMs));
+        this.spinner = null;
+        console.log(
+          `  See ~/.beeos/logs/services/device-agent-${this.serial}.log for details.`
+        );
+      }
+      skipFleetDown() {
+        if (!this.spinner) return;
+        this.spinner.info(
+          "Skipped fleet wait \u2014 supervisor not running. Run `beeos start` or `beeos doctor`."
+        );
+        this.spinner = null;
+      }
+      dispose() {
+        if (this.spinner) {
+          this.spinner.stop();
+          this.spinner = null;
+        }
+      }
+    };
+    BareReporter = class {
+      serial = "";
+      lastState = null;
+      start(serial, timeoutMs) {
+        this.serial = serial;
+        console.log(
+          `Waiting for device-agent fleet to mark ${serial} healthy (timeout=${formatSec(timeoutMs)})...`
+        );
+      }
+      update(snapshot, elapsedMs) {
+        if (snapshot.state === this.lastState) return;
+        this.lastState = snapshot.state;
+        console.log(
+          `[${formatSec(elapsedMs)}] ${this.serial} state=${snapshot.state}`
+        );
+      }
+      online(snapshot, elapsedMs) {
+        console.log(`\u2713 ${formatOnline(snapshot, elapsedMs)}`);
+        console.log(
+          "  Agent may take ~1-2s more to register on dashboard."
+        );
+      }
+      timeout(lastSnapshot, elapsedMs) {
+        console.log(`\u26A0 ${formatTimeout(this.serial, lastSnapshot, elapsedMs)}`);
+        console.log(
+          `  See ~/.beeos/logs/services/device-agent-${this.serial}.log for details.`
+        );
+      }
+      skipFleetDown() {
+        console.log(
+          "Skipped fleet wait \u2014 supervisor not running. Run `beeos start` or `beeos doctor`."
+        );
+      }
+      dispose() {
+      }
+    };
+  }
+});
+
 // src/commands/device/state.ts
 import lockfile from "proper-lockfile";
 function deviceAgentTargetId(serial) {
@@ -7101,10 +7318,17 @@ async function attach(options) {
     const outcome = await notifyFleetRestartDeviceBestEffort(serial);
     if (outcome === "not_running") {
       await maybeNotifyFleetWithHint(cfg);
+    } else {
+      await maybeWaitForFleetHealthy(serial, options);
     }
     return;
   }
   await maybeNotifyFleetWithHint(cfg);
+  await maybeWaitForFleetHealthy(serial, options);
+}
+async function maybeWaitForFleetHealthy(serial, options) {
+  if (options.wait === false) return;
+  await waitForFleetHealthy({ serial });
 }
 async function attachAll(cfg, reporter, withVideo, options) {
   const all = await deviceRuntime.listAdbDevices();
@@ -7230,6 +7454,7 @@ async function attachAll(cfg, reporter, withVideo, options) {
     }
     console.log(`Attached ${committed.length} device(s); supervision via device-agent fleet.`);
   });
+  const committedSerials = commits.filter((c) => c.ok).map((c) => c.serial);
   if (reboundSerials.length > 0) {
     let anyNotRunning = false;
     for (const serial of reboundSerials) {
@@ -7238,12 +7463,27 @@ async function attachAll(cfg, reporter, withVideo, options) {
     }
     if (anyNotRunning) {
       await maybeNotifyFleetWithHint(cfg);
-    } else if (reboundSerials.length < commits.filter((c) => c.ok).length) {
+    } else if (reboundSerials.length < committedSerials.length) {
       await maybeNotifyFleetWithHint(cfg);
     }
+    await maybeWaitForFleetHealthyMany(committedSerials, options);
     return;
   }
   await maybeNotifyFleetWithHint(cfg);
+  await maybeWaitForFleetHealthyMany(committedSerials, options);
+}
+async function maybeWaitForFleetHealthyMany(serials, options) {
+  if (options.wait === false || serials.length === 0) return;
+  await Promise.allSettled(
+    serials.map(
+      (s) => (
+        // Bare mode: ora doesn't compose with parallel callers cleanly,
+        // so we route every serial through the line-per-state-change
+        // reporter even on a TTY.
+        waitForFleetHealthy({ serial: s, spinner: false })
+      )
+    )
+  );
 }
 function commitAttachResults(state, commits) {
   const committed = [];
@@ -7558,6 +7798,7 @@ var init_attach = __esm({
     init_instance_picker();
     init_fallback_banner();
     init_fleet_notify();
+    init_wait_for_fleet_healthy();
     init_state2();
   }
 });
@@ -9932,6 +10173,9 @@ deviceCmd.command("attach").description("Attach an ADB-connected device as an AI
 ).option(
   "--agent-gateway-url <url>",
   "Override the Agent Gateway URL for THIS device only (advanced; multi-region staging). Persists to the device entry so the fleet supervisor reuses it on every restart. Falls back to the global config when omitted."
+).option(
+  "--no-wait",
+  "Skip waiting for the fleet supervisor to mark the device healthy after bind. By default, attach polls fleet on 127.0.0.1:7950 for up to 30s (BEEOS_AGENT_WAIT_TIMEOUT_MS overrides) so terminal exit aligns with dashboard agent-online status. Set this for CI/scripts that don't care about post-bind dashboard sync."
 ).action(attach);
 deviceCmd.command("detach").description("Detach a device agent").option("--serial <serial>", "ADB device serial number").option("--all", "Detach all devices", false).option(
   "--rotate-identity",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beeos-ai/cli",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "type": "module",
   "description": "BeeOS CLI — run AI agents from your desktop",
   "bin": {