@beeos-ai/cli 0.1.2 → 1.0.2

package/dist/index.js

@@ -0,0 +1,2124 @@
+// src/index.ts
+import { Command } from "commander";
+
+// ../core/dist/platform-adapter.js
+var _adapter = null;
+function setPlatformAdapter(adapter) {
+  _adapter = adapter;
+}
+function getPlatformAdapter() {
+  if (!_adapter) {
+    throw new Error("PlatformAdapter not initialized. Call setPlatformAdapter() before using @beeos/core.");
+  }
+  return _adapter;
+}
+
+// ../core/dist/progress.js
+var noopReporter = {
+  onStatus() {
+  },
+  onComplete() {
+  }
+};
+
+// ../core/dist/config.js
+import * as TOML from "smol-toml";
+var DEFAULT_API_URL = "https://api.beeos.ai";
+var DEFAULT_AGENT_GATEWAY_URL = "https://agent-gw.beeos.ai";
+var DEFAULT_DASHBOARD_URL = "https://beeos.ai";
+var DEFAULT_BRIDGE_URL = "wss://bridge-sg.beeos.ai";
+function defaultPlatformConfig() {
+  return {
+    api_url: DEFAULT_API_URL,
+    agent_gateway_url: DEFAULT_AGENT_GATEWAY_URL,
+    dashboard_base_url: DEFAULT_DASHBOARD_URL,
+    bridge_url: DEFAULT_BRIDGE_URL
+  };
+}
+function defaultDeviceConfig() {
+  return {
+    http_enabled: true,
+    http_port: 9090
+  };
+}
+function defaultConfig() {
+  return {
+    platform: defaultPlatformConfig(),
+    device: defaultDeviceConfig()
+  };
+}
+function beeoHome() {
+  const p = getPlatformAdapter();
+  return p.joinPath(p.homeDir(), ".beeos");
+}
+async function ensureDirs() {
+  const p = getPlatformAdapter();
+  const root = beeoHome();
+  for (const sub of ["", "identity", "agents"]) {
+    await p.mkdir(p.joinPath(root, sub));
+  }
+  return root;
+}
+function configPath() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "config.toml");
+}
+function bindingPath() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "binding.json");
+}
+function agentDir(agentType) {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "agents", agentType);
+}
+function agentHome(agentType) {
+  const p = getPlatformAdapter();
+  return p.joinPath(agentDir(agentType), "home");
+}
+function pidFile(agentType) {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), `${agentType}.pid`);
+}
+async function loadOrCreateConfig() {
+  const p = getPlatformAdapter();
+  const path2 = configPath();
+  if (await p.exists(path2)) {
+    const raw = await p.readFile(path2);
+    const parsed = TOML.parse(raw);
+    const cfg2 = mergeWithDefaults(parsed);
+    return cfg2;
+  }
+  const cfg = defaultConfig();
+  await saveConfig(cfg);
+  return cfg;
+}
+async function saveConfig(cfg) {
+  const p = getPlatformAdapter();
+  const path2 = configPath();
+  await p.mkdir(p.dirname(path2));
+  const serializable = {
+    platform: {
+      api_url: cfg.platform.api_url,
+      agent_gateway_url: cfg.platform.agent_gateway_url,
+      dashboard_base_url: cfg.platform.dashboard_base_url,
+      bridge_url: cfg.platform.bridge_url
+    },
+    device: {
+      http_enabled: cfg.device.http_enabled,
+      http_port: cfg.device.http_port
+    }
+  };
+  const raw = TOML.stringify(serializable);
+  await p.writeFile(path2, raw);
+}
+function mergeWithDefaults(parsed) {
+  const platform = parsed.platform ?? {};
+  const device = parsed.device ?? {};
+  return {
+    platform: {
+      api_url: platform.api_url || DEFAULT_API_URL,
+      agent_gateway_url: platform.agent_gateway_url || DEFAULT_AGENT_GATEWAY_URL,
+      dashboard_base_url: platform.dashboard_base_url || DEFAULT_DASHBOARD_URL,
+      bridge_url: platform.bridge_url || DEFAULT_BRIDGE_URL,
+      canvas_relay_url: platform.canvas_relay_url || void 0
+    },
+    device: {
+      mqtt_host: device.mqtt_host || void 0,
+      mqtt_port: device.mqtt_port || void 0,
+      mqtt_use_tls: device.mqtt_use_tls || void 0,
+      http_enabled: device.http_enabled !== void 0 ? device.http_enabled : true,
+      http_port: device.http_port || 9090
+    }
+  };
+}
+async function loadBindingInfo() {
+  const p = getPlatformAdapter();
+  const path2 = bindingPath();
+  if (!await p.exists(path2)) {
+    return migratePairedToBinding();
+  }
+  const raw = await p.readFile(path2);
+  return JSON.parse(raw);
+}
+async function saveBindingInfo(info) {
+  const p = getPlatformAdapter();
+  const path2 = bindingPath();
+  await p.writeFile(path2, JSON.stringify(info, null, 2));
+}
+async function removeBindingInfo() {
+  const p = getPlatformAdapter();
+  const path2 = bindingPath();
+  if (await p.exists(path2)) {
+    await p.rm(path2);
+  }
+}
+async function migratePairedToBinding() {
+  const p = getPlatformAdapter();
+  const legacy = p.joinPath(beeoHome(), "paired.json");
+  if (!await p.exists(legacy))
+    return null;
+  try {
+    const raw = await p.readFile(legacy);
+    const old = JSON.parse(raw);
+    const info = {
+      fingerprint: old.fingerprint,
+      instance_id: old.instance_id,
+      bound_at: old.paired_at
+    };
+    await saveBindingInfo(info);
+    await p.rm(legacy);
+    return info;
+  } catch {
+    return null;
+  }
+}
+async function loadOrCreateGatewayToken() {
+  const p = getPlatformAdapter();
+  const path2 = p.joinPath(beeoHome(), "gateway_token");
+  if (await p.exists(path2)) {
+    const token2 = (await p.readFile(path2)).trim();
+    if (token2)
+      return token2;
+  }
+  const token = crypto.randomUUID();
+  await p.mkdir(p.dirname(path2));
+  await p.writeFile(path2, token);
+  if (p.platform() !== "win32") {
+    await p.chmod(path2, 384);
+  }
+  return token;
+}
+async function readPid(agentType) {
+  const p = getPlatformAdapter();
+  const path2 = pidFile(agentType);
+  if (!await p.exists(path2))
+    return null;
+  const raw = (await p.readFile(path2)).trim();
+  const pid = parseInt(raw, 10);
+  return isNaN(pid) ? null : pid;
+}
+async function writePid(agentType, pid) {
+  const p = getPlatformAdapter();
+  await p.writeFile(pidFile(agentType), String(pid));
+}
+async function removePid(agentType) {
+  const p = getPlatformAdapter();
+  const path2 = pidFile(agentType);
+  if (await p.exists(path2)) {
+    await p.rm(path2);
+  }
+}
+
+// ../core/dist/identity/keypair.js
+import { createHash } from "crypto";
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+function publicKeyB64(id) {
+  return Buffer.from(id.publicKey).toString("base64");
+}
+function fingerprint(id) {
+  return createHash("sha256").update(id.publicKey).digest("hex");
+}
+function fingerprintFromB64(pubkeyB64) {
+  const raw = Buffer.from(pubkeyB64, "base64");
+  return createHash("sha256").update(raw).digest("hex");
+}
+async function loadOrCreateIdentity() {
+  const p = getPlatformAdapter();
+  const path2 = keypairPath();
+  if (await p.exists(path2)) {
+    return loadFromFile(path2);
+  }
+  const id = generate();
+  await save(id);
+  return id;
+}
+async function ensureDeviceKey(keyPath) {
+  const p = getPlatformAdapter();
+  if (await p.exists(keyPath))
+    return;
+  const id = generate();
+  const stored = {
+    publicKey: Buffer.from(id.publicKey).toString("base64"),
+    privateKey: Buffer.from(id.privateKey).toString("base64")
+  };
+  await p.mkdir(p.dirname(keyPath));
+  await p.writeFile(keyPath, JSON.stringify(stored, null, 2));
+  if (p.platform() !== "win32") {
+    await p.chmod(keyPath, 384);
+  }
+}
+async function readPubkeyFromKeyFile(keyPath) {
+  const p = getPlatformAdapter();
+  const raw = await p.readFile(keyPath);
+  const parsed = JSON.parse(raw);
+  if (!parsed.publicKey)
+    throw new Error("publicKey not found in key file");
+  return parsed.publicKey;
+}
+function keypairPath() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "identity", "keypair.json");
+}
+function fingerprintFilePath() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "identity", "fingerprint");
+}
+async function loadFromFile(path2) {
+  const p = getPlatformAdapter();
+  const raw = await p.readFile(path2);
+  const stored = JSON.parse(raw);
+  const privateKey = new Uint8Array(Buffer.from(stored.privateKey, "base64"));
+  if (privateKey.length !== 32) {
+    throw new Error(`private key seed must be 32 bytes, got ${privateKey.length}`);
+  }
+  const publicKey = ed.getPublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+function generate() {
+  const privateKey = ed.utils.randomPrivateKey();
+  const publicKey = ed.getPublicKey(privateKey);
+  return { privateKey, publicKey };
+}
+async function save(id) {
+  const p = getPlatformAdapter();
+  const stored = {
+    publicKey: Buffer.from(id.publicKey).toString("base64"),
+    privateKey: Buffer.from(id.privateKey).toString("base64")
+  };
+  const kpPath = keypairPath();
+  await p.mkdir(p.dirname(kpPath));
+  await p.writeFile(kpPath, JSON.stringify(stored, null, 2));
+  if (p.platform() !== "win32") {
+    await p.chmod(kpPath, 384);
+  }
+  const fpPath = fingerprintFilePath();
+  await p.writeFile(fpPath, fingerprint(id));
+}
+
+// ../core/dist/identity/qr.js
+import QRCode from "qrcode";
+async function qrModules(url) {
+  const segments = QRCode.create(url, { errorCorrectionLevel: "M" });
+  const size = segments.modules.size;
+  const modules = [];
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      modules.push(segments.modules.get(x, y) !== 0);
+    }
+  }
+  return { width: size, modules };
+}
+async function qrToTerminal(url) {
+  const { width, modules } = await qrModules(url);
+  const rows = [];
+  for (let i = 0; i < modules.length; i += width) {
+    rows.push(modules.slice(i, i + width));
+  }
+  const quiet = 2;
+  const fullWidth = width + quiet * 2;
+  const blankLine = " ".repeat(fullWidth);
+  const lines = [];
+  for (let i = 0; i < quiet; i++)
+    lines.push(blankLine);
+  let y = 0;
+  while (y < rows.length) {
+    const topRow = rows[y];
+    const botRow = y + 1 < rows.length ? rows[y + 1] : null;
+    let line = " ".repeat(quiet);
+    for (let x = 0; x < width; x++) {
+      const top = topRow[x];
+      const bot = botRow ? botRow[x] : false;
+      if (top && bot)
+        line += "\u2588";
+      else if (top && !bot)
+        line += "\u2580";
+      else if (!top && bot)
+        line += "\u2584";
+      else
+        line += " ";
+    }
+    line += " ".repeat(quiet);
+    lines.push(line);
+    y += 2;
+  }
+  for (let i = 0; i < quiet; i++)
+    lines.push(blankLine);
+  return lines.join("\n");
+}
+
+// ../core/dist/platform/client.js
+function buildBindUrl(dashboardBaseUrl, bindId) {
+  const base = dashboardBaseUrl.replace(/\/+$/, "");
+  return `${base}/bind/${bindId}`;
+}
+async function agentBind(apiUrl, publicKey, fingerprint2, agentType, hostname) {
+  const p = getPlatformAdapter();
+  const url = `${apiUrl}/api/v1/agent/bind`;
+  const resp = await p.fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      public_key: publicKey,
+      fingerprint: fingerprint2,
+      agent_type: agentType,
+      hostname
+    })
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`agent bind failed (${resp.status}): ${text}`);
+  }
+  return await resp.json();
+}
+async function pollBind(apiUrl, bindId) {
+  const p = getPlatformAdapter();
+  const url = `${apiUrl}/api/v1/agent/bind/${bindId}`;
+  const resp = await p.fetch(url, {
+    signal: AbortSignal.timeout(35e3)
+  });
+  if (!resp.ok) {
+    throw new Error(`bind poll failed: ${resp.status}`);
+  }
+  return await resp.json();
+}
+async function markInstanceOffline(apiUrl, instanceId) {
+  const p = getPlatformAdapter();
+  const url = `${apiUrl}/api/v1/instances/${instanceId}/offline`;
+  const resp = await p.fetch(url, {
+    method: "POST",
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!resp.ok) {
+    throw new Error(`mark offline failed: ${resp.status}`);
+  }
+}
+async function getBindStatus(apiUrl, bindId) {
+  const p = getPlatformAdapter();
+  const url = `${apiUrl}/api/v1/agent/bind/${bindId}`;
+  const resp = await p.fetch(url, {
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!resp.ok) {
+    throw new Error(`bind status check failed: ${resp.status}`);
+  }
+  return await resp.json();
+}
+
+// ../core/dist/platform/npm.js
+async function fetchNpmPackageInfo(packageName) {
+  const p = getPlatformAdapter();
+  const encoded = packageName.replace(/\//g, "%2f");
+  const url = `https://registry.npmjs.org/${encoded}`;
+  const resp = await p.fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!resp.ok) {
+    throw new Error(`npm registry returned ${resp.status}`);
+  }
+  return await resp.json();
+}
+async function downloadTarball(url) {
+  const p = getPlatformAdapter();
+  const resp = await p.fetch(url);
+  if (!resp.ok) {
+    throw new Error(`tarball download failed: ${resp.status}`);
+  }
+  const buf = await resp.arrayBuffer();
+  return new Uint8Array(buf);
+}
+
+// ../core/dist/process.js
+function killProcess(pid) {
+  const p = getPlatformAdapter();
+  if (p.platform() === "win32") {
+    p.exec("taskkill", ["/PID", String(pid), "/F"]).catch(() => {
+    });
+  } else {
+    p.kill(pid, "SIGTERM");
+  }
+}
+function isProcessAlive(pid) {
+  return getPlatformAdapter().isProcessAlive(pid);
+}
+function shouldOpenBrowser() {
+  const p = getPlatformAdapter();
+  if (p.env("SSH_CLIENT") || p.env("SSH_TTY"))
+    return false;
+  const plat = p.platform();
+  if (plat === "darwin" || plat === "win32")
+    return true;
+  return !!(p.env("DISPLAY") || p.env("WAYLAND_DISPLAY"));
+}
+
+// ../core/dist/bind.js
+async function presentBindUrl(bindUrl, forceHeadless, log = console.log) {
+  const p = getPlatformAdapter();
+  const canBrowser = !forceHeadless && shouldOpenBrowser();
+  if (canBrowser) {
+    log("  Opening browser to connect to BeeOS...");
+    log(`  ${bindUrl}`);
+    try {
+      await p.openUrl(bindUrl);
+    } catch (e) {
+      log(`  (Could not open browser: ${e})`);
+      log("");
+      log("  Open this URL manually, or scan with BeeOS app:");
+      await printQr(bindUrl, log);
+    }
+  } else {
+    log("  -- Connect to BeeOS ---------------------------------");
+    log("");
+    log("  Open this URL in your browser, or scan with BeeOS app:");
+    log(`  ${bindUrl}`);
+    log("");
+    await printQr(bindUrl, log);
+    log("  -----------------------------------------------------");
+  }
+}
+async function pollUntilBound(apiUrl, bindId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    if (Date.now() > deadline) {
+      throw new Error("Bind approval timed out \u2014 please re-run the command");
+    }
+    try {
+      const resp = await pollBind(apiUrl, bindId);
+      if (resp.status === "bound") {
+        return resp.instance_id ?? "";
+      }
+      if (resp.status === "expired") {
+        throw new Error("Bind session expired \u2014 please re-run the command");
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (msg.includes("expired") || msg.includes("timed out"))
+        throw e;
+      await sleep(2e3);
+    }
+  }
+}
+async function printQr(url, log) {
+  try {
+    const rendered = await qrToTerminal(url);
+    log(rendered);
+  } catch (e) {
+    log(`  (QR generation failed: ${e})`);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ../core/dist/device-setup.js
+var MIN_PYTHON_VERSION = [3, 11];
+var RECOMMENDED_AGENT_VERSION = "0.2.7";
+function agentBinCommandAndArgs(bin) {
+  if (bin.type === "executable") {
+    return { cmd: bin.path, args: [] };
+  }
+  return { cmd: pythonCmdName(), args: ["-m", "device_agent"] };
+}
+async function ensureDeviceAgent(progress) {
+  const existing = await findExisting();
+  if (existing) {
+    if (existing.type === "executable") {
+      progress.onStatus(`device-agent found: ${existing.path}`);
+      await checkAgentVersion(existing.path, progress);
+    } else {
+      progress.onStatus(`device-agent found: ${pythonCmdName()} -m device_agent`);
+    }
+    return existing;
+  }
+  return install(progress);
+}
+async function upgradeDeviceAgent(progress) {
+  const p = getPlatformAdapter();
+  const venv = venvDir();
+  if (!await p.exists(venv)) {
+    throw new Error(`No managed device-agent venv at ${venv}. Run \`beeos device attach\` first.`);
+  }
+  const source = await installSource();
+  if (await hasUv()) {
+    progress.onStatus(`Upgrading ${source.displayName} with uv...`);
+    const venvPy = p.joinPath(venv, venvBinName(), pythonCmdName());
+    await runCmd("uv", [
+      "pip",
+      "install",
+      "--upgrade",
+      "--python",
+      venvPy,
+      ...source.specs
+    ]);
+  } else {
+    progress.onStatus(`Upgrading ${source.displayName} with pip...`);
+    const pip = p.joinPath(venv, venvBinName(), "pip");
+    await runCmd(pip, ["install", "--upgrade", ...source.specs]);
+  }
+  progress.onComplete("device-agent upgraded");
+}
+async function findExisting() {
+  const p = getPlatformAdapter();
+  try {
+    const result = await p.exec("which", ["device-agent"]);
+    if (result.code === 0 && result.stdout.trim()) {
+      return { type: "executable", path: result.stdout.trim() };
+    }
+  } catch {
+  }
+  if (p.platform() === "win32") {
+    try {
+      const result = await p.exec("where", ["device-agent"]);
+      if (result.code === 0 && result.stdout.trim()) {
+        return { type: "executable", path: result.stdout.trim().split("\n")[0].trim() };
+      }
+    } catch {
+    }
+  }
+  const managed = managedBinary();
+  if (await p.exists(managed)) {
+    return { type: "executable", path: managed };
+  }
+  try {
+    const result = await p.exec(pythonCmdName(), ["-c", "import device_agent; print('ok')"]);
+    if (result.code === 0) {
+      return { type: "pythonModule" };
+    }
+  } catch {
+  }
+  return null;
+}
+async function checkAgentVersion(binPath, progress) {
+  const p = getPlatformAdapter();
+  try {
+    const result = await p.exec(binPath, ["--version"]);
+    if (result.code !== 0)
+      return;
+    const ver = result.stdout.trim().split(" ").pop() ?? "";
+    if (!ver)
+      return;
+    if (versionLessThan(ver, RECOMMENDED_AGENT_VERSION)) {
+      progress.onStatus(`  \x1B[33mdevice-agent v${ver} installed, v${RECOMMENDED_AGENT_VERSION} available. Run \`beeos device upgrade\` to update.\x1B[0m`);
+    }
+  } catch {
+  }
+}
+function versionLessThan(a, b) {
+  const parse2 = (s) => s.split(".").map((p) => parseInt(p, 10) || 0);
+  const pa = parse2(a);
+  const pb = parse2(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va < vb)
+      return true;
+    if (va > vb)
+      return false;
+  }
+  return false;
+}
+async function install(progress) {
+  const p = getPlatformAdapter();
+  const venv = venvDir();
+  const source = await installSource();
+  if (await hasUv()) {
+    await installWithUv(progress, venv, source);
+  } else {
+    const python = await findPython();
+    if (python) {
+      await installWithPython(progress, venv, source, python);
+    } else {
+      throw new Error(`Cannot install device-agent: no Python >= ${MIN_PYTHON_VERSION[0]}.${MIN_PYTHON_VERSION[1]} found and \`uv\` is not installed.
+
+Easiest fix \u2014 install uv (manages Python automatically):
+${uvInstallHint()}
+
+Or install Python manually:
+${pythonInstallHint()}`);
+    }
+  }
+  const bin = managedBinary();
+  if (!await p.exists(bin)) {
+    throw new Error(`device-agent binary not found at ${bin} after installation`);
+  }
+  progress.onComplete("device-agent installed");
+  return { type: "executable", path: bin };
+}
+async function installWithUv(progress, venv, source) {
+  const pyVersion = `${MIN_PYTHON_VERSION[0]}.${MIN_PYTHON_VERSION[1]}`;
+  const p = getPlatformAdapter();
+  progress.onStatus("Creating venv with uv (will download Python if needed)...");
+  await runCmd("uv", ["venv", "--python", pyVersion, venv]);
+  progress.onStatus(`Installing ${source.displayName}...`);
+  const venvPy = p.joinPath(venv, venvBinName(), pythonCmdName());
+  await runCmd("uv", ["pip", "install", "--python", venvPy, ...source.specs]);
+}
+async function installWithPython(progress, venv, source, python) {
+  const p = getPlatformAdapter();
+  progress.onStatus("Creating Python virtual environment...");
+  await runCmd(python, ["-m", "venv", venv]);
+  progress.onStatus(`Installing ${source.displayName}...`);
+  const pip = p.joinPath(venv, venvBinName(), "pip");
+  await runCmd(pip, ["install", ...source.specs]);
+}
+async function installSource() {
+  const p = getPlatformAdapter();
+  try {
+    const cwd = p.env("PWD") || p.homeDir();
+    let dir = cwd;
+    for (let i = 0; i < 10; i++) {
+      const da = p.joinPath(dir, "agents", "device-agent", "pyproject.toml");
+      const bc = p.joinPath(dir, "sdks", "bridge-client-python", "pyproject.toml");
+      if (await p.exists(da) && await p.exists(bc)) {
+        return {
+          displayName: "beeos-device-agent (dev mode from repo)",
+          specs: [
+            "-e",
+            p.joinPath(dir, "sdks", "bridge-client-python"),
+            "-e",
+            p.joinPath(dir, "agents", "device-agent")
+          ]
+        };
+      }
+      const parent = p.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return {
+    displayName: "beeos-device-agent",
+    specs: ["beeos-device-agent"]
+  };
+}
+async function hasUv() {
+  const p = getPlatformAdapter();
+  try {
+    const cmd = p.platform() === "win32" ? "where" : "which";
+    const result = await p.exec(cmd, ["uv"]);
+    return result.code === 0;
+  } catch {
+    return false;
+  }
+}
+async function findPython() {
+  const p = getPlatformAdapter();
+  const candidates = p.platform() === "win32" ? ["python3.13", "python3.12", "python3.11", "python3", "python"] : ["python3.13", "python3.12", "python3.11", "python3"];
+  for (const name of candidates) {
+    try {
+      const cmd = p.platform() === "win32" ? "where" : "which";
+      const whichResult = await p.exec(cmd, [name]);
+      if (whichResult.code !== 0)
+        continue;
+      const bin = whichResult.stdout.trim().split("\n")[0].trim();
+      const verResult = await p.exec(bin, ["--version"]);
+      const text = (verResult.stdout || verResult.stderr).trim();
+      const versionStr = text.replace(/^Python\s+/i, "");
+      const [major, minor] = versionStr.split(".").map((v) => parseInt(v, 10) || 0);
+      if (major > MIN_PYTHON_VERSION[0] || major === MIN_PYTHON_VERSION[0] && minor >= MIN_PYTHON_VERSION[1]) {
+        return bin;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function pythonCmdName() {
+  return getPlatformAdapter().platform() === "win32" ? "python" : "python3";
+}
+function venvDir() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "device-agent-env");
+}
+function venvBinName() {
+  return getPlatformAdapter().platform() === "win32" ? "Scripts" : "bin";
+}
+function managedBinary() {
+  const p = getPlatformAdapter();
+  const name = p.platform() === "win32" ? "device-agent.exe" : "device-agent";
+  return p.joinPath(venvDir(), venvBinName(), name);
+}
+function uvInstallHint() {
+  const p = getPlatformAdapter();
+  if (p.platform() === "win32") {
+    return '  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"';
+  }
+  return "  curl -LsSf https://astral.sh/uv/install.sh | sh";
+}
+function pythonInstallHint() {
+  const p = getPlatformAdapter();
+  if (p.platform() === "win32") {
+    return "  winget install Python.Python.3.13\n  Or download from https://www.python.org/downloads/";
+  }
+  if (p.platform() === "darwin") {
+    return "  brew install python@3.13\n  Or download from https://www.python.org/downloads/";
+  }
+  return "  sudo apt install python3  (Debian/Ubuntu)\n  sudo dnf install python3  (Fedora)\n  Or download from https://www.python.org/downloads/";
+}
+async function runCmd(cmd, args) {
+  const p = getPlatformAdapter();
+  const result = await p.exec(cmd, args);
+  if (result.code !== 0) {
+    const stderr = result.stderr.slice(0, 2e3);
+    throw new Error(`${cmd} ${args.join(" ")} failed (exit ${result.code}):
+${stderr}`);
+  }
+}
+
+// ../core/dist/runtime/device.js
+var deviceRuntime = {
+  agentType() {
+    return "device";
+  },
+  displayName() {
+    return "Device Agent";
+  },
+  async detect() {
+    try {
+      const bin = await ensureDeviceAgent(noopReporter);
+      const { cmd } = agentBinCommandAndArgs(bin);
+      return { binary: cmd, version: "", home: beeoHome() };
+    } catch {
+      return null;
+    }
+  },
+  async ensure(_version, progress) {
+    const bin = await ensureDeviceAgent(progress);
+    const { cmd } = agentBinCommandAndArgs(bin);
+    return { binary: cmd, version: "", home: beeoHome() };
+  },
+  async launch(_ctx) {
+    throw new Error("DeviceRuntime.launch() should not be called directly \u2014 use spawnForDevice() instead");
+  },
+  async isHealthy() {
+    return false;
+  },
+  async stop() {
+  },
+  async update(progress) {
+    await upgradeDeviceAgent(progress);
+  },
+  // ── Device-specific extensions ──────────────────────────
+  async ensureAgent(progress) {
+    return ensureDeviceAgent(progress);
+  },
+  async upgradeAgent(progress) {
+    return upgradeDeviceAgent(progress);
+  },
+  async listAdbDevices() {
+    const p = getPlatformAdapter();
+    const result = await p.exec("adb", ["devices"]);
+    if (result.code !== 0) {
+      throw new Error("adb not found \u2014 install Android platform-tools");
+    }
+    const devices = [];
+    const lines = result.stdout.split("\n").slice(1);
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2 && parts[1] === "device") {
+        devices.push({ serial: parts[0] });
+      }
+    }
+    return devices;
+  },
+  async detectSingleDevice() {
+    const devices = await this.listAdbDevices();
+    if (devices.length === 0) {
+      throw new Error("No ADB devices found. Connect a device and try again.");
+    }
+    if (devices.length > 1) {
+      const serials = devices.map((d) => d.serial).join(", ");
+      throw new Error(`Multiple ADB devices found: ${serials}. Use --serial to specify one.`);
+    }
+    return devices[0].serial;
+  },
+  async spawnForDevice(serial, agentBin, bridgeUrl, httpEnabled, httpPort) {
+    const p = getPlatformAdapter();
+    const keyFile = this.deviceKeyPath(serial);
+    await ensureDeviceKey(keyFile);
+    if (!bridgeUrl) {
+      throw new Error("bridge_url is not configured in ~/.beeos/config.toml.\nSet [platform] bridge_url (e.g. wss://bridge.beeos.ai).");
+    }
+    const { cmd, args: baseArgs } = agentBinCommandAndArgs(agentBin);
+    const args = [
+      ...baseArgs,
+      "--key",
+      keyFile,
+      "--adb",
+      serial,
+      "--bridge",
+      bridgeUrl
+    ];
+    if (httpEnabled) {
+      args.push("--http", "--http-port", String(httpPort));
+    }
+    const logDir = p.joinPath(beeoHome(), "logs");
+    await p.mkdir(logDir);
+    const logFile = p.joinPath(logDir, `device-${serial}.log`);
+    const result = await p.spawn(cmd, args, {
+      detached: true,
+      stdoutFile: logFile,
+      stderrFile: logFile
+    });
+    return result.pid;
+  },
+  deviceKeyPath(serial) {
+    const p = getPlatformAdapter();
+    return p.joinPath(beeoHome(), "identity", `device-${serial}.key.json`);
+  },
+  async ensureKeyAndGetPubkey(serial) {
+    const keyFile = this.deviceKeyPath(serial);
+    await ensureDeviceKey(keyFile);
+    return readPubkeyFromKeyFile(keyFile);
+  }
+};
+
+// ../core/dist/agent/detector.js
+var GATEWAY_PORT = 18789;
+async function isGatewayRunning() {
+  return getPlatformAdapter().tcpProbe("127.0.0.1", GATEWAY_PORT, 500);
+}
+async function managedBinary2(agentType) {
+  const p = getPlatformAdapter();
+  const base = agentDir(agentType);
+  const currentLink = p.joinPath(base, "versions", "current");
+  if (!await p.exists(currentLink))
+    return null;
+  let resolved;
+  try {
+    resolved = await p.readlink(currentLink);
+  } catch {
+    resolved = currentLink;
+  }
+  const binShim = p.joinPath(resolved, "node_modules", ".bin", "openclaw");
+  if (await p.exists(binShim))
+    return binShim;
+  const mjs = p.joinPath(resolved, "node_modules", "openclaw", "openclaw.mjs");
+  if (await p.exists(mjs))
+    return mjs;
+  return null;
+}
+async function findAgent(driver) {
+  const managed = await managedBinary2(driver.agentType());
+  if (managed) {
+    return {
+      type: "managed",
+      binary: managed,
+      home: agentHome(driver.agentType())
+    };
+  }
+  const local = await driver.detectLocal();
+  if (local) {
+    return {
+      type: "system",
+      binary: local.binary,
+      version: local.version,
+      home: local.homeDir
+    };
+  }
+  return { type: "notFound" };
+}
+
+// ../core/dist/agent/downloader.js
+async function downloadAgent(npmPackage, requestedVersion, agentType, progress) {
+  const p = getPlatformAdapter();
+  const info = await fetchNpmPackageInfo(npmPackage);
+  const version = requestedVersion ?? info["dist-tags"]["latest"];
+  if (!version)
+    throw new Error("no 'latest' tag in npm registry");
+  const verInfo = info.versions[version];
+  if (!verInfo)
+    throw new Error(`version ${version} not found in npm registry`);
+  const versionsDir = p.joinPath(agentDir(agentType), "versions");
+  const dest = p.joinPath(versionsDir, version);
+  if (await p.exists(dest)) {
+    progress.onStatus(`${npmPackage} v${version} already downloaded`);
+  } else {
+    progress.onStatus(`Downloading ${npmPackage} v${version} ...`);
+    const data = await downloadTarball(verInfo.dist.tarball);
+    progress.onStatus("extracting...");
+    await extractTarball(data, dest);
+    progress.onStatus("installing dependencies...");
+    await runNpmInstall(dest);
+    progress.onComplete(`${npmPackage} v${version} ready`);
+  }
+  const current = p.joinPath(versionsDir, "current");
+  if (await p.exists(current)) {
+    try {
+      await p.rm(current);
+    } catch {
+    }
+  }
+  try {
+    await p.symlink(dest, current);
+  } catch {
+  }
+  return dest;
+}
+async function downloadPlugin(pluginPackage, agentType, progress) {
+  const p = getPlatformAdapter();
+  const info = await fetchNpmPackageInfo(pluginPackage);
+  const version = info["dist-tags"]["latest"];
+  if (!version)
+    throw new Error("no 'latest' tag for plugin");
+  const verInfo = info.versions[version];
+  if (!verInfo)
+    throw new Error("plugin version not found");
+  const cacheDir = p.joinPath(agentDir(agentType), "beeos-claw");
+  const dest = p.joinPath(cacheDir, version);
+  if (await p.exists(dest))
+    return dest;
+  progress.onStatus(`Downloading ${pluginPackage} v${version} ...`);
+  const data = await downloadTarball(verInfo.dist.tarball);
+  await extractTarball(data, dest);
+  const pkgJson = p.joinPath(dest, "package.json");
+  if (await p.exists(pkgJson)) {
+    await runNpmInstall(dest);
+  }
+  return dest;
+}
+async function extractTarball(data, dest) {
+  const p = getPlatformAdapter();
+  await p.mkdir(dest);
+  const tmpFile = p.joinPath(dest, "__tmp.tgz");
+  await p.writeFileBytes(tmpFile, data);
+  try {
+    await p.exec("tar", ["-xzf", tmpFile, "--strip-components=1", "-C", dest]);
+  } finally {
+    try {
+      await p.rm(tmpFile);
+    } catch {
+    }
+  }
+}
+async function runNpmInstall(dir) {
+  const p = getPlatformAdapter();
+  const result = await p.exec("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], {
+    cwd: dir
+  });
+  if (result.code !== 0) {
+    throw new Error(`npm install failed with exit code ${result.code}`);
+  }
+}
+
+// ../core/dist/agent/launcher.js
+import { createHash as createHash2 } from "crypto";
+var MAX_BACKUPS = 5;
+async function backupOpenclawConfig(agentHome2) {
+  const p = getPlatformAdapter();
+  const configPath2 = p.joinPath(agentHome2, "openclaw.json");
+  if (!await p.exists(configPath2))
+    return false;
+  const ts = Math.floor(Date.now() / 1e3);
+  const backupPath = p.joinPath(agentHome2, `openclaw.json.beeos-backup-${ts}`);
+  await p.copyFile(configPath2, backupPath);
+  const entries = await p.readdir(agentHome2);
+  const backups = entries.filter((e) => e.startsWith("openclaw.json.beeos-backup-")).sort();
+  if (backups.length > MAX_BACKUPS) {
+    for (const old of backups.slice(0, backups.length - MAX_BACKUPS)) {
+      try {
+        await p.rm(p.joinPath(agentHome2, old));
+      } catch {
+      }
+    }
+  }
+  return true;
+}
+async function readExistingGatewayToken(agentHome2) {
+  const p = getPlatformAdapter();
+  const configPath2 = p.joinPath(agentHome2, "openclaw.json");
+  if (!await p.exists(configPath2))
+    return null;
+  try {
+    const raw = await p.readFile(configPath2);
+    const val = JSON.parse(raw);
+    return val?.gateway?.auth?.token ?? null;
+  } catch {
+    return null;
+  }
+}
+function beeosClawPluginConfig(ctx) {
+  const p = getPlatformAdapter();
+  const logDir = p.joinPath(ctx.agentHome, "beeos-logs");
+  return {
+    _generator: { name: "beeos-cli", version: "1.0.0", configProtocol: 1 },
+    agentGatewayUrl: ctx.agentGatewayUrl,
+    keyFile: ctx.keyFile,
+    gateway: { token: ctx.gatewayToken },
+    log: { dir: logDir }
+  };
+}
+async function configurePluginViaCli(ctx) {
+  const p = getPlatformAdapter();
+  const env = {};
+  if (!ctx.isSystemHome)
+    env.OPENCLAW_HOME = ctx.agentHome;
+  await runConfigSet(ctx.agentBinary, ctx.agentHome, "plugins.entries.beeos-claw.enabled", "true", false, ctx.isSystemHome);
+  const configJson = JSON.stringify(beeosClawPluginConfig(ctx));
+  const result = await p.exec(ctx.agentBinary, ["config", "set", "plugins.entries.beeos-claw.config", configJson, "--json"], { env });
+  if (result.code !== 0) {
+    throw new Error("`openclaw config set plugins.entries.beeos-claw.config` failed");
+  }
+  await writePairedJson(ctx.agentHome, ctx.keyFile);
+}
+async function generateOpenclawConfig(ctx) {
+  const p = getPlatformAdapter();
+  await p.mkdir(ctx.agentHome);
+  const env = { OPENCLAW_HOME: ctx.agentHome };
+  const setupResult = await p.exec(ctx.agentBinary, ["setup", "--non-interactive", "--mode", "local"], { env });
+  if (setupResult.code === 0) {
+    for (const [path2, value] of [
+      ["gateway.auth.token", ctx.gatewayToken],
+      ["gateway.remote.token", ctx.gatewayToken],
+      ["gateway.bind", "lan"]
+    ]) {
+      await runConfigSet(ctx.agentBinary, ctx.agentHome, path2, value, false, false);
+    }
+    await configurePluginViaCli(ctx);
+  } else {
+    await generateConfigFallback(ctx);
+  }
+}
+async function generateConfigFallback(ctx) {
+  const p = getPlatformAdapter();
+  for (const sub of ["extensions", "skills", "devices", "workspace"]) {
+    await p.mkdir(p.joinPath(ctx.agentHome, sub));
+  }
+  const config = {
+    gateway: {
+      auth: { token: ctx.gatewayToken },
+      remote: { token: ctx.gatewayToken },
+      bind: "lan"
+    },
+    plugins: {
+      entries: {
+        "beeos-claw": {
+          enabled: true,
+          config: beeosClawPluginConfig(ctx)
+        }
+      }
+    }
+  };
+  const configPath2 = p.joinPath(ctx.agentHome, "openclaw.json");
+  await p.writeFile(configPath2, JSON.stringify(config, null, 2));
+  await writePairedJson(ctx.agentHome, ctx.keyFile);
+}
+async function runConfigSet(bin, home, path2, value, json, isSystemHome) {
+  const p = getPlatformAdapter();
+  const args = ["config", "set", path2, value];
+  if (json)
+    args.push("--json");
+  const env = {};
+  if (!isSystemHome)
+    env.OPENCLAW_HOME = home;
+  const result = await p.exec(bin, args, { env });
+  if (result.code !== 0) {
+    throw new Error(`\`openclaw config set ${path2}\` exited with ${result.code}`);
+  }
+}
+async function restartGatewayViaCli(ctx) {
+  const p = getPlatformAdapter();
+  const env = {};
+  if (!ctx.isSystemHome)
+    env.OPENCLAW_HOME = ctx.agentHome;
+  const result = await p.exec(ctx.agentBinary, ["gateway", "restart"], { env });
+  return result.code === 0;
+}
+async function spawnOpenclaw(ctx) {
+  const p = getPlatformAdapter();
+  const logDir = p.joinPath(ctx.agentHome, "beeos-logs");
+  await p.mkdir(logDir);
+  const stdoutFile = p.joinPath(logDir, "gateway-stdout.log");
+  const stderrFile = p.joinPath(logDir, "gateway-stderr.log");
+  const isMjs = ctx.agentBinary.endsWith(".mjs") || ctx.agentBinary.endsWith(".js");
+  const cmd = isMjs ? "node" : ctx.agentBinary;
+  const baseArgs = isMjs ? [ctx.agentBinary] : [];
+  const env = {
+    AGENT_GATEWAY_URL: ctx.agentGatewayUrl
+  };
+  if (!ctx.isSystemHome) {
+    env.OPENCLAW_HOME = ctx.agentHome;
+    env.OPENCLAW_GATEWAY_TOKEN = ctx.gatewayToken;
+  }
+  const result = await p.spawn(cmd, [...baseArgs, "gateway", "--allow-unconfigured", "--bind", "lan"], {
+    detached: true,
+    stdoutFile,
+    stderrFile,
+    env
+  });
+  return result.pid;
+}
+async function writePairedJson(home, keyFile) {
+  const p = getPlatformAdapter();
+  const devicesDir = p.joinPath(home, "devices");
+  await p.mkdir(devicesDir);
+  let pubKeyB64 = "";
+  if (await p.exists(keyFile)) {
+    try {
+      const raw = await p.readFile(keyFile);
+      const kp = JSON.parse(raw);
+      pubKeyB64 = kp.publicKey ?? "";
+    } catch {
+    }
+  }
+  let deviceId = "beeos-claw-device";
+  if (pubKeyB64) {
+    const decoded = Buffer.from(pubKeyB64, "base64");
+    const hash = createHash2("sha256").update(decoded).digest("hex");
+    deviceId = `beeos-claw-${hash.slice(0, 12)}`;
+  }
+  const paired = {
+    devices: {
+      [deviceId]: {
+        name: "beeos-claw",
+        role: "operator",
+        scopes: ["operator.admin", "operator.approvals", "operator.pairing"],
+        publicKey: pubKeyB64,
+        paired: true
+      }
+    }
+  };
+  const pairedPath = p.joinPath(devicesDir, "paired.json");
+  await p.writeFile(pairedPath, JSON.stringify(paired, null, 2));
+}
+
+// ../core/dist/agent/registry.js
+var openClawDriver = {
+  agentType() {
+    return "openclaw";
+  },
+  npmPackage() {
+    return "openclaw";
+  },
+  pluginPackage() {
+    return "beeos-claw";
+  },
+  async detectLocal() {
+    const p = getPlatformAdapter();
+    const cmd = p.platform() === "win32" ? "where" : "which";
+    let binary;
+    try {
+      const result = await p.exec(cmd, ["openclaw"]);
+      if (result.code !== 0)
+        return null;
+      binary = result.stdout.trim().split("\n")[0].trim();
+    } catch {
+      return null;
+    }
+    let version = "";
+    try {
+      const verResult = await p.exec(binary, ["--version"]);
+      version = verResult.stdout.trim();
+    } catch {
+    }
+    const homeDir = p.joinPath(p.homeDir(), ".openclaw");
+    return { binary, version, homeDir };
+  }
+};
+
+// ../core/dist/runtime/openclaw.js
+var GATEWAY_PORT2 = 18789;
+var openclawRuntime = {
+  agentType() {
+    return "openclaw";
+  },
+  displayName() {
+    return "OpenClaw";
+  },
+  async detect() {
+    const location = await findAgent(openClawDriver);
+    if (location.type === "notFound")
+      return null;
+    return {
+      binary: location.binary,
+      version: location.type === "system" ? location.version : "",
+      home: location.home
+    };
+  },
+  async ensure(version, progress) {
+    const location = await findAgent(openClawDriver);
+    if (location.type === "managed") {
+      return { binary: location.binary, version: "", home: location.home };
+    }
+    if (location.type === "system") {
+      return { binary: location.binary, version: location.version, home: location.home };
+    }
+    const dest = await downloadAgent(openClawDriver.npmPackage(), version ?? void 0, "openclaw", progress);
+    const home = agentHome("openclaw");
+    await getPlatformAdapter().mkdir(home);
+    await downloadPlugin(openClawDriver.pluginPackage(), "openclaw", progress);
+    return { binary: dest, version: "", home };
+  },
+  async launch(ctx) {
+    return spawnOpenclaw(ctx);
+  },
+  async isHealthy() {
+    return getPlatformAdapter().tcpProbe("127.0.0.1", GATEWAY_PORT2, 500);
+  },
+  async stop(agentType) {
+    const pid = await readPid(agentType);
+    if (pid != null) {
+      killProcess(pid);
+      await removePid(agentType);
+    }
+  },
+  async update(progress) {
+    await downloadAgent(openClawDriver.npmPackage(), void 0, "openclaw", progress);
+    await downloadPlugin(openClawDriver.pluginPackage(), "openclaw", progress);
+  }
+};
+
+// src/node-adapter.ts
+import {
+  execFile,
+  spawn as nodeSpawn
+} from "child_process";
+import fs from "fs";
+import fsp from "fs/promises";
+import net from "net";
+import os from "os";
+import path from "path";
+var NodePlatformAdapter = class {
+  // ── Filesystem ──────────────────────────────────────────
+  async readFile(filePath) {
+    return fsp.readFile(filePath, "utf-8");
+  }
+  async readFileBytes(filePath) {
+    const buf = await fsp.readFile(filePath);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  async writeFile(filePath, content) {
+    await fsp.writeFile(filePath, content, "utf-8");
+  }
+  async writeFileBytes(filePath, content) {
+    await fsp.writeFile(filePath, content);
+  }
+  async exists(filePath) {
+    try {
+      await fsp.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(dirPath) {
+    await fsp.mkdir(dirPath, { recursive: true });
+  }
+  async rm(filePath) {
+    await fsp.rm(filePath, { force: true });
+  }
+  async rmdir(dirPath) {
+    await fsp.rm(dirPath, { recursive: true, force: true });
+  }
+  async readdir(dirPath) {
+    return fsp.readdir(dirPath);
+  }
+  async chmod(filePath, mode) {
+    if (process.platform !== "win32") {
+      await fsp.chmod(filePath, mode);
+    }
+  }
+  async symlink(target, linkPath) {
+    try {
+      await fsp.symlink(target, linkPath);
+    } catch (e) {
+      if (process.platform === "win32") {
+        await fsp.symlink(target, linkPath, "junction");
+      } else {
+        throw e;
+      }
+    }
+  }
+  async readlink(linkPath) {
+    return fsp.readlink(linkPath);
+  }
+  async copyFile(src, dest) {
+    await fsp.copyFile(src, dest);
+  }
+  async isDirectory(filePath) {
+    try {
+      const stat = await fsp.stat(filePath);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async stat(filePath) {
+    const s = await fsp.stat(filePath);
+    return { size: s.size, mtimeMs: s.mtimeMs };
+  }
+  // ── Process execution ───────────────────────────────────
+  exec(cmd, args, options) {
+    return new Promise((resolve) => {
+      const env = options?.env ? { ...process.env, ...options.env } : process.env;
+      execFile(
+        cmd,
+        args,
+        {
+          cwd: options?.cwd,
+          env,
+          timeout: options?.timeout,
+          maxBuffer: 10 * 1024 * 1024,
+          encoding: "utf-8"
+        },
+        (error, stdout, stderr) => {
+          const code = error && "code" in error && typeof error.code === "number" ? error.code : error ? 1 : 0;
+          resolve({
+            stdout: stdout ?? "",
+            stderr: stderr ?? "",
+            code
+          });
+        }
+      );
+    });
+  }
+  async spawn(cmd, args, options) {
+    const env = options?.env ? { ...process.env, ...options.env } : process.env;
+    let stdoutFd;
+    let stderrFd;
+    if (options?.stdoutFile) {
+      await fsp.mkdir(path.dirname(options.stdoutFile), { recursive: true });
+      stdoutFd = fs.openSync(options.stdoutFile, "a");
+    }
+    if (options?.stderrFile) {
+      await fsp.mkdir(path.dirname(options.stderrFile), { recursive: true });
+      stderrFd = options.stderrFile === options.stdoutFile ? stdoutFd : fs.openSync(options.stderrFile, "a");
+    }
+    const child = nodeSpawn(cmd, args, {
+      cwd: options?.cwd,
+      env,
+      detached: options?.detached ?? false,
+      stdio: [
+        "ignore",
+        stdoutFd != null ? stdoutFd : "ignore",
+        stderrFd != null ? stderrFd : "ignore"
+      ]
+    });
+    if (options?.detached) {
+      child.unref();
+    }
+    if (stdoutFd != null) fs.closeSync(stdoutFd);
+    if (stderrFd != null && stderrFd !== stdoutFd) fs.closeSync(stderrFd);
+    const pid = child.pid;
+    if (pid == null) {
+      throw new Error(`Failed to spawn process: ${cmd} ${args.join(" ")}`);
+    }
+    return { pid };
+  }
+  kill(pid, signal) {
+    try {
+      process.kill(pid, signal ?? "SIGTERM");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ── Network ─────────────────────────────────────────────
+  async fetch(url, init) {
+    return globalThis.fetch(url, init);
+  }
+  tcpProbe(host, port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+      const socket = net.createConnection({ host, port }, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.setTimeout(timeoutMs);
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve(false);
+      });
+    });
+  }
+  // ── OS info ─────────────────────────────────────────────
+  homeDir() {
+    return os.homedir();
+  }
+  hostname() {
+    return os.hostname();
+  }
+  platform() {
+    return process.platform;
+  }
+  env(key) {
+    return process.env[key];
+  }
+  // ── UI ──────────────────────────────────────────────────
+  async openUrl(url) {
+    const open = await import("open");
+    await open.default(url);
+  }
+  // ── Path utilities ──────────────────────────────────────
+  joinPath(...segments) {
+    return path.join(...segments);
+  }
+  dirname(p) {
+    return path.dirname(p);
+  }
+  basename(p) {
+    return path.basename(p);
+  }
+};
+
+// src/commands/start.ts
+import os2 from "os";
+
+// src/progress.ts
+import ora from "ora";
+var CliReporter = class {
+  spinner;
+  constructor() {
+    this.spinner = ora({ stream: process.stderr });
+  }
+  onStatus(message) {
+    if (this.spinner.isSpinning) {
+      this.spinner.text = message;
+    } else {
+      this.spinner.start(message);
+    }
+  }
+  onComplete(message) {
+    if (this.spinner.isSpinning) {
+      this.spinner.succeed(message);
+    } else {
+      console.log(`\u2713 ${message}`);
+    }
+  }
+  stop() {
+    if (this.spinner.isSpinning) {
+      this.spinner.stop();
+    }
+  }
+};
+
+// src/commands/start.ts
+async function run(agentType, options) {
+  const p = getPlatformAdapter();
+  await ensureDirs();
+  const cfg = await loadOrCreateConfig();
+  const reporter = new CliReporter();
+  if (agentType !== "openclaw") {
+    throw new Error(`Agent type '${agentType}' is not yet supported. Use 'openclaw'.`);
+  }
+  const identity = await loadOrCreateIdentity();
+  const fp = fingerprint(identity);
+  const pubkey = publicKeyB64(identity);
+  const keyFile = p.joinPath(beeoHome(), "identity", "keypair.json");
+  const gwToken = await loadOrCreateGatewayToken();
+  const location = await findAgent(openClawDriver);
+  let binary;
+  let home;
+  let isSystemHome = false;
+  let effectiveToken = gwToken;
+  if (location.type === "managed") {
+    binary = location.binary;
+    home = location.home;
+  } else if (location.type === "system") {
+    binary = location.binary;
+    home = location.home;
+    isSystemHome = true;
+    try {
+      const pluginDir = await downloadPlugin(openClawDriver.pluginPackage(), agentType, reporter);
+      await installPluginToHome(home, pluginDir, binary);
+    } catch {
+    }
+    const systemToken = await readExistingGatewayToken(home);
+    effectiveToken = systemToken ?? gwToken;
+    await backupOpenclawConfig(home);
+    if (await isGatewayRunning()) {
+      const ctx = {
+        agentHome: home,
+        agentBinary: binary,
+        keyFile,
+        bridgeUrl: cfg.platform.bridge_url,
+        agentGatewayUrl: cfg.platform.api_url,
+        gatewayToken: effectiveToken,
+        isSystemHome: true
+      };
+      try {
+        await configurePluginViaCli(ctx);
+      } catch {
+      }
+      try {
+        await restartGatewayViaCli(ctx);
+      } catch {
+      }
+    }
+  } else {
+    reporter.onStatus(`Downloading ${openClawDriver.npmPackage()}...`);
+    await downloadAgent(openClawDriver.npmPackage(), options.version ?? void 0, agentType, reporter);
+    home = agentHome(agentType);
+    await p.mkdir(home);
+    await downloadPlugin(openClawDriver.pluginPackage(), agentType, reporter);
+    const managedBin = await managedBinary2(agentType);
+    if (!managedBin) throw new Error("agent binary not found after download");
+    binary = managedBin;
+  }
+  reporter.stop();
+  let gatewayPid;
+  if (!await isGatewayRunning()) {
+    const ctx = {
+      agentHome: home,
+      agentBinary: binary,
+      keyFile,
+      bridgeUrl: cfg.platform.bridge_url,
+      agentGatewayUrl: cfg.platform.api_url,
+      gatewayToken: effectiveToken,
+      isSystemHome
+    };
+    if (isSystemHome) {
+      await configurePluginViaCli(ctx);
+    } else {
+      await generateOpenclawConfig(ctx);
+    }
+    const pid = await spawnOpenclaw(ctx);
+    await writePid(agentType, pid);
+    gatewayPid = pid;
+    let alive = false;
+    for (let i = 0; i < 10; i++) {
+      await sleep2(500);
+      if (await isGatewayRunning()) {
+        alive = true;
+        break;
+      }
+    }
+    if (!alive) {
+      throw new Error("Agent gateway did not start within 5s");
+    }
+  } else {
+    gatewayPid = await readPid(agentType) ?? void 0;
+  }
+  const hostname = buildHostname();
+  try {
+    const resp = await agentBind(cfg.platform.api_url, pubkey, fp, agentType, hostname);
+    if (resp.status === "bound") {
+      const instanceId = resp.instance_id ?? "";
+      await saveBindingInfo({ fingerprint: fp, instance_id: instanceId, bound_at: nowUnix() });
+      const result = {
+        status: "bound",
+        public_key: pubkey,
+        fingerprint: fp,
+        gateway_url: "http://127.0.0.1:18789",
+        gateway_pid: gatewayPid,
+        bridge_url: cfg.platform.bridge_url,
+        instance_id: instanceId
+      };
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`Agent bound to instance: ${instanceId}`);
+      }
+      return;
+    }
+    if (resp.status === "pending") {
+      const bindId = resp.bind_id ?? "";
+      const bindUrl = buildBindUrl(cfg.platform.dashboard_base_url, bindId);
+      await removeBindingInfo();
+      if (options.json) {
+        const result = {
+          status: "pending",
+          public_key: pubkey,
+          fingerprint: fp,
+          bind_id: bindId,
+          bind_url: bindUrl,
+          qr_data: bindUrl,
+          gateway_url: "http://127.0.0.1:18789",
+          gateway_pid: gatewayPid,
+          bridge_url: cfg.platform.bridge_url
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      await presentBindUrl(bindUrl, options.browser === false);
+      console.log("");
+      console.log("  Waiting for bind approval (timeout: 10min)...");
+      const instanceId = await pollUntilBound(cfg.platform.api_url, bindId, 6e5);
+      await saveBindingInfo({ fingerprint: fp, instance_id: instanceId, bound_at: nowUnix() });
+      console.log(`  Bind confirmed! Instance: ${instanceId}`);
+    }
+  } catch (e) {
+    const cached = await loadBindingInfo();
+    if (cached && cached.fingerprint === fp) {
+      if (options.json) {
+        console.log(JSON.stringify({
+          status: "bound_offline",
+          public_key: pubkey,
+          fingerprint: fp,
+          gateway_url: "http://127.0.0.1:18789",
+          gateway_pid: gatewayPid,
+          bridge_url: cfg.platform.bridge_url,
+          instance_id: cached.instance_id
+        }, null, 2));
+      } else {
+        console.log(`Agent running (offline, cached instance: ${cached.instance_id})`);
+      }
+      return;
+    }
+    throw new Error(`Cannot reach platform to bind agent: ${e}`);
+  }
+}
+async function installPluginToHome(home, pluginDir, binary) {
+  const p = getPlatformAdapter();
+  const dest = p.joinPath(home, "extensions", "beeos-claw");
+  if (await p.exists(dest)) {
+    await p.rmdir(dest);
+  }
+  await copyDirRecursive(pluginDir, dest);
+}
+async function copyDirRecursive(src, dst) {
+  const p = getPlatformAdapter();
+  await p.mkdir(dst);
+  const entries = await p.readdir(src);
+  for (const name of entries) {
+    const srcPath = p.joinPath(src, name);
+    const dstPath = p.joinPath(dst, name);
+    if (await p.isDirectory(srcPath)) {
+      await copyDirRecursive(srcPath, dstPath);
+    } else {
+      await p.copyFile(srcPath, dstPath);
+    }
+  }
+}
+function buildHostname() {
+  const machine = os2.hostname();
+  const user = process.env.USER || process.env.USERNAME || "";
+  return user ? `${user}@${machine}` : machine;
+}
+function nowUnix() {
+  return Math.floor(Date.now() / 1e3);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/stop.ts
+async function run2(agentType) {
+  const pid = await readPid(agentType);
+  if (pid == null) {
+    console.log(`No running ${agentType} agent found`);
+    return;
+  }
+  killProcess(pid);
+  await removePid(agentType);
+  console.log(`Stopped ${agentType} agent (pid ${pid})`);
+}
+
+// src/commands/status.ts
+var KNOWN_RUNTIMES = ["openclaw", "device"];
+async function run3() {
+  const home = beeoHome();
+  const cfg = await loadOrCreateConfig();
+  console.log(`BeeOS Home: ${home}`);
+  console.log(`API URL: ${cfg.platform.api_url}`);
+  console.log(`Bridge URL: ${cfg.platform.bridge_url}`);
+  console.log("");
+  const p = getPlatformAdapter();
+  const fpPath = p.joinPath(home, "identity", "fingerprint");
+  if (await p.exists(fpPath)) {
+    const fp = (await p.readFile(fpPath)).trim();
+    console.log(`Identity fingerprint: ${fp}`);
+  } else {
+    console.log("Identity: not yet created");
+  }
+  console.log("");
+  for (const rt of KNOWN_RUNTIMES) {
+    const pid = await readPid(rt);
+    if (pid != null && isProcessAlive(pid)) {
+      console.log(`${rt}: running (pid ${pid})`);
+    } else if (pid != null) {
+      console.log(`${rt}: stale pid ${pid} (process not alive)`);
+    } else {
+      console.log(`${rt}: not running`);
+    }
+  }
+}
+
+// src/commands/update.ts
+async function run4(agentType) {
+  const reporter = new CliReporter();
+  const pid = await readPid(agentType);
+  const wasRunning = pid != null && isProcessAlive(pid);
+  if (wasRunning) {
+    await run2(agentType);
+  }
+  if (agentType === "openclaw") {
+    await openclawRuntime.update(reporter);
+  } else if (agentType === "device") {
+    await deviceRuntime.update(reporter);
+  } else {
+    throw new Error(`Unknown agent type: ${agentType}`);
+  }
+  reporter.stop();
+  console.log(`${agentType} updated`);
+  if (wasRunning) {
+    console.log("Restarting agent...");
+    await run(agentType, { force: true });
+  }
+}
+
+// src/commands/bind-status.ts
+async function run5(bindId, options) {
+  const cfg = await loadOrCreateConfig();
+  const resp = await getBindStatus(cfg.platform.api_url, bindId);
+  if (resp.status === "bound" && resp.instance_id) {
+    const p = getPlatformAdapter();
+    const fpPath = p.joinPath(beeoHome(), "identity", "fingerprint");
+    try {
+      if (await p.exists(fpPath)) {
+        const fp = (await p.readFile(fpPath)).trim();
+        if (fp) {
+          await saveBindingInfo({
+            fingerprint: fp,
+            instance_id: resp.instance_id,
+            bound_at: Math.floor(Date.now() / 1e3)
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      status: resp.status,
+      instance_id: resp.instance_id ?? null
+    }, null, 2));
+  } else {
+    console.log(`Bind status: ${resp.status}`);
+    if (resp.instance_id) {
+      console.log(`Instance: ${resp.instance_id}`);
+    }
+  }
+}
+
+// src/commands/device.ts
+import lockfile from "proper-lockfile";
+function devicesPath() {
+  const p = getPlatformAdapter();
+  return p.joinPath(beeoHome(), "devices.json");
+}
+async function loadDeviceState() {
+  const p = getPlatformAdapter();
+  const path2 = devicesPath();
+  if (!await p.exists(path2)) return { devices: [] };
+  try {
+    const raw = await p.readFile(path2);
+    return JSON.parse(raw);
+  } catch {
+    return { devices: [] };
+  }
+}
+async function saveDeviceState(state) {
+  const p = getPlatformAdapter();
+  await p.writeFile(devicesPath(), JSON.stringify(state, null, 2));
+}
+async function withDeviceLock(fn) {
+  const p = getPlatformAdapter();
+  const path2 = devicesPath();
+  await p.mkdir(p.dirname(path2));
+  if (!await p.exists(path2)) {
+    await p.writeFile(path2, JSON.stringify({ devices: [] }));
+  }
+  const release = await lockfile.lock(path2, { retries: 3 });
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+async function attach(options) {
+  const cfg = await loadOrCreateConfig();
+  const reporter = new CliReporter();
+  if (options.all) {
+    return attachAll(cfg, reporter);
+  }
+  const serial = options.serial ?? await deviceRuntime.detectSingleDevice();
+  const name = options.name ?? serial;
+  const agentBin = await deviceRuntime.ensureAgent(reporter);
+  reporter.stop();
+  const pubkeyB64 = await deviceRuntime.ensureKeyAndGetPubkey(serial);
+  const instanceId = await tryBindDevice(pubkeyB64, name, cfg);
+  if (!instanceId) {
+    console.error("Bind was not completed \u2014 device-agent will not start without a platform binding.");
+    console.error("Run `beeos device attach` again to retry.");
+    return;
+  }
+  await withDeviceLock(async () => {
+    const state = await loadDeviceState();
+    const idx = state.devices.findIndex((d) => d.serial === serial);
+    if (idx >= 0) {
+      if (isProcessAlive(state.devices[idx].pid)) {
+        console.log(`Device ${serial} is already attached (pid ${state.devices[idx].pid})`);
+        return;
+      }
+      console.error(`  Cleaning stale entry for ${serial} (pid ${state.devices[idx].pid} no longer alive)`);
+      state.devices.splice(idx, 1);
+    }
+    const httpPort = nextHttpPort(state, cfg.device.http_port);
+    const pid = await deviceRuntime.spawnForDevice(
+      serial,
+      agentBin,
+      cfg.platform.bridge_url,
+      cfg.device.http_enabled,
+      httpPort
+    );
+    await sleep3(2e3);
+    if (!isProcessAlive(pid)) {
+      const p2 = getPlatformAdapter();
+      const logPath2 = p2.joinPath(beeoHome(), "logs", `device-${serial}.log`);
+      const tail = await readLogTail(logPath2, 20);
+      throw new Error(
+        `device-agent for ${serial} exited immediately (pid ${pid}). Check logs:
+  ${logPath2}
+
+${tail}`
+      );
+    }
+    const keyFile = deviceRuntime.deviceKeyPath(serial);
+    state.devices.push({
+      serial,
+      name,
+      pid,
+      instance_id: instanceId,
+      key_file: keyFile,
+      http_port: httpPort
+    });
+    await saveDeviceState(state);
+    const p = getPlatformAdapter();
+    const logPath = p.joinPath(beeoHome(), "logs", `device-${serial}.log`);
+    console.log(`  logs: ${logPath}`);
+    console.log(
+      `Attached device ${serial} (${name}) \u2014 pid ${pid} (http :${httpPort}) \u2014 instance ${instanceId}`
+    );
+  });
+}
+async function attachAll(cfg, reporter) {
+  const devices = await deviceRuntime.listAdbDevices();
+  if (devices.length === 0) {
+    console.log("No ADB devices found");
+    return;
+  }
+  const agentBin = await deviceRuntime.ensureAgent(reporter);
+  reporter.stop();
+  await withDeviceLock(async () => {
+    const state = await loadDeviceState();
+    state.devices = state.devices.filter((d) => isProcessAlive(d.pid));
+    const alreadyAttached = new Set(state.devices.map((d) => d.serial));
+    let count = 0;
+    for (const device of devices) {
+      if (alreadyAttached.has(device.serial)) continue;
+      const httpPort = nextHttpPort(state, cfg.device.http_port);
+      try {
+        const pubkeyB64 = await deviceRuntime.ensureKeyAndGetPubkey(device.serial);
+        const instanceId = await tryBindDevice(pubkeyB64, device.serial, cfg);
+        if (!instanceId) {
+          console.error(`  Skipping ${device.serial} \u2014 bind not completed`);
+          continue;
+        }
+        const pid = await deviceRuntime.spawnForDevice(
+          device.serial,
+          agentBin,
+          cfg.platform.bridge_url,
+          cfg.device.http_enabled,
+          httpPort
+        );
+        await sleep3(2e3);
+        if (!isProcessAlive(pid)) {
+          const p = getPlatformAdapter();
+          const logPath = p.joinPath(beeoHome(), "logs", `device-${device.serial}.log`);
+          const tail = await readLogTail(logPath, 10);
+          console.error(`device-agent for ${device.serial} exited immediately (pid ${pid}): ${tail}`);
+          continue;
+        }
+        const keyFile = deviceRuntime.deviceKeyPath(device.serial);
+        state.devices.push({
+          serial: device.serial,
+          name: device.serial,
+          pid,
+          instance_id: instanceId,
+          key_file: keyFile,
+          http_port: httpPort
+        });
+        console.log(`Attached device ${device.serial} \u2014 pid ${pid} (http :${httpPort})`);
+        count++;
+      } catch (e) {
+        console.error(`Failed to attach ${device.serial}: ${e}`);
+      }
+    }
+    await saveDeviceState(state);
+    console.log(`Attached ${count} new device(s)`);
+  });
+}
+async function detach(options) {
+  const cfg = await loadOrCreateConfig();
+  await withDeviceLock(async () => {
+    const state = await loadDeviceState();
+    if (options.all) {
+      for (const entry2 of state.devices) {
+        killProcess(entry2.pid);
+        await notifyOffline(cfg.platform.api_url, entry2.instance_id);
+      }
+      const count = state.devices.length;
+      state.devices = [];
+      await saveDeviceState(state);
+      console.log(`Detached ${count} device(s)`);
+      return;
+    }
+    if (!options.serial) {
+      throw new Error("Specify --serial or use --all");
+    }
+    const idx = state.devices.findIndex((d) => d.serial === options.serial);
+    if (idx < 0) throw new Error(`Device ${options.serial} not found`);
+    const entry = state.devices.splice(idx, 1)[0];
+    killProcess(entry.pid);
+    await notifyOffline(cfg.platform.api_url, entry.instance_id);
+    await saveDeviceState(state);
+    console.log(`Detached device ${options.serial}`);
+  });
+}
+async function notifyOffline(apiUrl, instanceId) {
+  if (!instanceId) return;
+  try {
+    await markInstanceOffline(apiUrl, instanceId);
+  } catch {
+  }
+}
+async function list(options) {
+  if (options.local) {
+    const state = await loadDeviceState();
+    if (state.devices.length === 0) {
+      console.log("No attached devices");
+      return;
+    }
+    console.log(`${"SERIAL".padEnd(16)} ${"NAME".padEnd(20)} ${"STATUS".padEnd(12)} PID`);
+    for (const entry of state.devices) {
+      const status = isProcessAlive(entry.pid) ? "running" : "stopped";
+      console.log(
+        `${entry.serial.padEnd(16)} ${entry.name.padEnd(20)} ${status.padEnd(12)} ${entry.pid}`
+      );
+    }
+  } else {
+    console.log("Remote device listing requires platform API (use --local for local devices)");
+  }
+}
+async function exec(prompt, options) {
+  const state = await loadDeviceState();
+  const entry = options.serial ? state.devices.find((d) => d.serial === options.serial) : state.devices[0];
+  if (!entry) {
+    throw new Error(options.serial ? `Device ${options.serial} not attached` : "No attached devices");
+  }
+  if (!entry.http_port) {
+    throw new Error(
+      `Device ${entry.serial} has no local HTTP port configured.
+Enable http_enabled in ~/.beeos/config.toml and re-attach.`
+    );
+  }
+  const p = getPlatformAdapter();
+  const url = `http://127.0.0.1:${entry.http_port}/prompt`;
+  console.log(`-> ${entry.serial} (local :${entry.http_port}): ${prompt}`);
+  const resp = await p.fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ prompt })
+  });
+  if (!resp.ok) {
+    const body2 = await resp.text().catch(() => "");
+    throw new Error(`device-agent returned ${resp.status} \u2014 ${body2}`);
+  }
+  const body = await resp.json();
+  console.log(JSON.stringify(body, null, 2));
+}
+async function upgrade() {
+  const reporter = new CliReporter();
+  await deviceRuntime.upgradeAgent(reporter);
+}
+async function tryBindDevice(pubkeyB64, name, cfg) {
+  const fp = fingerprintFromB64(pubkeyB64);
+  try {
+    const resp = await agentBind(
+      cfg.platform.api_url,
+      pubkeyB64,
+      fp,
+      "device",
+      name
+    );
+    if (resp.status === "bound") {
+      console.log(`  Already bound \u2014 instance: ${resp.instance_id}`);
+      return resp.instance_id ?? void 0;
+    }
+    if (resp.bind_id) {
+      const bindUrl = buildBindUrl(cfg.platform.dashboard_base_url, resp.bind_id);
+      await presentBindUrl(bindUrl, false);
+      console.log("");
+      console.log("  Waiting for bind approval (timeout: 10min)...");
+      try {
+        const instanceId = await pollUntilBound(
+          cfg.platform.api_url,
+          resp.bind_id,
+          6e5
+        );
+        console.log(`  Bind confirmed! Instance: ${instanceId}`);
+        return instanceId;
+      } catch (e) {
+        console.error(`  Bind polling stopped: ${e}`);
+      }
+    }
+    return void 0;
+  } catch (e) {
+    console.error(`  Platform bind failed: ${e}`);
+    return void 0;
+  }
+}
+function nextHttpPort(state, base) {
+  const used = new Set(state.devices.map((d) => d.http_port));
+  let port = base;
+  while (used.has(port)) port++;
+  return port;
+}
+async function readLogTail(path2, lines) {
+  const p = getPlatformAdapter();
+  try {
+    const content = await p.readFile(path2);
+    const allLines = content.split("\n");
+    const start = Math.max(0, allLines.length - lines);
+    return allLines.slice(start).join("\n");
+  } catch {
+    return "(could not read log file)";
+  }
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/index.ts
+setPlatformAdapter(new NodePlatformAdapter());
+var program = new Command();
+program.name("beeos").version("1.0.0").description("BeeOS \u2014 run AI agents from your desktop");
+program.command("start").description("Install and start an agent").argument("<agent_type>", "Agent type to start (e.g. openclaw)").option("--version <version>", "Pin to a specific version instead of latest").option("--force", "Skip confirmation prompts", false).option("--json", "Output machine-readable JSON to stdout (implies --force)", false).option("--no-browser", "Don't auto-open browser for bind confirmation").action(run);
+program.command("stop").description("Stop a running agent").argument("<agent_type>", "Agent type to stop").action(run2);
+program.command("status").description("Show status of managed agents").action(run3);
+program.command("update").description("Update an agent to the latest version").argument("<agent_type>", "Agent type to update").action(run4);
+program.command("bind-status").description("Check agent binding status").argument("<bind_id>", "Bind session ID returned by `beeos start --json`").option("--json", "Output machine-readable JSON", false).action(run5);
+var deviceCmd = program.command("device").description("Manage device agents (Android/Desktop/ChromeOS)");
+deviceCmd.command("attach").description("Attach an ADB-connected device as an AI agent").option("--serial <serial>", "ADB device serial number").option("--name <name>", "Human-readable device name").option("--all", "Attach all connected ADB devices", false).action(attach);
+deviceCmd.command("detach").description("Detach a device agent").option("--serial <serial>", "ADB device serial number").option("--all", "Detach all devices", false).action(detach);
+deviceCmd.command("list").description("List attached devices").option("--local", "Only show locally running device agents", false).action(list);
+deviceCmd.command("exec").description("Send a natural language command to a device").option("--serial <serial>", "ADB device serial number").argument("<prompt>", "The command/prompt to execute").action(exec);
+deviceCmd.command("upgrade").description("Upgrade the device-agent to the latest version").action(upgrade);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});