botapp-cli 0.1.1

package/dist/index.js

@@ -0,0 +1,3251 @@
+// src/index.ts
+import { Command as Command19 } from "commander";
+import pc20 from "picocolors";
+
+// src/commands/server.ts
+import { Command } from "commander";
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+import pc from "picocolors";
+
+// src/config/profile.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse, stringify } from "yaml";
+var CONFIG_DIR = join(homedir(), ".botapp");
+var CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+function defaultConfig() {
+  return {
+    active_profile: "local",
+    profiles: {
+      local: {
+        server: "http://localhost:7100"
+      }
+    }
+  };
+}
+function loadProfile() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return defaultConfig();
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = parse(raw);
+    return { ...defaultConfig(), ...parsed };
+  } catch {
+    return defaultConfig();
+  }
+}
+function saveProfile(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, stringify(config), "utf-8");
+}
+function getActiveProfile() {
+  const config = loadProfile();
+  return config.profiles[config.active_profile] ?? config.profiles.local ?? { server: "http://localhost:7100" };
+}
+function updateActiveProfile(updates) {
+  const config = loadProfile();
+  const name = config.active_profile;
+  config.profiles[name] = { ...config.profiles[name], ...updates };
+  saveProfile(config);
+}
+
+// src/config/server.ts
+function resolveServerUrl(flagUrl) {
+  if (flagUrl) return flagUrl.replace(/\/$/, "");
+  const env = process.env.BOTAPP_SERVER;
+  if (env) return env.replace(/\/$/, "");
+  const profile = getActiveProfile();
+  return profile.server.replace(/\/$/, "");
+}
+function resolveToken(flagToken) {
+  if (flagToken) return flagToken;
+  const env = process.env.BOTAPP_TOKEN;
+  if (env) return env;
+  return getActiveProfile().token;
+}
+function authHeaders(token) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+
+// src/commands/server.ts
+var serverCommand = new Command("server").description("Manage the local botapp server process");
+serverCommand.command("start").description("Start the local server process (no auth setup)").option("-p, --port <port>", "Port for local server", "7100").option("--background", "Run in background", false).action(async (opts) => {
+  const serverUrl = `http://localhost:${opts.port}`;
+  try {
+    const res = await fetch(`${serverUrl}/health`);
+    if (res.ok) {
+      console.log(pc.yellow("Server is already running at"), pc.cyan(serverUrl));
+      return;
+    }
+  } catch {
+  }
+  const serverEntry = findServerEntry();
+  if (!serverEntry) {
+    console.error(
+      pc.red("Could not find the server package.\n") + `
+This command requires the botapp monorepo source.
+If you installed the CLI from npm, use ${pc.cyan("bot launch")} and
+pick option 2 (cloud) or 3 (custom) instead.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  console.log(pc.blue("Starting local server..."));
+  const child = spawn("node", ["--import", "tsx", serverEntry], {
+    env: { ...process.env, PORT: opts.port },
+    stdio: opts.background ? "ignore" : "inherit",
+    detached: opts.background
+  });
+  if (opts.background) {
+    child.unref();
+    console.log(pc.green("Server started in background"), `(PID: ${child.pid})`);
+  }
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    try {
+      const res = await fetch(`${serverUrl}/health`);
+      if (res.ok) {
+        if (opts.background) console.log(pc.green("Server ready at"), pc.cyan(serverUrl));
+        return;
+      }
+    } catch {
+    }
+  }
+  if (opts.background) console.log(pc.yellow("Server may still be starting..."));
+});
+serverCommand.command("status").description("Check if the server is running").action(async () => {
+  const serverUrl = resolveServerUrl();
+  try {
+    const res = await fetch(`${serverUrl}/health`);
+    const data = await res.json();
+    console.log(pc.green("Server is running"));
+    console.log(`  URL:   ${pc.cyan(serverUrl)}`);
+    console.log(`  Mode:  ${data.mode}`);
+    console.log(`  Apps:  ${data.apps}`);
+  } catch {
+    console.log(pc.red("Server is not running"));
+    process.exitCode = 1;
+  }
+});
+serverCommand.command("stop").description("Stop the botapp server").action(async () => {
+  console.log(pc.yellow("Server stop not yet implemented (kill the process manually)"));
+});
+function findServerEntry() {
+  const candidates = [
+    resolve(process.cwd(), "packages/server/src/index.ts"),
+    resolve(process.cwd(), "../server/src/index.ts"),
+    resolve(process.cwd(), "../../packages/server/src/index.ts")
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c)) return c;
+  }
+  return null;
+}
+
+// src/commands/launch.ts
+import { Command as Command3 } from "commander";
+import { spawn as spawn3 } from "child_process";
+import { resolve as resolve3, join as join3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, openSync, writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { createInterface as createInterface2 } from "readline";
+import { hostname } from "os";
+import pc4 from "picocolors";
+
+// src/config/daemon.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var CONFIG_DIR2 = join2(homedir2(), ".botapp");
+var DAEMON_FILE = join2(CONFIG_DIR2, "daemon.yaml");
+function loadDaemonProfile() {
+  try {
+    if (!existsSync3(DAEMON_FILE)) return null;
+    const parsed = parse2(readFileSync2(DAEMON_FILE, "utf-8"));
+    if (!parsed?.server || !parsed.daemonId || !parsed.token) return null;
+    return {
+      server: parsed.server.replace(/\/$/, ""),
+      daemonId: parsed.daemonId,
+      daemonName: parsed.daemonName ?? parsed.daemonId,
+      token: parsed.token
+    };
+  } catch {
+    return null;
+  }
+}
+function saveDaemonProfile(profile) {
+  mkdirSync2(CONFIG_DIR2, { recursive: true });
+  writeFileSync2(DAEMON_FILE, stringify2(profile), "utf-8");
+}
+
+// src/auth/browser-auth.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { spawn as spawn2 } from "child_process";
+import pc2 from "picocolors";
+var OK_HTML = `<!doctype html>
+<meta charset="utf-8">
+<title>botapp \xB7 Authentication successful</title>
+<style>
+  :root { color-scheme: dark; }
+  html, body { height: 100%; margin: 0; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Inter', 'Segoe UI', Roboto, sans-serif;
+    background: #0b0b0d;
+    color: #e9e9ec;
+    display: grid;
+    place-items: center;
+    -webkit-font-smoothing: antialiased;
+  }
+  .card {
+    width: min(92vw, 520px);
+    background: #151518;
+    border: 1px solid #242428;
+    border-radius: 16px;
+    padding: 48px 40px 40px;
+    text-align: center;
+  }
+  .check {
+    width: 64px; height: 64px; margin: 0 auto 22px;
+    border-radius: 50%;
+    background: rgba(34, 197, 94, 0.14);
+    color: #22c55e;
+    display: grid; place-items: center;
+    font-size: 30px;
+  }
+  .glyph { color: #6b6b72; font-size: 20px; margin: 8px 0 12px; }
+  h1 { font-size: 28px; font-weight: 700; margin: 0 0 10px; letter-spacing: -0.01em; }
+  p  { color: #9a9aa1; margin: 0; font-size: 15px; line-height: 1.5; }
+  .dim { color: #6b6b72; font-size: 13px; margin-top: 14px; }
+</style>
+<div class="card">
+  <div class="check">\u2713</div>
+  <div class="glyph">\u2731</div>
+  <h1>Authentication successful</h1>
+  <p>You can close this tab and return to the terminal.</p>
+  <p class="dim">Your CLI session is now authenticated.</p>
+</div>`;
+async function runBrowserAuth(opts) {
+  const state = randomBytes(24).toString("base64url");
+  const timeoutMs = opts.timeoutMs ?? 10 * 6e4;
+  const { port, waitForCallback, shutdown } = await startLoopback(state);
+  const cliCallback = `http://127.0.0.1:${port}/callback`;
+  const params = new URLSearchParams({
+    cli_callback: cliCallback,
+    cli_state: state,
+    scope: opts.scope
+  });
+  if (opts.name) params.set("name", opts.name);
+  const approvalUrl = `${opts.appUrl.replace(/\/$/, "")}/cli-auth?${params.toString()}`;
+  console.log(pc2.dim("Opening browser to authenticate..."));
+  console.log(pc2.dim("If the browser didn't open, visit:"));
+  console.log(`  ${pc2.cyan(approvalUrl)}`);
+  console.log();
+  console.log(pc2.dim("Waiting for authentication..."));
+  openUrl(approvalUrl);
+  try {
+    const payload = await Promise.race([
+      waitForCallback(),
+      new Promise((_, reject) => {
+        setTimeout(
+          () => reject(new Error("timed out waiting for authentication")),
+          timeoutMs
+        );
+      })
+    ]);
+    await new Promise((r) => setTimeout(r, 1500));
+    return {
+      scope: opts.scope,
+      serverUrl: payload.serverUrl ?? opts.serverUrl,
+      name: payload.name,
+      pairingToken: payload.pairingToken,
+      userId: payload.userId,
+      userEmail: payload.userEmail,
+      userToken: payload.userToken,
+      agentId: payload.agentId,
+      agentName: payload.agentName,
+      daemonPairingToken: payload.daemonPairingToken
+    };
+  } finally {
+    shutdown();
+  }
+}
+async function startLoopback(expectedState) {
+  let resolveCb = () => {
+  };
+  let rejectCb = () => {
+  };
+  let settled = false;
+  const callbackPromise = new Promise((resolve7, reject) => {
+    resolveCb = (p) => {
+      if (settled) return;
+      settled = true;
+      resolve7(p);
+    };
+    rejectCb = (e) => {
+      if (settled) return;
+      settled = true;
+      reject(e);
+    };
+  });
+  const server = createServer((req, res) => {
+    void handleLoopback(req, res, expectedState, resolveCb, rejectCb);
+  });
+  await new Promise((resolve7, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      resolve7();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("could not bind loopback port");
+  }
+  return {
+    port: address.port,
+    waitForCallback: () => callbackPromise,
+    shutdown: () => {
+      rejectCb(new Error("loopback shut down"));
+      server.close();
+    }
+  };
+}
+async function handleLoopback(req, res, expectedState, onOk, onErr) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  if (!url.pathname.startsWith("/callback")) {
+    res.statusCode = 404;
+    res.end("not found");
+    return;
+  }
+  if (req.method === "GET") {
+    const state = url.searchParams.get("state");
+    if (!state || state !== expectedState) {
+      res.statusCode = 400;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.end(errorHtml("State mismatch. Re-run the CLI and try again."), () => {
+        onErr(new Error("callback state mismatch"));
+      });
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(OK_HTML, () => {
+      onOk({
+        serverUrl: url.searchParams.get("serverUrl") ?? void 0,
+        name: url.searchParams.get("name") ?? void 0,
+        pairingToken: url.searchParams.get("pairingToken") ?? void 0,
+        userId: url.searchParams.get("userId") ?? void 0,
+        userEmail: url.searchParams.get("userEmail") ?? void 0,
+        userToken: url.searchParams.get("userToken") ?? void 0,
+        agentId: url.searchParams.get("agentId") ?? void 0,
+        agentName: url.searchParams.get("agentName") ?? void 0,
+        daemonPairingToken: url.searchParams.get("daemonPairingToken") ?? void 0
+      });
+    });
+    return;
+  }
+  const origin = req.headers.origin ?? "*";
+  res.setHeader("Access-Control-Allow-Origin", origin);
+  res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  res.setHeader("Access-Control-Allow-Private-Network", "true");
+  res.setHeader("Vary", "Origin");
+  if (req.method === "OPTIONS") {
+    res.statusCode = 204;
+    res.end();
+    return;
+  }
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    res.end("method not allowed");
+    return;
+  }
+  try {
+    const body = await readJsonBody(req);
+    if (!body || typeof body !== "object") {
+      res.statusCode = 400;
+      res.end("invalid body");
+      onErr(new Error("invalid callback body"));
+      return;
+    }
+    const parsed = body;
+    if (typeof parsed.state !== "string" || parsed.state !== expectedState) {
+      res.statusCode = 400;
+      res.end("state mismatch");
+      onErr(new Error("callback state mismatch"));
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(OK_HTML);
+    onOk({
+      serverUrl: asString(parsed.serverUrl),
+      name: asString(parsed.name),
+      pairingToken: asString(parsed.pairingToken),
+      userId: asString(parsed.userId),
+      userEmail: asString(parsed.userEmail),
+      userToken: asString(parsed.userToken),
+      agentId: asString(parsed.agentId),
+      agentName: asString(parsed.agentName),
+      daemonPairingToken: asString(parsed.daemonPairingToken)
+    });
+  } catch (e) {
+    res.statusCode = 500;
+    res.end("error");
+    onErr(e);
+  }
+}
+function errorHtml(msg) {
+  const safe = msg.replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c] ?? c);
+  return `<!doctype html><meta charset="utf-8"><title>botapp \xB7 CLI auth failed</title>
+<style>body{font-family:ui-monospace,Menlo,monospace;background:#0b0b0d;color:#eee;display:grid;place-items:center;min-height:100vh;margin:0}.c{border:1px solid #333;padding:2rem 2.5rem;max-width:520px}</style>
+<div class="c"><h1>CLI auth failed</h1><p>${safe}</p></div>`;
+}
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function readJsonBody(req) {
+  return new Promise((resolve7, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (c) => {
+      total += c.length;
+      if (total > 64 * 1024) {
+        reject(new Error("payload too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (!raw) return resolve7(null);
+      try {
+        resolve7(JSON.parse(raw));
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function openUrl(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", '""', url] : [url];
+  try {
+    spawn2(cmd, args, { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+
+// src/commands/daemon-agent-config.ts
+import { spawnSync } from "child_process";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { resolve as resolve2 } from "path";
+import { Command as Command2 } from "commander";
+import pc3 from "picocolors";
+var LOCAL_AGENT_SPECS = [
+  { name: "codex", kind: "codex", command: "codex" },
+  { name: "claude", kind: "claude-code", command: "claude" },
+  { name: "openclaw", kind: "openclaw", command: "openclaw" },
+  { name: "hermes", kind: "hermes-agent", command: "hermes" }
+];
+async function registerAllDetectedAgents(input2) {
+  const detected = scanLocalDaemonAgents();
+  if (detected.length === 0) return { created: [], skipped: [], detected: 0 };
+  const existing = await daemonSelfRequest(
+    input2.server,
+    input2.token,
+    "/api/daemon/self/agents"
+  );
+  const registered = existing.agents ?? [];
+  const created = [];
+  const skipped = [];
+  const cwd = resolve2(input2.cwd);
+  for (const candidate of detected) {
+    if (registered.find((a) => a.name === candidate.name)) {
+      skipped.push(candidate.name);
+      continue;
+    }
+    try {
+      await daemonSelfRequest(
+        input2.server,
+        input2.token,
+        "/api/daemon/self/agents",
+        {
+          method: "POST",
+          body: {
+            name: candidate.name,
+            kind: candidate.kind,
+            command: candidate.command,
+            args: [],
+            cwd,
+            env: null
+          }
+        }
+      );
+      created.push(candidate.name);
+    } catch {
+      skipped.push(candidate.name);
+    }
+  }
+  return { created, skipped, detected: detected.length };
+}
+function createDaemonAgentConfigCommand() {
+  return new Command2("config").description("Scan local agent CLIs and register selected daemon agents").option("--all", "Register every detected agent without prompting").option("--agent <name...>", "Register only these detected agent names, e.g. codex claude").option("--cwd <cwd>", "Working directory stored on registered daemon agents", process.cwd()).action(async (opts) => {
+    await configureDaemonAgents({
+      all: Boolean(opts.all),
+      names: Array.isArray(opts.agent) ? opts.agent : [],
+      cwd: opts.cwd
+    });
+  });
+}
+async function configureDaemonAgents(inputOpts) {
+  const profile = loadDaemonProfile();
+  if (!profile) {
+    console.error(pc3.red("No paired daemon found. Run `bot pair` first."));
+    process.exitCode = 1;
+    return;
+  }
+  const detected = scanLocalDaemonAgents();
+  if (detected.length === 0) {
+    console.log(pc3.yellow("No supported local agent CLIs were found on PATH."));
+    console.log(pc3.dim("Scanned: codex, claude, openclaw, hermes"));
+    return;
+  }
+  const existing = await daemonSelfRequest(
+    profile.server,
+    profile.token,
+    "/api/daemon/self/agents"
+  );
+  const registered = existing.agents ?? [];
+  const selected = await selectCandidates(detected, inputOpts);
+  if (selected.length === 0) {
+    console.log(pc3.dim("No agents selected."));
+    return;
+  }
+  const cwd = resolve2(inputOpts.cwd);
+  let created = 0;
+  let skipped = 0;
+  for (const candidate of selected) {
+    const alreadyRegistered = registered.find((agent) => agent.name === candidate.name);
+    if (alreadyRegistered) {
+      skipped += 1;
+      console.log(
+        pc3.dim(
+          `Skipping ${candidate.name}: already registered as ${alreadyRegistered.id}`
+        )
+      );
+      continue;
+    }
+    const data = await daemonSelfRequest(
+      profile.server,
+      profile.token,
+      "/api/daemon/self/agents",
+      {
+        method: "POST",
+        body: {
+          name: candidate.name,
+          kind: candidate.kind,
+          command: candidate.command,
+          args: [],
+          cwd,
+          env: null
+        }
+      }
+    );
+    created += 1;
+    console.log(
+      pc3.green(`Registered ${pc3.bold(data.agent.name)}`) + pc3.dim(` (${data.agent.kind}, ${data.agent.command}, cwd ${cwd})`)
+    );
+  }
+  console.log(pc3.green(`Done. Registered ${created}, skipped ${skipped}.`));
+}
+function scanLocalDaemonAgents() {
+  const candidates = [];
+  for (const spec of LOCAL_AGENT_SPECS) {
+    const path = findExecutable(spec.command);
+    if (!path) continue;
+    candidates.push({ ...spec, path });
+  }
+  return candidates;
+}
+function findExecutable(command) {
+  const lookupCommand = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(lookupCommand, [command], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  return result.stdout.split(/\r?\n/).find((line) => line.trim())?.trim() ?? null;
+}
+async function selectCandidates(detected, opts) {
+  if (opts.all) return detected;
+  const requested = new Set(opts.names.map((name) => name.toLowerCase()));
+  if (requested.size > 0) {
+    const selected = detected.filter((candidate) => requested.has(candidate.name.toLowerCase()));
+    const missing = [...requested].filter(
+      (name) => !detected.some((candidate) => candidate.name.toLowerCase() === name)
+    );
+    for (const name of missing) {
+      console.log(pc3.yellow(`Not detected on PATH: ${name}`));
+    }
+    return selected;
+  }
+  if (!process.stdin.isTTY) {
+    console.error(pc3.red("Interactive selection requires a TTY. Use --all or --agent <name...>."));
+    process.exitCode = 1;
+    return [];
+  }
+  console.log(pc3.bold("Detected local agents:"));
+  detected.forEach((candidate, index) => {
+    console.log(
+      `  ${index + 1}. ${pc3.bold(candidate.name)} ` + pc3.dim(`${candidate.kind} / ${candidate.command} / ${candidate.path}`)
+    );
+  });
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(
+      'Select agents to register (comma-separated numbers, "all", or empty for all): '
+    );
+    const value = answer.trim().toLowerCase();
+    if (!value || value === "all" || value === "a") return detected;
+    if (value === "none" || value === "n") return [];
+    const indexes = new Set(
+      value.split(",").map((part) => Number(part.trim())).filter((index) => Number.isInteger(index) && index >= 1 && index <= detected.length)
+    );
+    return detected.filter((_, index) => indexes.has(index + 1));
+  } finally {
+    rl.close();
+  }
+}
+async function daemonSelfRequest(server, token, path, opts) {
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  if (opts?.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const res = await fetch(`${server}${path}`, {
+    method: opts?.method ?? "GET",
+    headers,
+    body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(data.error ?? data.message ?? res.statusText);
+  }
+  return data;
+}
+
+// src/commands/launch.ts
+var DEFAULT_SERVER_URL = "https://api.botapp.ai";
+var DEFAULT_APP_URL = "https://botapp.ai";
+function ask(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      res(answer.trim());
+    });
+  });
+}
+var launchCommand = new Command3("launch").alias("start").description("Set up this CLI (auth + default agent + daemon pair + agent register)").option("-p, --port <port>", "Port for local server", "7100").option("--background", "Run local server in background", false).option("-s, --server <url>", "Server URL (skip the interactive picker)").option("--app-url <url>", "Dashboard URL (defaults to the server URL)").option("--no-browser", "Error instead of opening a browser").option("--no-agents", "Skip auto-registering local agent CLIs").option("--agent-cwd <cwd>", "Working directory stored on registered daemon agents", process.cwd()).option("--no-start", "Skip starting the daemon process in background").action(async (opts) => {
+  if (opts.server) {
+    await launchAgainstServer(opts.server, opts.appUrl, opts);
+    return;
+  }
+  console.log(pc4.bold("Where do you want to run botapp?\n"));
+  console.log(`  ${pc4.cyan("1)")} Local  ${pc4.dim("\u2014 start a server on this machine")}`);
+  console.log(`  ${pc4.cyan("2)")} Cloud  ${pc4.dim(`\u2014 connect to ${DEFAULT_APP_URL}`)}`);
+  console.log(`  ${pc4.cyan("3)")} Custom ${pc4.dim("\u2014 enter your own server URL")}
+`);
+  const choice = await ask(`${pc4.bold("Select [1/2/3]:")} `);
+  switch (choice) {
+    case "1":
+      await launchLocal(opts);
+      break;
+    case "2":
+      await launchAgainstServer(DEFAULT_SERVER_URL, DEFAULT_APP_URL, opts);
+      break;
+    case "3": {
+      const url = await ask(`
+${pc4.bold("Server URL:")} `);
+      if (!url) {
+        console.error(pc4.red("No URL provided"));
+        process.exitCode = 1;
+        return;
+      }
+      await launchAgainstServer(url.replace(/\/$/, ""), void 0, opts);
+      break;
+    }
+    default:
+      console.error(pc4.red(`Invalid choice: ${choice}`));
+      process.exitCode = 1;
+  }
+});
+async function launchLocal(opts) {
+  const serverUrl = `http://localhost:${opts.port}`;
+  if (!await isServerUp(serverUrl)) {
+    const spawned = await startLocalServer(opts);
+    if (!spawned) {
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    console.log(pc4.yellow("Server already running at"), pc4.cyan(serverUrl));
+  }
+  await launchAgainstServer(serverUrl, serverUrl, opts);
+}
+async function launchAgainstServer(serverUrl, appUrl, opts) {
+  console.log(pc4.dim(`
+Configured for ${serverUrl}`));
+  const health = await fetchHealth(serverUrl);
+  if (!health) {
+    console.error(pc4.red(`Cannot reach ${serverUrl}`));
+    process.exitCode = 1;
+    return;
+  }
+  const profileName = pickProfileName(serverUrl);
+  if (health.mode === "local" && health.token) {
+    const config2 = loadProfile();
+    config2.profiles[profileName] = {
+      server: serverUrl,
+      app_url: appUrl ?? serverUrl,
+      token: health.token,
+      user_id: "local",
+      agent_id: "local-agent"
+    };
+    config2.active_profile = profileName;
+    saveProfile(config2);
+    console.log(pc4.green("Logged in (local mode)"));
+    console.log(`  Profile: ${pc4.bold(profileName)}`);
+    console.log(`  Server:  ${pc4.cyan(serverUrl)}`);
+    const paired = await tryLocalDaemonPair(serverUrl, hostname());
+    if (paired) {
+      console.log(
+        `  Daemon:  ${pc4.bold(paired.name)} ${pc4.dim(`(${paired.id})`)}`
+      );
+      await autoRegisterAgents(opts);
+      await autoStartDaemon(opts, serverUrl, paired.id);
+    } else {
+      console.log(pc4.yellow(`  Daemon:  pairing failed \u2014 run \`bot pair\` later`));
+    }
+    return;
+  }
+  if (opts.noBrowser) {
+    console.error(pc4.red("Hosted server needs browser auth but --no-browser was passed."));
+    process.exitCode = 1;
+    return;
+  }
+  const result = await runBrowserAuth({
+    serverUrl,
+    appUrl: appUrl ?? serverUrl,
+    scope: "launch",
+    name: hostname()
+  });
+  if (!result.userToken || !result.userId || !result.agentId) {
+    console.error(pc4.red("server did not return a user token / agent"));
+    process.exitCode = 1;
+    return;
+  }
+  const config = loadProfile();
+  config.profiles[profileName] = {
+    server: result.serverUrl ?? serverUrl,
+    app_url: appUrl ?? serverUrl,
+    token: result.userToken,
+    user_id: result.userId,
+    agent_id: result.agentId
+  };
+  config.active_profile = profileName;
+  saveProfile(config);
+  if (result.userEmail) {
+    console.log(pc4.green(`Authenticated as ${pc4.bold(result.userEmail)}`));
+  }
+  console.log(`  Profile: ${pc4.bold(profileName)}`);
+  console.log(`  Server:  ${pc4.cyan(result.serverUrl ?? serverUrl)}`);
+  console.log(
+    `  Agent:   ${pc4.bold(result.agentName ?? "default")} ${pc4.dim(`(${result.agentId})`)}`
+  );
+  if (result.daemonPairingToken) {
+    try {
+      const res = await fetch(`${result.serverUrl ?? serverUrl}/api/daemon/pair`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          token: result.daemonPairingToken,
+          name: hostname(),
+          machine: hostname()
+        })
+      });
+      const data = await res.json().catch(() => ({}));
+      if (res.ok && data?.daemon?.id) {
+        saveDaemonProfile({
+          server: result.serverUrl ?? serverUrl,
+          daemonId: data.daemon.id,
+          daemonName: data.daemon.name,
+          token: data.token
+        });
+        console.log(
+          `  Daemon:  ${pc4.bold(data.daemon.name)} ${pc4.dim(`(${data.daemon.id})`)}`
+        );
+        await autoRegisterAgents(opts);
+        await autoStartDaemon(opts, result.serverUrl ?? serverUrl, data.daemon.id);
+      } else {
+        console.log(pc4.yellow(`  Daemon:  pairing failed \u2014 run \`bot pair\` later`));
+      }
+    } catch {
+      console.log(pc4.yellow(`  Daemon:  pairing skipped \u2014 run \`bot pair\` later`));
+    }
+  }
+}
+async function autoStartDaemon(opts, serverUrl, daemonId) {
+  if (opts.start === false) {
+    console.log(pc4.dim(`
+Next: run \`bot daemon run\` to bring this machine online.`));
+    return;
+  }
+  const dir = join3(homedir3(), ".botapp");
+  const pidFile = join3(dir, "daemon.pid");
+  const logFile = join3(dir, "daemon.log");
+  mkdirSync3(dir, { recursive: true });
+  if (isDaemonRunningLocally(pidFile)) {
+    console.log(pc4.dim(`  Running: already (pid $(cat ~/.botapp/daemon.pid))`));
+    return;
+  }
+  const botBin = process.argv[1];
+  if (!botBin || !existsSync4(botBin)) {
+    console.log(pc4.yellow(`  Running: cannot resolve \`bot\` binary \u2014 run \`bot daemon run\` manually`));
+    return;
+  }
+  const logFd = openSync(logFile, "a");
+  const child = spawn3(process.execPath, [botBin, "daemon", "run"], {
+    stdio: ["ignore", logFd, logFd],
+    detached: true
+  });
+  child.unref();
+  if (typeof child.pid === "number") {
+    writeFileSync3(pidFile, `${child.pid}
+`, "utf-8");
+  }
+  let online = false;
+  for (let i = 0; i < 20; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await isDaemonOnline(serverUrl, daemonId)) {
+      online = true;
+      break;
+    }
+  }
+  if (online) {
+    console.log(`  Running: ${pc4.green("online")} ${pc4.dim(`(pid ${child.pid}, logs ~/.botapp/daemon.log)`)}`);
+  } else {
+    console.log(
+      pc4.yellow(
+        `  Running: started but didn't report online in 10s \u2014 check ~/.botapp/daemon.log`
+      )
+    );
+  }
+}
+function isDaemonRunningLocally(pidFile) {
+  if (!existsSync4(pidFile)) return false;
+  try {
+    const pid = parseInt(readFileSync3(pidFile, "utf-8").trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDaemonOnline(serverUrl, daemonId) {
+  try {
+    const res = await fetch(`${serverUrl}/api/daemons`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return false;
+    const data = await res.json();
+    const d = (data.daemons ?? []).find((x) => x.id === daemonId);
+    return d?.status === "online" || d?.status === "connected";
+  } catch {
+    return false;
+  }
+}
+async function autoRegisterAgents(opts) {
+  if (opts.agents === false) return;
+  const daemon = loadDaemonProfile();
+  if (!daemon) return;
+  try {
+    const { created, skipped, detected } = await registerAllDetectedAgents({
+      server: daemon.server,
+      token: daemon.token,
+      cwd: opts.agentCwd
+    });
+    if (detected === 0) {
+      console.log(
+        pc4.dim(
+          `  Agents:  none detected on PATH (scanned: codex, claude, openclaw, hermes)`
+        )
+      );
+      return;
+    }
+    const summary = [];
+    if (created.length > 0) summary.push(`${created.length} registered (${created.join(", ")})`);
+    if (skipped.length > 0) summary.push(`${skipped.length} skipped`);
+    console.log(
+      `  Agents:  ${pc4.bold(summary.join(" \xB7 ") || "up to date")}`
+    );
+  } catch (e) {
+    console.log(pc4.yellow(`  Agents:  registration failed (${e.message})`));
+  }
+}
+async function tryLocalDaemonPair(serverUrl, name) {
+  try {
+    const tokRes = await fetch(`${serverUrl}/api/daemon/pairing-tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    if (!tokRes.ok) return null;
+    const tokData = await tokRes.json();
+    if (!tokData.token) return null;
+    const pairRes = await fetch(`${serverUrl}/api/daemon/pair`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token: tokData.token, name, machine: name })
+    });
+    if (!pairRes.ok) return null;
+    const data = await pairRes.json();
+    if (!data.daemon?.id || !data.token) return null;
+    saveDaemonProfile({
+      server: serverUrl,
+      daemonId: data.daemon.id,
+      daemonName: data.daemon.name,
+      token: data.token
+    });
+    return { id: data.daemon.id, name: data.daemon.name };
+  } catch {
+    return null;
+  }
+}
+function pickProfileName(serverUrl) {
+  try {
+    const host = new URL(serverUrl).hostname;
+    if (host === "localhost" || host === "127.0.0.1") return "local";
+    if (host === new URL(DEFAULT_SERVER_URL).hostname) return "cloud";
+    return host.replace(/\./g, "-");
+  } catch {
+    return "remote";
+  }
+}
+async function fetchHealth(serverUrl) {
+  try {
+    const res = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function isServerUp(serverUrl) {
+  return await fetchHealth(serverUrl) !== null;
+}
+async function startLocalServer(opts) {
+  const serverUrl = `http://localhost:${opts.port}`;
+  const serverEntry = findServerEntry2();
+  if (!serverEntry) {
+    console.error(
+      pc4.red("Could not find the server package.\n") + `
+Local mode requires the botapp monorepo source.
+If you installed the CLI from npm, pick option ${pc4.cyan("2")} (cloud) or ${pc4.cyan("3")} (custom) instead.
+
+Or run a local server from source:
+  ${pc4.cyan("git clone https://github.com/wangdinglu/botapp")}
+  ${pc4.cyan("cd botapp && pnpm install && pnpm build")}
+  ${pc4.cyan("pnpm --filter @botapp/server dev")}`
+    );
+    return false;
+  }
+  console.log(pc4.blue("Starting local server..."));
+  const child = spawn3("node", ["--import", "tsx", serverEntry], {
+    env: { ...process.env, PORT: opts.port },
+    stdio: opts.background ? "ignore" : "inherit",
+    detached: opts.background
+  });
+  if (opts.background) {
+    child.unref();
+  }
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (await isServerUp(serverUrl)) return true;
+  }
+  console.error(pc4.red("Server did not come up in 15s"));
+  return false;
+}
+function findServerEntry2() {
+  const candidates = [
+    resolve3(process.cwd(), "packages/server/src/index.ts"),
+    resolve3(process.cwd(), "../server/src/index.ts"),
+    resolve3(process.cwd(), "../../packages/server/src/index.ts")
+  ];
+  for (const c of candidates) {
+    if (existsSync4(c)) return c;
+  }
+  return null;
+}
+
+// src/commands/apps.ts
+import { Command as Command4 } from "commander";
+import pc5 from "picocolors";
+
+// src/client/http.ts
+async function request(url, method, token, body) {
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: authHeaders(token),
+      body: body ? JSON.stringify(body) : void 0
+    });
+  } catch (e) {
+    const cause = e?.cause;
+    const code = cause?.code;
+    const parsed = (() => {
+      try {
+        return new URL(url);
+      } catch {
+        return null;
+      }
+    })();
+    const origin = parsed ? `${parsed.protocol}//${parsed.host}` : url;
+    let hint = "";
+    if (code === "ECONNREFUSED") {
+      hint = ` \u2014 nothing is listening on ${origin}. Run \`bot server start\` to pick a server, or point at a different one with \`-s <url>\` or BOTAPP_SERVER.`;
+    } else if (code === "ENOTFOUND") {
+      hint = ` \u2014 cannot resolve host ${parsed?.hostname ?? origin}. Check the URL in ~/.botapp/config.yaml.`;
+    } else if (code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT") {
+      hint = ` \u2014 connection to ${origin} timed out.`;
+    } else if (code) {
+      hint = ` (${code})`;
+    } else if (cause?.message) {
+      hint = ` \u2014 ${cause.message}`;
+    }
+    throw new Error(`Cannot reach ${origin}${hint}`);
+  }
+  const data = await res.json().catch(() => null);
+  if (!res.ok) {
+    const msg = data?.error ?? data?.message ?? `HTTP ${res.status}`;
+    throw Object.assign(new Error(msg), { status: res.status });
+  }
+  return data;
+}
+function createClient(serverUrl, token) {
+  return {
+    async health() {
+      return request(`${serverUrl}/health`, "GET");
+    },
+    async listApps() {
+      return request(`${serverUrl}/api/apps`, "GET", token);
+    },
+    async getApp(name) {
+      return request(`${serverUrl}/api/apps/${name}`, "GET", token);
+    },
+    async runCommand(app, command, params) {
+      return request(
+        `${serverUrl}/api/apps/${app}/commands/${command}`,
+        "POST",
+        token,
+        params
+      );
+    },
+    async runAction(app, action, params) {
+      return request(
+        `${serverUrl}/api/apps/${app}/actions/${action}`,
+        "POST",
+        token,
+        params
+      );
+    }
+  };
+}
+
+// src/commands/apps.ts
+var appsCommand = new Command4("apps").description("List installed apps").option("--json", "Output as JSON").action(async (opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  const client = createClient(serverUrl, token);
+  try {
+    const data = await client.listApps();
+    const apps = data.apps ?? [];
+    if (opts.json || globalOpts.json) {
+      console.log(JSON.stringify(apps, null, 2));
+      return;
+    }
+    if (apps.length === 0) {
+      console.log(pc5.yellow("No apps installed"));
+      return;
+    }
+    for (const app of apps) {
+      const status = app.status === "running" ? pc5.green("\u25CF") : app.status === "errored" ? pc5.red("\u25CF") : pc5.gray("\u25CB");
+      console.log(`${status} ${pc5.bold(app.name)} v${app.version}`);
+      if (app.description) {
+        console.log(`  ${pc5.dim(app.description)}`);
+      }
+      if (app.commands?.length > 0) {
+        console.log(
+          `  Commands: ${app.commands.map((c) => pc5.cyan(c.name)).join(", ")}`
+        );
+      }
+      if (app.actions?.length > 0) {
+        console.log(
+          `  Actions:  ${app.actions.map((a) => pc5.yellow(a.name)).join(", ")}`
+        );
+      }
+      console.log();
+    }
+  } catch (e) {
+    console.error(pc5.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/run.ts
+import { Command as Command5 } from "commander";
+import pc6 from "picocolors";
+var runCommand = new Command5("run").description("Run an app command").argument("<app>", "App name").argument("<command>", "Command name").allowUnknownOption(true).allowExcessArguments(true).action(async (appName, commandName, _opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  const client = createClient(serverUrl, token);
+  const params = parseKwargs(process.argv.slice(process.argv.indexOf(commandName) + 1));
+  try {
+    const data = await client.runCommand(appName, commandName, params);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else if (data.status === "success") {
+      console.log(data.result);
+    } else {
+      console.error(pc6.red(`Error: ${data.error}`));
+      process.exitCode = 1;
+    }
+  } catch (e) {
+    console.error(pc6.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+function parseKwargs(args) {
+  const params = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (!next || next.startsWith("--")) {
+        params[key] = true;
+      } else {
+        const num = Number(next);
+        params[key] = isNaN(num) ? next : num;
+        i++;
+      }
+    }
+  }
+  return params;
+}
+
+// src/commands/login.ts
+import { Command as Command6 } from "commander";
+import pc7 from "picocolors";
+var loginCommand = new Command6("login").description("Login to a botapp server").option("-s, --server <url>", "Server URL").action(async (opts) => {
+  const serverUrl = resolveServerUrl(opts.server);
+  console.log(`Connecting to ${pc7.cyan(serverUrl)}...`);
+  try {
+    const res = await fetch(`${serverUrl}/health`);
+    if (!res.ok) {
+      console.error(pc7.red(`Server returned ${res.status}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    if (data.token) {
+      updateActiveProfile({
+        server: serverUrl,
+        token: data.token,
+        user_id: "local",
+        agent_id: "local-agent"
+      });
+      console.log(pc7.green("Logged in successfully"));
+      console.log(`  Server: ${pc7.cyan(serverUrl)}`);
+      console.log(`  Mode:   ${data.mode}`);
+      console.log(`  Token:  ${pc7.dim(data.token.slice(0, 12) + "...")}`);
+    } else {
+      console.log(pc7.yellow("Server did not return a token (hosted mode login not yet implemented)"));
+    }
+  } catch (e) {
+    const code = e?.cause?.code;
+    const extra = code === "ECONNREFUSED" ? ` \u2014 nothing is listening. Run \`bot server start\` to pick a server, or set BOTAPP_SERVER to point at a running instance.` : code === "ENOTFOUND" ? ` \u2014 cannot resolve hostname. Check the URL.` : code ? ` (${code})` : "";
+    console.error(pc7.red(`Cannot reach ${serverUrl}${extra}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/install.ts
+import { Command as Command7 } from "commander";
+import { resolve as resolve4, basename } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, symlinkSync, cpSync, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+import pc8 from "picocolors";
+var APPS_DIR = join4(homedir4(), ".botapp", "apps");
+var installCommand = new Command7("install").description("Install an app from a local path").argument("<path>", "Path to the app directory").option("--dev", "Install in dev mode (symlink)").action(async (appPath, opts) => {
+  const absPath = resolve4(appPath);
+  if (!existsSync5(absPath)) {
+    console.error(pc8.red(`Path not found: ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const manifestPath = join4(absPath, "botapp.app.json");
+  if (!existsSync5(manifestPath)) {
+    console.error(pc8.red(`No botapp.app.json found in ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+  } catch {
+    console.error(pc8.red("Failed to parse botapp.app.json"));
+    process.exitCode = 1;
+    return;
+  }
+  const appName = manifest.name || basename(absPath);
+  const targetDir = join4(APPS_DIR, appName);
+  mkdirSync4(APPS_DIR, { recursive: true });
+  if (existsSync5(targetDir)) {
+    console.log(pc8.yellow(`App "${appName}" is already installed. Reinstalling...`));
+    const { rmSync: rmSync2 } = await import("fs");
+    rmSync2(targetDir, { recursive: true, force: true });
+  }
+  if (opts.dev) {
+    symlinkSync(absPath, targetDir, "dir");
+    console.log(pc8.green(`Installed ${pc8.bold(appName)} in dev mode (symlink)`));
+    console.log(`  ${pc8.dim(absPath)} \u2192 ${pc8.dim(targetDir)}`);
+  } else {
+    cpSync(absPath, targetDir, { recursive: true });
+    console.log(pc8.green(`Installed ${pc8.bold(appName)}`));
+    console.log(`  ${pc8.dim(targetDir)}`);
+  }
+  console.log(pc8.dim("Restart the server to load the new app."));
+});
+
+// src/commands/uninstall.ts
+import { Command as Command8 } from "commander";
+import { existsSync as existsSync6, rmSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+import pc9 from "picocolors";
+var APPS_DIR2 = join5(homedir5(), ".botapp", "apps");
+var uninstallCommand = new Command8("uninstall").description("Uninstall an app").argument("<name>", "App name to uninstall").action(async (name) => {
+  const targetDir = join5(APPS_DIR2, name);
+  if (!existsSync6(targetDir)) {
+    console.error(pc9.red(`App "${name}" is not installed`));
+    process.exitCode = 1;
+    return;
+  }
+  rmSync(targetDir, { recursive: true, force: true });
+  console.log(pc9.green(`Uninstalled ${pc9.bold(name)}`));
+  console.log(pc9.dim("Restart the server to apply changes."));
+});
+
+// src/commands/dev.ts
+import { Command as Command9 } from "commander";
+import { resolve as resolve5, basename as basename2, join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, symlinkSync as symlinkSync2, readFileSync as readFileSync5, lstatSync } from "fs";
+import { homedir as homedir6 } from "os";
+import { spawn as spawn4 } from "child_process";
+import pc10 from "picocolors";
+var APPS_DIR3 = join6(homedir6(), ".botapp", "apps");
+var devCommand = new Command9("dev").description("Start development mode for an app").argument("[path]", "Path to the app directory", ".").option("-p, --port <port>", "Server port", "7100").action(async (appPath, opts) => {
+  const absPath = resolve5(appPath);
+  if (!existsSync7(absPath)) {
+    console.error(pc10.red(`Path not found: ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const manifestPath = join6(absPath, "botapp.app.json");
+  if (!existsSync7(manifestPath)) {
+    console.error(pc10.red(`No botapp.app.json found in ${absPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+  } catch {
+    console.error(pc10.red("Failed to parse botapp.app.json"));
+    process.exitCode = 1;
+    return;
+  }
+  const appName = manifest.name || basename2(absPath);
+  const targetDir = join6(APPS_DIR3, appName);
+  mkdirSync5(APPS_DIR3, { recursive: true });
+  if (!existsSync7(targetDir)) {
+    symlinkSync2(absPath, targetDir, "dir");
+    console.log(pc10.blue(`Linked ${pc10.bold(appName)} \u2192 ${pc10.dim(absPath)}`));
+  } else {
+    const stat = lstatSync(targetDir);
+    if (stat.isSymbolicLink()) {
+      console.log(pc10.dim(`${appName} already linked`));
+    } else {
+      console.log(pc10.yellow(`${appName} is installed (not symlinked). Using existing installation.`));
+    }
+  }
+  const serverUrl = resolveServerUrl();
+  let serverRunning = false;
+  try {
+    const res = await fetch(`${serverUrl}/health`);
+    serverRunning = res.ok;
+  } catch {
+  }
+  if (serverRunning) {
+    console.log(pc10.green(`Server already running at ${serverUrl}`));
+    console.log(pc10.yellow("Restart the server to load the new app."));
+  } else {
+    const serverEntry = findServerEntry3();
+    if (!serverEntry) {
+      console.log(
+        pc10.yellow("No local server found.") + ` App ${pc10.bold(appName)} has been linked to ${pc10.dim(targetDir)}
+
+Start the server separately, then restart it to load the app:
+  ${pc10.cyan("bot server start")}`
+      );
+      return;
+    }
+    console.log(pc10.blue("Starting botapp server..."));
+    const child = spawn4("node", ["--import", "tsx", serverEntry], {
+      env: { ...process.env, PORT: opts.port },
+      stdio: "inherit"
+    });
+    child.on("exit", (code) => {
+      process.exitCode = code ?? 0;
+    });
+    process.on("SIGINT", () => {
+      child.kill("SIGINT");
+    });
+  }
+});
+function findServerEntry3() {
+  const candidates = [
+    resolve5(process.cwd(), "packages/server/src/index.ts"),
+    resolve5(process.cwd(), "../server/src/index.ts")
+  ];
+  for (const c of candidates) {
+    if (existsSync7(c)) return c;
+  }
+  return null;
+}
+
+// src/commands/connect.ts
+import { Command as Command10 } from "commander";
+import { WebSocket } from "ws";
+import pc11 from "picocolors";
+var connectCommand = new Command10("connect").description("Open a persistent WebSocket connection and stream events").option("--subscribe <patterns>", "Comma-separated event patterns to subscribe to", "*").action(async (opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  const wsUrl = serverUrl.replace(/^http/, "ws");
+  const url = token ? `${wsUrl}/ws/agent?token=${token}` : `${wsUrl}/ws/agent`;
+  console.log(pc11.blue(`Connecting to ${serverUrl}...`));
+  const ws = new WebSocket(url);
+  ws.on("open", () => {
+    console.log(pc11.green("Connected"));
+    const patterns = opts.subscribe.split(",").map((p) => p.trim());
+    ws.send(JSON.stringify({
+      type: "subscribe",
+      patterns
+    }));
+  });
+  ws.on("message", (raw) => {
+    try {
+      const frame = JSON.parse(raw.toString());
+      switch (frame.type) {
+        case "subscribed":
+          console.log(pc11.dim(`Subscribed to: ${frame.patterns.join(", ")}`));
+          break;
+        case "event": {
+          const e = frame.event;
+          const ts = new Date(e.timestamp).toLocaleTimeString();
+          const status = e.result?.status === "success" ? pc11.green("\u2713") : pc11.red("\u2717");
+          console.log(
+            `${pc11.dim(ts)} ${status} ${pc11.bold(e.app)}.${e.action} [${e.source}]` + (e.duration_ms != null ? pc11.dim(` ${e.duration_ms}ms`) : "")
+          );
+          if (globalOpts.verbose && e.result) {
+            console.log(pc11.dim(`  \u2192 ${JSON.stringify(e.result)}`));
+          }
+          break;
+        }
+        case "result":
+          if (frame.status === "success") {
+            console.log(pc11.green(`Result: ${JSON.stringify(frame.output)}`));
+          } else {
+            console.log(pc11.red(`Error: ${frame.error}`));
+          }
+          break;
+        case "pong":
+          break;
+        case "error":
+          console.log(pc11.red(`Server error: ${frame.message}`));
+          break;
+        default:
+          if (globalOpts.verbose) {
+            console.log(pc11.dim(JSON.stringify(frame)));
+          }
+      }
+    } catch {
+      console.log(pc11.dim(raw.toString()));
+    }
+  });
+  ws.on("close", (code, reason) => {
+    console.log(pc11.yellow(`Disconnected (${code}: ${reason.toString() || "no reason"})`));
+    process.exit(0);
+  });
+  ws.on("error", (err) => {
+    console.error(pc11.red(`WebSocket error: ${err.message}`));
+    process.exit(1);
+  });
+  const pingInterval = setInterval(() => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, 3e4);
+  process.on("SIGINT", () => {
+    clearInterval(pingInterval);
+    ws.close();
+  });
+});
+
+// src/commands/events.ts
+import { Command as Command11 } from "commander";
+import pc12 from "picocolors";
+var eventsCommand = new Command11("events").description("Fetch recent events").option("--app <name>", "Filter by app name").option("--since <timestamp>", "Show events since ISO timestamp").option("--limit <n>", "Max events to return", "20").option("--json", "Output as JSON").action(async (opts, cmd) => {
+  const globalOpts = { ...cmd.parent?.opts() ?? {}, ...opts };
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  const params = new URLSearchParams();
+  if (opts.app) params.set("app", opts.app);
+  if (opts.since) params.set("since", opts.since);
+  if (opts.limit) params.set("limit", opts.limit);
+  const url = `${serverUrl}/api/events?${params.toString()}`;
+  try {
+    const res = await fetch(url, {
+      headers: {
+        ...authHeaders(token)
+      }
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc12.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (data.events.length === 0) {
+      console.log(pc12.dim("No events found"));
+      return;
+    }
+    for (const e of data.events.reverse()) {
+      const ts = new Date(e.timestamp).toLocaleTimeString();
+      const status = e.result?.status === "success" ? pc12.green("\u2713") : pc12.red("\u2717");
+      console.log(
+        `${pc12.dim(ts)} ${status} ${pc12.bold(e.app)}.${e.action} [${e.source}]` + (e.duration_ms != null ? pc12.dim(` ${e.duration_ms}ms`) : "")
+      );
+      if (globalOpts.verbose && e.result) {
+        console.log(pc12.dim(`  \u2192 ${JSON.stringify(e.result)}`));
+      }
+    }
+    console.log(pc12.dim(`
+${data.events.length} event(s)`));
+  } catch (e) {
+    console.error(pc12.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/agent.ts
+import { Command as Command12 } from "commander";
+import pc13 from "picocolors";
+var agentCommand = new Command12("agent").description("Manage agents");
+agentCommand.command("list").description("List agents for current user").action(async (_opts, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  try {
+    const res = await fetch(`${serverUrl}/auth/agents`, {
+      headers: authHeaders(token)
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc13.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    if (data.agents.length === 0) {
+      console.log(pc13.dim("No agents"));
+      return;
+    }
+    for (const agent of data.agents) {
+      console.log(`${pc13.bold(agent.name)} ${pc13.dim(`(${agent.id})`)}`);
+      console.log(`  Token: ${pc13.dim(agent.token)}`);
+      console.log(`  Created: ${pc13.dim(agent.createdAt)}`);
+    }
+  } catch (e) {
+    console.error(pc13.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+agentCommand.command("create").description("Create a new agent").argument("<name>", "Agent name").action(async (name, _opts, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  try {
+    const res = await fetch(`${serverUrl}/auth/agents`, {
+      method: "POST",
+      headers: authHeaders(token),
+      body: JSON.stringify({ name })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc13.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    console.log(pc13.green(`Created agent: ${pc13.bold(data.agent.name)}`));
+    console.log(`  ID:    ${data.agent.id}`);
+    console.log(`  Token: ${data.agent.token}`);
+  } catch (e) {
+    console.error(pc13.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+agentCommand.command("info").description("Show current user and agent info").action(async (_opts, cmd) => {
+  const globalOpts = cmd.parent?.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  try {
+    const res = await fetch(`${serverUrl}/auth/me`, {
+      headers: authHeaders(token)
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc13.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log(`User:  ${pc13.bold(data.user.email)} ${pc13.dim(`(${data.user.id})`)}`);
+    console.log(`Agent: ${pc13.bold(data.currentAgent.name)} ${pc13.dim(`(${data.currentAgent.id})`)}`);
+    if (data.agents.length > 1) {
+      console.log(`
+All agents:`);
+      for (const a of data.agents) {
+        const current = a.id === data.currentAgent.id ? pc13.green(" (current)") : "";
+        console.log(`  ${pc13.bold(a.name)} ${pc13.dim(a.id)}${current}`);
+      }
+    }
+  } catch (e) {
+    console.error(pc13.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/register.ts
+import { Command as Command13 } from "commander";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import pc14 from "picocolors";
+var registerCommand = new Command13("register").description("Register an external app via HTTP bridge manifest").argument("<manifest>", "Path to YAML manifest file").option("--adapter <url>", "Override base URL from manifest").action(async (manifestPath, opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  if (!existsSync8(manifestPath)) {
+    console.error(pc14.red(`Error: Manifest not found: ${manifestPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const raw = readFileSync6(manifestPath, "utf-8");
+    const res = await fetch(`${serverUrl}/api/bridges/http`, {
+      method: "POST",
+      headers: authHeaders(token),
+      body: JSON.stringify({
+        manifest: raw,
+        adapterUrl: opts.adapter
+      })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc14.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    console.log(pc14.green(`Registered bridge: ${pc14.bold(data.name)}`));
+    if (data.commands?.length > 0) {
+      console.log(`  Commands: ${data.commands.join(", ")}`);
+    }
+    if (data.actions?.length > 0) {
+      console.log(`  Actions: ${data.actions.join(", ")}`);
+    }
+  } catch (e) {
+    console.error(pc14.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/wrap.ts
+import { Command as Command14 } from "commander";
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import pc15 from "picocolors";
+var wrapCommand = new Command14("wrap").description("Register CLI tool as app commands via YAML manifest").argument("<manifest>", "Path to CLI wrapper YAML manifest").action(async (manifestPath, _opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  if (!existsSync9(manifestPath)) {
+    console.error(pc15.red(`Error: Manifest not found: ${manifestPath}`));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const raw = readFileSync7(manifestPath, "utf-8");
+    const res = await fetch(`${serverUrl}/api/bridges/cli`, {
+      method: "POST",
+      headers: authHeaders(token),
+      body: JSON.stringify({ manifest: raw })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc15.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    console.log(pc15.green(`Wrapped CLI: ${pc15.bold(data.name)}`));
+    if (data.commands?.length > 0) {
+      console.log(`  Commands: ${data.commands.join(", ")}`);
+    }
+  } catch (e) {
+    console.error(pc15.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/reload.ts
+import { Command as Command15 } from "commander";
+import pc16 from "picocolors";
+var reloadCommand = new Command15("reload").description("Reload an app").argument("<app>", "App name to reload").action(async (appName, _opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  try {
+    const res = await fetch(`${serverUrl}/api/apps/${appName}/reload`, {
+      method: "POST",
+      headers: authHeaders(token),
+      body: "{}"
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      console.error(pc16.red(`Error: ${body.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    const data = await res.json();
+    console.log(pc16.green(`Reloaded: ${pc16.bold(data.name)} (${data.status})`));
+  } catch (e) {
+    console.error(pc16.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+var configCommand = new Command15("config").description("View or set app configuration").argument("[app]", "App name").argument("[key]", "Config key").argument("[value]", "Config value (omit to read)").action(async (appName, key, value, _opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  if (!appName) {
+    try {
+      const res = await fetch(`${serverUrl}/api/config`, {
+        headers: authHeaders(token)
+      });
+      const data = await res.json();
+      console.log(JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error(pc16.red(`Error: ${e.message}`));
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (!key) {
+    try {
+      const res = await fetch(`${serverUrl}/api/apps/${appName}`, {
+        headers: authHeaders(token)
+      });
+      if (!res.ok) {
+        console.error(pc16.red(`App not found: ${appName}`));
+        process.exitCode = 1;
+        return;
+      }
+      const data = await res.json();
+      console.log(JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error(pc16.red(`Error: ${e.message}`));
+      process.exitCode = 1;
+    }
+    return;
+  }
+  console.log(pc16.dim(`Config management for ${appName}.${key}${value ? ` = ${value}` : ""}`));
+  console.log(pc16.dim("(Config persistence coming in a future update)"));
+});
+
+// src/commands/skill.ts
+import { Command as Command16 } from "commander";
+import pc17 from "picocolors";
+async function fetchSkill(serverUrl, token, appName, opts) {
+  const qs = new URLSearchParams();
+  if (opts.json) qs.set("format", "json");
+  if (opts.refresh) qs.set("refresh", "1");
+  const url = `${serverUrl}/api/apps/${appName}/skill${qs.toString() ? `?${qs}` : ""}`;
+  let res;
+  try {
+    res = await fetch(url, { headers: authHeaders(token) });
+  } catch (e) {
+    const code = e?.cause?.code;
+    const hint = code === "ECONNREFUSED" ? ` \u2014 nothing is listening. Run \`bot server start\` to pick a server, or set BOTAPP_SERVER to point at a running instance.` : code ? ` (${code})` : "";
+    throw new Error(`Cannot reach ${serverUrl}${hint}`);
+  }
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body?.error ?? `HTTP ${res.status}`);
+  }
+  if (opts.json) {
+    return await res.json();
+  }
+  return await res.text();
+}
+var skillSingle = new Command16("skill").description("Fetch an app's skill doc (agent-facing narrative + reference)").argument("[app]", "App name. Omit to list all apps with their skill source.").option("--json", "Emit structured JSON instead of markdown").option("--refresh", "Bypass the server-side URL cache").option("--bundle", "When no app given, print every app as one big markdown doc").action(async (appName, opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const token = resolveToken(globalOpts.token);
+  try {
+    if (!appName) {
+      const client = createClient(serverUrl, token);
+      const data = await client.listApps();
+      const apps = data.apps ?? [];
+      if (opts.bundle) {
+        const chunks = [
+          "# botapp server \u2014 app skills bundle",
+          "",
+          `_Generated from ${serverUrl}. ${apps.length} app(s)._`,
+          "",
+          "---",
+          ""
+        ];
+        for (const app of apps) {
+          try {
+            const md = await fetchSkill(serverUrl, token, app.name, {});
+            chunks.push(md, "", "---", "");
+          } catch (e) {
+            chunks.push(
+              `# ${app.name}`,
+              "",
+              `> (failed to load: ${e.message})`,
+              "",
+              "---",
+              ""
+            );
+          }
+        }
+        console.log(chunks.join("\n"));
+        return;
+      }
+      if (globalOpts.json || opts.json) {
+        console.log(JSON.stringify(apps, null, 2));
+        return;
+      }
+      if (apps.length === 0) {
+        console.log(pc17.yellow("No apps installed"));
+        return;
+      }
+      console.log(pc17.bold("App skills:"));
+      console.log();
+      for (const app of apps) {
+        const src = app.skill ? /^https?:\/\//i.test(app.skill) ? pc17.cyan(app.skill) : pc17.green(app.skill) : pc17.dim("(none declared \u2014 fallback to ./SKILL.md or auto-gen)");
+        console.log(
+          `  ${pc17.bold(app.name)}${pc17.dim(` \u2014 ${app.description ?? ""}`)}`
+        );
+        console.log(`    skill: ${src}`);
+      }
+      console.log();
+      console.log(
+        pc17.dim(
+          `Run \`bot skill <app>\` to fetch one, or \`bot skill --bundle\` for everything.`
+        )
+      );
+      return;
+    }
+    const wantJson = globalOpts.json || opts.json;
+    const result = await fetchSkill(serverUrl, token, appName, {
+      json: wantJson,
+      refresh: opts.refresh
+    });
+    if (wantJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(result);
+    }
+  } catch (e) {
+    console.error(pc17.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+}).addHelpText(
+  "after",
+  `
+Examples:
+  $ bot skill                     List every app with its skill source
+  $ bot skill trading              Print the trading app's skill markdown
+  $ bot skill trading --json       Structured response (source, url, content)
+  $ bot skill trading --refresh    Bypass the 5-minute URL cache
+  $ bot skill --bundle             Print every app's skill in one markdown doc
+
+Sources, in lookup order:
+  manifest.skill (URL)     Fetched, cached 5 min
+  manifest.skill (path)    Read from disk relative to the app's manifest
+  ./SKILL.md (convention)  Read if no manifest field
+  auto                      Generated from registered commands/actions/widgets
+`
+);
+var skillCommand = skillSingle;
+
+// src/commands/pairing.ts
+import { hostname as hostname2 } from "os";
+import { Command as Command17 } from "commander";
+import pc18 from "picocolors";
+var pairingCommand = new Command17("pairing").alias("pair").description("Pair this machine as a botapp daemon").option("--token <token>", "Pairing token (skip browser flow)").option("--name <name>", "Daemon name", hostname2()).option("--app-url <url>", "Dashboard URL (defaults to server URL)").option("--no-browser", "Error instead of opening a browser").action(async (opts, cmd) => {
+  const globalOpts = cmd.parent?.opts() ?? {};
+  const serverUrl = resolveServerUrl(globalOpts.server);
+  const name = opts.name;
+  try {
+    const grant = await obtainPairingToken({
+      serverUrl,
+      appUrl: opts.appUrl,
+      name,
+      explicitToken: opts.token,
+      allowBrowser: opts.browser !== false
+    });
+    if (!grant) {
+      console.error(
+        pc18.red(
+          "No pairing token and browser flow disabled. Pass --token, or drop --no-browser."
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (grant.userEmail) {
+      console.log(pc18.green(`Authenticated as ${pc18.bold(grant.userEmail)}`));
+    }
+    const res = await fetch(`${serverUrl}/api/daemon/pair`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        token: grant.pairingToken,
+        name,
+        machine: hostname2()
+      })
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      console.error(pc18.red(`Error: ${data.error ?? res.statusText}`));
+      process.exitCode = 1;
+      return;
+    }
+    saveDaemonProfile({
+      server: serverUrl,
+      daemonId: data.daemon.id,
+      daemonName: data.daemon.name,
+      token: data.token
+    });
+    console.log(pc18.green(`Paired daemon: ${pc18.bold(data.daemon.name)}`));
+    console.log(`  ID:     ${data.daemon.id}`);
+    console.log(`  Server: ${serverUrl}`);
+    console.log(pc18.dim("\nNext: botapp daemon agent add codex --command codex"));
+    console.log(pc18.dim("Then: botapp daemon run"));
+  } catch (e) {
+    console.error(pc18.red(`Error: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+async function obtainPairingToken(opts) {
+  if (opts.explicitToken) return { pairingToken: opts.explicitToken };
+  const localToken = await tryLocalFastPath(opts.serverUrl, opts.name);
+  if (localToken) return { pairingToken: localToken };
+  if (!opts.allowBrowser) return null;
+  const appUrl = opts.appUrl ?? opts.serverUrl;
+  const result = await runBrowserAuth({
+    serverUrl: opts.serverUrl,
+    appUrl,
+    scope: "pair",
+    name: opts.name
+  });
+  if (!result.pairingToken) {
+    throw new Error("server returned no pairing token");
+  }
+  return { pairingToken: result.pairingToken, userEmail: result.userEmail };
+}
+async function tryLocalFastPath(serverUrl, name) {
+  let mode = null;
+  try {
+    const res = await fetch(`${serverUrl}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => ({}));
+    mode = data.mode ?? null;
+  } catch {
+    return null;
+  }
+  if (mode !== "local") return null;
+  try {
+    const res = await fetch(`${serverUrl}/api/daemon/pairing-tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => ({}));
+    return data.token ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/daemon.ts
+import { spawn as spawn5 } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync8, statSync } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7, resolve as resolve6 } from "path";
+import { createInterface as createInterface3 } from "readline";
+import { Command as Command18 } from "commander";
+import { WebSocket as WebSocket2 } from "ws";
+import pc19 from "picocolors";
+var daemonCommand = new Command18("daemon").description("Manage and run the local botapp daemon");
+daemonCommand.command("run").description("Run the local daemon and wait for server jobs").action(async () => {
+  const profile = loadDaemonProfile();
+  if (!profile) {
+    console.error(pc19.red("No paired daemon found. Run `bot pair` first."));
+    process.exitCode = 1;
+    return;
+  }
+  await runDaemonConnectionLoop(profile);
+});
+daemonCommand.command("stop").description("Stop the background daemon started by `bot launch`").action(async () => {
+  const pidFile = join7(homedir7(), ".botapp", "daemon.pid");
+  if (!existsSync10(pidFile)) {
+    console.log(pc19.yellow("No background daemon PID file found."));
+    return;
+  }
+  try {
+    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) {
+      console.error(pc19.red(`Invalid PID in ${pidFile}`));
+      process.exitCode = 1;
+      return;
+    }
+    process.kill(pid, "SIGTERM");
+    console.log(pc19.green(`Stopped daemon (pid ${pid})`));
+  } catch (e) {
+    console.error(pc19.red(`Failed to stop daemon: ${e.message}`));
+    process.exitCode = 1;
+  }
+});
+daemonCommand.command("agent").description("Manage agents hosted by this daemon").addCommand(
+  new Command18("list").description("List registered daemon agents").action(async () => {
+    const profile = requireProfile();
+    if (!profile) return;
+    const data = await daemonRequest(profile.server, profile.token, "/api/daemon/self/agents");
+    for (const agent of data.agents ?? []) {
+      console.log(`${pc19.bold(agent.name)} ${pc19.dim(`(${agent.id})`)}`);
+      console.log(`  Kind:    ${agent.kind}`);
+      console.log(`  Command: ${agent.command} ${(agent.args ?? []).join(" ")}`);
+      if (agent.cwd) console.log(`  CWD:     ${agent.cwd}`);
+    }
+  })
+).addCommand(createDaemonAgentConfigCommand()).addCommand(
+  new Command18("add").description("Register a local agent command").argument("<name>", "Name, e.g. codex, claude-code, openclaw, hermes, or hermes-agent").requiredOption("--command <command>", "Executable command").option(
+    "--kind <kind>",
+    "Agent adapter kind: acp, codex, claude-code, openclaw, hermes, hermes-agent, or shell",
+    "acp"
+  ).option("--arg <arg...>", "Argument passed to the executable").option("--cwd <cwd>", "Working directory for the agent process").option("--env <entry...>", "Environment entries in KEY=VALUE form").action(async (name, opts) => {
+    const profile = requireProfile();
+    if (!profile) return;
+    const env = parseEnv(opts.env ?? []);
+    const data = await daemonRequest(
+      profile.server,
+      profile.token,
+      "/api/daemon/self/agents",
+      {
+        method: "POST",
+        body: {
+          name,
+          kind: opts.kind,
+          command: opts.command,
+          args: opts.arg ?? [],
+          cwd: opts.cwd,
+          env
+        }
+      }
+    );
+    console.log(pc19.green(`Registered daemon agent: ${pc19.bold(data.agent.name)}`));
+    console.log(`  ID:      ${data.agent.id}`);
+    console.log(`  Command: ${data.agent.command} ${(data.agent.args ?? []).join(" ")}`);
+  })
+).addCommand(
+  new Command18("remove").alias("rm").description("Remove a daemon agent by id or name").argument("<agent>", "Daemon agent id or name").action(async (agent) => {
+    const profile = requireProfile();
+    if (!profile) return;
+    const data = await daemonRequest(
+      profile.server,
+      profile.token,
+      `/api/daemon/self/agents/${encodeURIComponent(agent)}`,
+      { method: "DELETE" }
+    );
+    console.log(pc19.green(`Removed daemon agent: ${pc19.bold(data.agent.name)}`));
+    console.log(`  ID: ${data.agent.id}`);
+  })
+);
+async function runDaemonConnectionLoop(profile) {
+  const wsUrl = `${profile.server.replace(/^http/, "ws")}/ws/daemon?token=${profile.token}`;
+  const baseRetryMs = envNumber(process.env, "BOTAPP_DAEMON_RETRY_MS", 1e3);
+  const maxRetryMs = envNumber(process.env, "BOTAPP_DAEMON_MAX_RETRY_MS", 3e4);
+  let stopped = false;
+  let activeWs = null;
+  let retryMs = baseRetryMs;
+  let retryTimer = null;
+  let resolveRetry = null;
+  const stop = () => {
+    stopped = true;
+    if (activeWs && activeWs.readyState !== WebSocket2.CLOSED) {
+      activeWs.close();
+    }
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    }
+    resolveRetry?.();
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  while (!stopped) {
+    console.log(pc19.blue(`Connecting daemon ${profile.daemonName} to ${profile.server}...`));
+    const outcome = await runDaemonSocket(wsUrl, (ws) => {
+      activeWs = ws;
+    });
+    activeWs = null;
+    if (stopped) break;
+    const waitMs = outcome.opened ? baseRetryMs : retryMs;
+    retryMs = outcome.opened ? baseRetryMs : Math.min(retryMs * 2, maxRetryMs);
+    console.log(pc19.yellow(`Retrying daemon connection in ${Math.round(waitMs / 1e3)}s...`));
+    await new Promise((resolveWait) => {
+      resolveRetry = resolveWait;
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        resolveRetry = null;
+        resolveWait();
+      }, waitMs);
+    });
+  }
+}
+function runDaemonSocket(wsUrl, setActiveWs) {
+  return new Promise((resolveRun) => {
+    const ws = new WebSocket2(wsUrl);
+    setActiveWs(ws);
+    let opened = false;
+    let settled = false;
+    let ping = null;
+    function finish() {
+      if (settled) return;
+      settled = true;
+      if (ping) clearInterval(ping);
+      resolveRun({ opened });
+    }
+    ws.on("open", () => {
+      opened = true;
+      console.log(pc19.green("Daemon connected"));
+      ws.send(JSON.stringify({ type: "daemon_ready" }));
+      ping = setInterval(() => {
+        if (ws.readyState === WebSocket2.OPEN) ws.send(JSON.stringify({ type: "ping" }));
+      }, 3e4);
+    });
+    ws.on("message", (raw) => {
+      void handleFrame(ws, raw.toString());
+    });
+    ws.on("close", (code, reason) => {
+      console.log(pc19.yellow(`Daemon disconnected (${code}: ${reason.toString() || "no reason"})`));
+      finish();
+    });
+    ws.on("error", (err) => {
+      console.error(pc19.red(`Daemon WebSocket error: ${err.message}`));
+      if (!opened) {
+        if (ws.readyState !== WebSocket2.CLOSED) ws.terminate();
+        finish();
+      }
+    });
+  });
+}
+async function handleFrame(ws, raw) {
+  const frame = JSON.parse(raw);
+  if (frame.type === "daemon_job") {
+    const job = frame.job;
+    console.log(pc19.blue(`Running ${job.agent.name} job ${job.id}`));
+    ws.send(JSON.stringify({ type: "daemon_job_started", jobId: job.id }));
+    try {
+      const result = await runAgentJob(job, (update) => {
+        if (ws.readyState === WebSocket2.OPEN) {
+          ws.send(JSON.stringify({
+            type: "daemon_job_update",
+            jobId: job.id,
+            update
+          }));
+        }
+      });
+      ws.send(JSON.stringify({
+        type: "daemon_job_result",
+        jobId: job.id,
+        status: "succeeded",
+        result
+      }));
+      console.log(pc19.green(`Completed job ${job.id}`));
+    } catch (e) {
+      ws.send(JSON.stringify({
+        type: "daemon_job_result",
+        jobId: job.id,
+        status: "failed",
+        error: e.message
+      }));
+      console.error(pc19.red(`Job ${job.id} failed: ${e.message}`));
+    }
+    return;
+  }
+  if (frame.type === "error") {
+    console.error(pc19.red(`Server error: ${frame.message}`));
+  }
+}
+async function runAgentJob(job, update) {
+  if (job.agent.kind === "codex") {
+    return runCodexAgent(job, update);
+  }
+  if (job.agent.kind === "claude-code" || job.agent.kind === "claude_code") {
+    return runClaudeCodeAgent(job, update);
+  }
+  if (job.agent.kind === "openclaw" || job.agent.kind === "kimiclaw") {
+    return runOpenClawAgent(job, update);
+  }
+  if (job.agent.kind === "hermes" || job.agent.kind === "hermes-agent") {
+    return runHermesAgent(job, update);
+  }
+  if (job.agent.kind === "shell") {
+    return runShellAgent(job);
+  }
+  return runAcpAgent(job);
+}
+async function runShellAgent(job) {
+  const child = spawn5(job.agent.command, [...job.agent.args, job.query], {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env: { ...process.env, ...job.agent.env ?? {} }
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `Agent exited with code ${code}`);
+  }
+  return stdout.trim();
+}
+async function runCodexAgent(job, update) {
+  const args = [...job.agent.args];
+  if (!args.includes("exec") && !args.includes("e")) {
+    args.unshift("exec");
+  }
+  if (!args.includes("--json")) {
+    args.push("--json");
+  }
+  if (!args.includes("--skip-git-repo-check")) {
+    args.push("--skip-git-repo-check");
+  }
+  if (!hasAnyFlag(args, [
+    "--sandbox",
+    "-s",
+    "--ask-for-approval",
+    "-a",
+    "--full-auto",
+    "--dangerously-bypass-approvals-and-sandbox"
+  ])) {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  args.push(job.query);
+  const child = spawn5(job.agent.command, args, {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env: { ...process.env, ...job.agent.env ?? {} },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const result = {
+    kind: "codex",
+    text: "",
+    messages: [],
+    toolCalls: [],
+    rawEvents: []
+  };
+  const toolCalls = /* @__PURE__ */ new Map();
+  function processLine(line) {
+    if (!line.trim()) return;
+    try {
+      const event = JSON.parse(line);
+      result.rawEvents.push(event);
+      update({ kind: "codex_event", event });
+      if (event?.type === "item.completed" && event.item?.type === "agent_message") {
+        if (typeof event.item.text === "string") {
+          result.messages.push(event.item.text);
+          update({ kind: "message", text: event.item.text });
+        }
+      }
+      if ((event?.type === "item.started" || event?.type === "item.completed") && typeof event.item?.id === "string" && event.item?.type && event.item.type !== "agent_message") {
+        const existing = toolCalls.get(event.item.id) ?? {
+          id: event.item.id,
+          type: String(event.item.type)
+        };
+        const next = {
+          ...existing,
+          type: String(event.item.type),
+          status: event.item.status ?? existing.status,
+          command: event.item.command ?? existing.command,
+          output: event.item.aggregated_output ?? event.item.output ?? existing.output,
+          exitCode: event.item.exit_code ?? existing.exitCode
+        };
+        toolCalls.set(event.item.id, next);
+        update({ kind: "tool_call", toolCall: next });
+      }
+    } catch {
+    }
+  }
+  const rl = createInterface3({ input: child.stdout });
+  rl.on("line", processLine);
+  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `Codex exited with code ${code}`);
+  }
+  result.text = result.messages.at(-1)?.trim() || "";
+  result.toolCalls = [...toolCalls.values()];
+  return JSON.stringify(result);
+}
+async function runClaudeCodeAgent(job, update) {
+  const args = [...job.agent.args];
+  if (!args.includes("-p") && !args.includes("--print")) {
+    args.push("-p");
+  }
+  if (!args.includes("--output-format")) {
+    args.push("--output-format", "stream-json");
+  }
+  if (!args.includes("--verbose")) {
+    args.push("--verbose");
+  }
+  if (!hasAnyFlag(args, [
+    "--permission-mode",
+    "--dangerously-skip-permissions",
+    "--allow-dangerously-skip-permissions"
+  ])) {
+    args.push("--permission-mode", "bypassPermissions");
+  }
+  const resume = job.resumeSessionId ?? job.agent.env?.CLAUDE_SESSION_ID ?? null;
+  if (resume && !args.includes("--resume")) {
+    args.push("--resume", resume);
+  }
+  const child = spawn5(job.agent.command, args, {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env: { ...process.env, ...job.agent.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdin.write(job.query);
+  child.stdin.end();
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const result = {
+    kind: "claude-code",
+    text: "",
+    messages: [],
+    toolCalls: [],
+    sessionId: resume,
+    rawEvents: []
+  };
+  const toolCalls = /* @__PURE__ */ new Map();
+  function captureSessionId(event) {
+    const id = event?.session_id ?? event?.sessionId;
+    if (typeof id === "string" && id.length > 0) {
+      result.sessionId = id;
+    }
+  }
+  function ingestAssistantContent(blocks) {
+    for (const block of blocks) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "text" && typeof block.text === "string") {
+        result.messages.push(block.text);
+        update({ kind: "message", text: block.text });
+      }
+      if (block.type === "tool_use" && typeof block.id === "string") {
+        const existing = toolCalls.get(block.id) ?? { id: block.id, name: String(block.name ?? "tool") };
+        const next = {
+          ...existing,
+          name: String(block.name ?? existing.name ?? "tool"),
+          input: block.input ?? existing.input
+        };
+        toolCalls.set(block.id, next);
+        update({ kind: "tool_call", toolCall: next });
+      }
+    }
+  }
+  function ingestUserContent(blocks) {
+    for (const block of blocks) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type !== "tool_result") continue;
+      const id = block.tool_use_id;
+      if (typeof id !== "string") continue;
+      const existing = toolCalls.get(id) ?? { id, name: "tool" };
+      const output2 = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((item) => typeof item?.text === "string" ? item.text : "").join("") : void 0;
+      const next = {
+        ...existing,
+        output: output2 ?? existing.output,
+        isError: Boolean(block.is_error ?? existing.isError)
+      };
+      toolCalls.set(id, next);
+      update({ kind: "tool_call", toolCall: next });
+    }
+  }
+  function processLine(line) {
+    if (!line.trim()) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    result.rawEvents.push(event);
+    update({ kind: "claude_code_event", event });
+    captureSessionId(event);
+    if (event.type === "assistant" && event.message?.content) {
+      ingestAssistantContent(
+        Array.isArray(event.message.content) ? event.message.content : []
+      );
+      return;
+    }
+    if (event.type === "user" && event.message?.content) {
+      ingestUserContent(
+        Array.isArray(event.message.content) ? event.message.content : []
+      );
+      return;
+    }
+    if (event.type === "result" && typeof event.result === "string") {
+      result.text = event.result;
+    }
+  }
+  const rl = createInterface3({ input: child.stdout });
+  rl.on("line", processLine);
+  const code = await new Promise((resolve7) => child.on("close", resolve7));
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `Claude Code exited with code ${code}`);
+  }
+  if (!result.text) {
+    result.text = result.messages.at(-1)?.trim() ?? "";
+  }
+  result.toolCalls = [...toolCalls.values()];
+  return JSON.stringify(result);
+}
+async function runOpenClawAgent(job, update) {
+  const env = { ...process.env, ...job.agent.env ?? {} };
+  const args = [...job.agent.args];
+  if (!args.includes("agent")) {
+    args.unshift("agent");
+  }
+  let usedPromptPlaceholder = false;
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].includes("{prompt}")) continue;
+    args[i] = args[i].replaceAll("{prompt}", job.query);
+    usedPromptPlaceholder = true;
+  }
+  if (!usedPromptPlaceholder) {
+    const promptArg = env.BOTAPP_OPENCLAW_PROMPT_ARG ?? env.OPENCLAW_PROMPT_ARG ?? "--message";
+    if (promptArg) {
+      args.push(promptArg, job.query);
+    } else {
+      args.push(job.query);
+    }
+  }
+  let requestedSessionId = getFlagValue(args, "--session-id");
+  if (!requestedSessionId) {
+    requestedSessionId = job.resumeSessionId || `botapp-${randomUUID()}`;
+    args.push("--session-id", requestedSessionId);
+  }
+  if (!hasFlag(args, "--verbose")) {
+    args.push("--verbose", "on");
+  }
+  const sessionDir = resolveOpenClawSessionDir(args, env);
+  const state = {
+    startedAtMs: Date.now(),
+    sessionDir,
+    sessionStorePath: join7(sessionDir, "sessions.json"),
+    requestedSessionId,
+    sessionKey: null,
+    sessionId: null,
+    sessionResolvedBy: null,
+    initialOffsets: snapshotOpenClawSessionOffsets(sessionDir),
+    selectedFile: null,
+    offset: 0,
+    pending: "",
+    seenEventIds: /* @__PURE__ */ new Set()
+  };
+  const result = {
+    kind: "openclaw",
+    text: "",
+    messages: [],
+    toolCalls: [],
+    sessionId: null,
+    requestedSessionId,
+    sessionKey: null,
+    sessionFile: null,
+    rawEvents: []
+  };
+  const toolCalls = /* @__PURE__ */ new Map();
+  let stderr = "";
+  let stopPolling = false;
+  const child = spawn5(job.agent.command, args, {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdout = createInterface3({ input: child.stdout });
+  stdout.on("line", () => {
+  });
+  const stderrReader = createInterface3({ input: child.stderr });
+  stderrReader.on("line", (line) => {
+    if (!line.trim()) return;
+    stderr += `${line}
+`;
+  });
+  const pollIntervalMs = envNumber(env, "BOTAPP_OPENCLAW_POLL_INTERVAL_MS", 500);
+  const stableAfterExitMs = envNumber(env, "BOTAPP_OPENCLAW_STABLE_AFTER_EXIT_MS", 1e3);
+  const timeoutMs = resolveOpenClawTimeoutMs(env);
+  const tailTask = (async () => {
+    while (!stopPolling) {
+      readOpenClawSessionUpdates(state, result, toolCalls, update);
+      await sleep(pollIntervalMs);
+    }
+    readOpenClawSessionUpdates(state, result, toolCalls, update, true);
+  })();
+  let code;
+  try {
+    code = await waitForChild(child, timeoutMs, "OpenClaw");
+    await sleep(stableAfterExitMs);
+  } finally {
+    stopPolling = true;
+    await tailTask;
+  }
+  if (state.pending.trim()) {
+    handleOpenClawJsonlLine(state.pending.trim(), state, result, toolCalls, update);
+    state.pending = "";
+  }
+  result.sessionFile = state.selectedFile;
+  result.toolCalls = [...toolCalls.values()];
+  result.text = result.text || result.messages.at(-1)?.trim() || "";
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `OpenClaw exited with code ${code}`);
+  }
+  if (!result.sessionId) {
+    throw new Error(
+      [
+        "OpenClaw completed, but the session key was not resolved from sessions.json.",
+        `Session store: ${state.sessionStorePath}`,
+        `Requested session id fragment: ${state.requestedSessionId}`
+      ].join("\n")
+    );
+  }
+  if (!result.text && result.toolCalls.length === 0) {
+    throw new Error(
+      [
+        "OpenClaw completed, but no assistant message was found in session JSONL.",
+        `Session directory: ${sessionDir}`,
+        state.selectedFile ? `Selected session file: ${state.selectedFile}` : "Selected session file: none",
+        "Check BOTAPP_OPENCLAW_SESSION_DIR, --agent, or the OpenClaw JSONL message format."
+      ].join("\n")
+    );
+  }
+  return JSON.stringify(result);
+}
+function resolveOpenClawSessionDir(args, env) {
+  const configured = env.BOTAPP_OPENCLAW_SESSION_DIR ?? env.OPENCLAW_SESSION_DIR;
+  if (configured) return expandPath(configured);
+  const agentName = resolveOpenClawAgentName(args);
+  return join7(homedir7(), ".openclaw", "agents", agentName, "sessions");
+}
+function resolveOpenClawAgentName(args) {
+  return getFlagValue(args, "--agent") ?? "main";
+}
+function snapshotOpenClawSessionOffsets(sessionDir) {
+  const offsets = /* @__PURE__ */ new Map();
+  for (const file of listOpenClawSessionFiles(sessionDir)) {
+    try {
+      offsets.set(file, statSync(file).size);
+    } catch {
+    }
+  }
+  return offsets;
+}
+function readOpenClawSessionUpdates(state, result, toolCalls, update, final = false) {
+  resolveOpenClawRealSessionId(state, result);
+  if (!state.sessionId) return;
+  const selectedFile = state.selectedFile ?? selectOpenClawSessionFile(state);
+  if (!selectedFile) return;
+  if (!state.selectedFile) {
+    state.selectedFile = selectedFile;
+    state.offset = state.sessionResolvedBy === "key-fragment" ? 0 : state.initialOffsets.get(selectedFile) ?? 0;
+  }
+  let data = "";
+  try {
+    const buffer = readFileSync8(selectedFile);
+    if (state.offset > buffer.length) state.offset = 0;
+    data = buffer.subarray(state.offset).toString("utf-8");
+    state.offset = buffer.length;
+  } catch {
+    return;
+  }
+  if (!data && !final) return;
+  state.pending += data;
+  if (!state.pending) return;
+  const parts = state.pending.split("\n");
+  const completeLines = final || state.pending.endsWith("\n") ? parts : parts.slice(0, -1);
+  state.pending = final || state.pending.endsWith("\n") ? "" : parts.at(-1) ?? "";
+  for (const rawLine of completeLines) {
+    const line = rawLine.trim();
+    if (line) handleOpenClawJsonlLine(line, state, result, toolCalls, update);
+  }
+}
+function resolveOpenClawRealSessionId(state, result) {
+  if (state.sessionId) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(state.sessionStorePath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object") return;
+  let entry = null;
+  let sessionKey = null;
+  let resolvedBy = null;
+  for (const candidateKey of Object.keys(parsed)) {
+    if (!candidateKey.includes(state.requestedSessionId)) continue;
+    sessionKey = candidateKey;
+    entry = parsed[candidateKey];
+    resolvedBy = "key-fragment";
+    break;
+  }
+  if (!entry) {
+    for (const [candidateKey, candidateEntry] of Object.entries(parsed)) {
+      if (candidateEntry && typeof candidateEntry === "object" && candidateEntry.sessionId === state.requestedSessionId) {
+        sessionKey = candidateKey;
+        entry = candidateEntry;
+        resolvedBy = "entry-session-id";
+        break;
+      }
+    }
+  }
+  const realSessionId = entry?.sessionId;
+  if (typeof realSessionId !== "string" || !realSessionId.trim()) return;
+  state.sessionKey = sessionKey;
+  state.sessionId = realSessionId;
+  state.sessionResolvedBy = resolvedBy;
+  result.sessionKey = sessionKey;
+  result.sessionId = realSessionId;
+}
+function selectOpenClawSessionFile(state) {
+  const files = listOpenClawSessionFiles(state.sessionDir);
+  if (files.length === 0) return null;
+  if (state.sessionId) {
+    const exact = join7(state.sessionDir, `${state.sessionId}.jsonl`);
+    if (files.includes(exact)) return exact;
+    const matching = files.filter((file) => file.includes(state.sessionId ?? ""));
+    if (matching.length > 0) return newestFile(matching);
+  }
+  if (files.length === 1) return files[0];
+  const recent = files.filter((file) => {
+    try {
+      return statSync(file).mtimeMs >= state.startedAtMs - 1e3;
+    } catch {
+      return false;
+    }
+  });
+  return newestFile(recent.length > 0 ? recent : files);
+}
+function listOpenClawSessionFiles(sessionDir) {
+  try {
+    if (!existsSync10(sessionDir)) return [];
+    return readdirSync(sessionDir).filter((name) => name.endsWith(".jsonl")).map((name) => join7(sessionDir, name)).filter((file) => {
+      try {
+        return statSync(file).isFile();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function newestFile(files) {
+  if (files.length === 0) return null;
+  return files.reduce((selected, file) => {
+    try {
+      return statSync(file).mtimeMs > statSync(selected).mtimeMs ? file : selected;
+    } catch {
+      return selected;
+    }
+  }, files[0]);
+}
+function handleOpenClawJsonlLine(line, state, result, toolCalls, update) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return;
+  }
+  if (!event || typeof event !== "object") return;
+  const eventId = event.id;
+  if (typeof eventId === "string") {
+    if (state.seenEventIds.has(eventId)) return;
+    state.seenEventIds.add(eventId);
+  }
+  result.rawEvents.push(event);
+  update({ kind: "openclaw_event", event });
+  if (event.type !== "message" || !event.message || typeof event.message !== "object") {
+    return;
+  }
+  const message = event.message;
+  if (message.role === "assistant") {
+    ingestOpenClawAssistantMessage(event, result, toolCalls, update);
+  }
+  if (message.role === "toolResult") {
+    ingestOpenClawToolResult(event, toolCalls, update);
+  }
+}
+function ingestOpenClawAssistantMessage(event, result, toolCalls, update) {
+  const message = event.message;
+  const text = openClawContentText(message.content);
+  if (text) {
+    result.messages.push(text);
+    result.text = text;
+    update({ kind: "message", text });
+  }
+  for (const part of openClawContentParts(message.content)) {
+    if (part.type !== "toolCall" || typeof part.id !== "string") continue;
+    const toolCall = {
+      id: part.id,
+      name: String(part.name ?? "tool"),
+      arguments: part.arguments,
+      messageId: typeof event.id === "string" ? event.id : void 0
+    };
+    toolCalls.set(toolCall.id, { ...toolCalls.get(toolCall.id), ...toolCall });
+    update({ kind: "tool_call", toolCall: toolCalls.get(toolCall.id) });
+  }
+}
+function ingestOpenClawToolResult(event, toolCalls, update) {
+  const message = event.message;
+  if (typeof message.toolCallId !== "string") return;
+  const existing = toolCalls.get(message.toolCallId) ?? {
+    id: message.toolCallId,
+    name: String(message.toolName ?? "tool")
+  };
+  const next = {
+    ...existing,
+    name: String(message.toolName ?? existing.name),
+    output: openClawContentText(message.content),
+    isError: Boolean(message.isError ?? existing.isError)
+  };
+  toolCalls.set(message.toolCallId, next);
+  update({ kind: "tool_call", toolCall: next });
+}
+function openClawContentParts(content) {
+  if (Array.isArray(content)) return content.filter((part) => part && typeof part === "object");
+  if (content && typeof content === "object") return [content];
+  return [];
+}
+function openClawContentText(content) {
+  if (typeof content === "string") return content;
+  return openClawContentParts(content).map((part) => {
+    if (part.type === "text" && typeof part.text === "string") return part.text;
+    return "";
+  }).join("");
+}
+async function runHermesAgent(job, update) {
+  const env = { ...process.env, ...job.agent.env ?? {} };
+  const args = [...job.agent.args];
+  if (!args.includes("chat")) {
+    args.unshift("chat");
+  }
+  let usedPromptPlaceholder = false;
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].includes("{prompt}")) continue;
+    args[i] = args[i].replaceAll("{prompt}", job.query);
+    usedPromptPlaceholder = true;
+  }
+  if (!usedPromptPlaceholder && !hasAnyFlag(args, ["-q", "--query"])) {
+    args.push("-q", job.query);
+  }
+  if (!hasAnyFlag(args, ["-Q", "--quiet"])) {
+    args.push("-Q");
+  }
+  const resume = job.resumeSessionId ?? job.agent.env?.HERMES_SESSION_ID ?? null;
+  if (resume && !hasAnyFlag(args, ["-r", "--resume"])) {
+    args.push("--resume", resume);
+  }
+  const sessionDir = resolveHermesSessionDir(env);
+  const state = {
+    startedAtMs: Date.now(),
+    sessionDir,
+    resumeSessionId: resume,
+    initialMessageCounts: snapshotHermesMessageCounts(sessionDir),
+    selectedFile: null,
+    processedMessages: 0
+  };
+  const result = {
+    kind: "hermes",
+    text: "",
+    messages: [],
+    toolCalls: [],
+    sessionId: resume,
+    sessionFile: null,
+    rawMessages: []
+  };
+  const toolCalls = /* @__PURE__ */ new Map();
+  let stderr = "";
+  let stdoutText = "";
+  let stopPolling = false;
+  const child = spawn5(job.agent.command, args, {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdout = createInterface3({ input: child.stdout });
+  stdout.on("line", (line) => {
+    stdoutText += `${line}
+`;
+    const sessionId = parseHermesSessionId(line);
+    if (sessionId) result.sessionId = sessionId;
+  });
+  const stderrReader = createInterface3({ input: child.stderr });
+  stderrReader.on("line", (line) => {
+    if (!line.trim()) return;
+    stderr += `${line}
+`;
+  });
+  const pollIntervalMs = envNumber(env, "BOTAPP_HERMES_POLL_INTERVAL_MS", 500);
+  const stableAfterExitMs = envNumber(env, "BOTAPP_HERMES_STABLE_AFTER_EXIT_MS", 1e3);
+  const timeoutMs = resolveHermesTimeoutMs(env);
+  const tailTask = (async () => {
+    while (!stopPolling) {
+      readHermesSessionUpdates(state, result, toolCalls, update);
+      await sleep(pollIntervalMs);
+    }
+    readHermesSessionUpdates(state, result, toolCalls, update, true);
+  })();
+  let code;
+  try {
+    code = await waitForChild(child, timeoutMs, "Hermes");
+    await sleep(stableAfterExitMs);
+  } finally {
+    stopPolling = true;
+    await tailTask;
+  }
+  const sessionIdFromStdout = parseHermesSessionId(stdoutText);
+  if (sessionIdFromStdout) {
+    result.sessionId = sessionIdFromStdout;
+  }
+  if (!state.selectedFile && result.sessionId) {
+    state.selectedFile = hermesSessionFile(sessionDir, result.sessionId);
+    readHermesSessionUpdates(state, result, toolCalls, update, true);
+  }
+  result.sessionFile = state.selectedFile;
+  result.toolCalls = [...toolCalls.values()];
+  result.text = result.text || result.messages.at(-1)?.trim() || "";
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `Hermes exited with code ${code}`);
+  }
+  if (!result.sessionId) {
+    throw new Error("Hermes completed, but no session_id line was found on stdout.");
+  }
+  if (!result.text && result.toolCalls.length === 0) {
+    throw new Error(
+      [
+        "Hermes completed, but no assistant message was found in the session file.",
+        `Session directory: ${sessionDir}`,
+        result.sessionFile ? `Selected session file: ${result.sessionFile}` : "Selected session file: none"
+      ].join("\n")
+    );
+  }
+  return JSON.stringify(result);
+}
+function resolveHermesSessionDir(env) {
+  const configured = env.BOTAPP_HERMES_SESSION_DIR ?? env.HERMES_SESSION_DIR;
+  if (configured) return expandPath(configured);
+  return join7(homedir7(), ".hermes", "sessions");
+}
+function hermesSessionFile(sessionDir, sessionId) {
+  return join7(sessionDir, `session_${sessionId}.json`);
+}
+function parseHermesSessionId(text) {
+  const match = text.match(/session_id:\s*([A-Za-z0-9_-]+)/);
+  return match?.[1] ?? null;
+}
+function snapshotHermesMessageCounts(sessionDir) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of listHermesSessionFiles(sessionDir)) {
+    counts.set(file, readHermesMessageCount(file));
+  }
+  return counts;
+}
+function readHermesMessageCount(file) {
+  try {
+    const parsed = JSON.parse(readFileSync8(file, "utf-8"));
+    return Array.isArray(parsed?.messages) ? parsed.messages.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function readHermesSessionUpdates(state, result, toolCalls, update, final = false) {
+  const selectedFile = state.selectedFile ?? selectHermesSessionFile(state);
+  if (!selectedFile) return;
+  if (!state.selectedFile) {
+    state.selectedFile = selectedFile;
+    state.processedMessages = state.resumeSessionId ? state.initialMessageCounts.get(selectedFile) ?? 0 : 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(selectedFile, "utf-8"));
+  } catch {
+    return;
+  }
+  if (typeof parsed?.session_id === "string") {
+    result.sessionId = parsed.session_id;
+  }
+  if (!Array.isArray(parsed?.messages)) return;
+  if (parsed.messages.length <= state.processedMessages && !final) return;
+  const nextMessages = parsed.messages.slice(state.processedMessages);
+  state.processedMessages = parsed.messages.length;
+  for (const message of nextMessages) {
+    ingestHermesMessage(message, result, toolCalls, update);
+  }
+}
+function selectHermesSessionFile(state) {
+  if (state.resumeSessionId) {
+    const exact = hermesSessionFile(state.sessionDir, state.resumeSessionId);
+    if (existsSync10(exact)) return exact;
+  }
+  const files = listHermesSessionFiles(state.sessionDir);
+  if (files.length === 0) return null;
+  const recent = files.filter((file) => {
+    try {
+      return statSync(file).mtimeMs >= state.startedAtMs - 1e3;
+    } catch {
+      return false;
+    }
+  });
+  return newestFile(recent);
+}
+function listHermesSessionFiles(sessionDir) {
+  try {
+    if (!existsSync10(sessionDir)) return [];
+    return readdirSync(sessionDir).filter((name) => /^session_.+\.json$/.test(name)).map((name) => join7(sessionDir, name)).filter((file) => {
+      try {
+        return statSync(file).isFile();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function ingestHermesMessage(message, result, toolCalls, update) {
+  if (!message || typeof message !== "object") return;
+  result.rawMessages.push(message);
+  if (message.role === "assistant") {
+    if (typeof message.content === "string" && message.content.trim()) {
+      result.messages.push(message.content);
+      result.text = message.content;
+      update({ kind: "message", text: message.content });
+    }
+    if (Array.isArray(message.tool_calls)) {
+      for (const call of message.tool_calls) {
+        const id = String(call?.id ?? call?.call_id ?? call?.response_item_id ?? randomUUID());
+        const name = String(call?.function?.name ?? call?.name ?? "tool");
+        const next = {
+          ...toolCalls.get(id),
+          id,
+          name,
+          arguments: parseMaybeJson(call?.function?.arguments ?? call?.arguments)
+        };
+        toolCalls.set(id, next);
+        update({ kind: "tool_call", toolCall: next });
+      }
+    }
+  }
+  if (message.role === "tool" && typeof message.tool_call_id === "string") {
+    const existing = toolCalls.get(message.tool_call_id) ?? {
+      id: message.tool_call_id,
+      name: "tool"
+    };
+    const parsedOutput = parseMaybeJson(message.content);
+    const next = {
+      ...existing,
+      output: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+      isError: Boolean(parsedOutput?.status === "error" || parsedOutput?.is_error)
+    };
+    toolCalls.set(message.tool_call_id, next);
+    update({ kind: "tool_call", toolCall: next });
+  }
+}
+async function runAcpAgent(job) {
+  const child = spawn5(job.agent.command, job.agent.args, {
+    cwd: job.agent.cwd ?? process.cwd(),
+    env: { ...process.env, ...job.agent.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const chunks = [];
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const rl = createInterface3({ input: child.stdout });
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      stderr += `
+Invalid ACP stdout: ${line}`;
+      return;
+    }
+    if (msg.id != null && (msg.result !== void 0 || msg.error)) {
+      const waiting = pending.get(Number(msg.id));
+      if (!waiting) return;
+      pending.delete(Number(msg.id));
+      if (msg.error) waiting.reject(new Error(msg.error.message));
+      else waiting.resolve(msg.result);
+      return;
+    }
+    if (msg.id != null && msg.method) {
+      child.stdin.write(JSON.stringify({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: { code: -32601, message: `Unsupported ACP client method: ${msg.method}` }
+      }) + "\n");
+      return;
+    }
+    if (msg.method === "session/update") {
+      const update = msg.params?.update;
+      if (update?.sessionUpdate === "agent_message_chunk") {
+        const text = update.content?.text;
+        if (text) chunks.push(String(text));
+      }
+      if (update?.sessionUpdate === "tool_call_update" && Array.isArray(update.content)) {
+        for (const item of update.content) {
+          const text = item?.content?.text;
+          if (text) chunks.push(String(text));
+        }
+      }
+    }
+  });
+  function request2(method, params) {
+    const id = nextId++;
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    return new Promise((resolve7, reject) => {
+      pending.set(id, { resolve: resolve7, reject });
+    });
+  }
+  child.on("exit", (code) => {
+    if (code === 0) return;
+    for (const [, waiting] of pending) {
+      waiting.reject(new Error(stderr.trim() || `ACP agent exited with code ${code}`));
+    }
+    pending.clear();
+  });
+  const timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    for (const [, waiting] of pending) {
+      waiting.reject(new Error("ACP agent timed out"));
+    }
+    pending.clear();
+  }, 10 * 60 * 1e3);
+  try {
+    await request2("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+      clientInfo: {
+        name: "botapp-daemon",
+        title: "botapp daemon",
+        version: "0.1.0"
+      }
+    });
+    const session = await request2("session/new", {
+      cwd: job.agent.cwd ?? process.cwd()
+    });
+    const sessionId = session?.sessionId ?? session?.id;
+    if (!sessionId) throw new Error("ACP agent did not return a sessionId");
+    await request2("session/prompt", {
+      sessionId,
+      prompt: [{ type: "text", text: job.query }]
+    });
+    return chunks.join("").trim();
+  } finally {
+    clearTimeout(timeout);
+    child.kill("SIGTERM");
+  }
+}
+function requireProfile() {
+  const profile = loadDaemonProfile();
+  if (!profile) {
+    console.error(pc19.red("No paired daemon found. Run `bot pair` first."));
+    process.exitCode = 1;
+    return null;
+  }
+  return profile;
+}
+async function daemonRequest(server, token, path, opts) {
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  if (opts?.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  const res = await fetch(`${server}${path}`, {
+    method: opts?.method ?? "GET",
+    headers,
+    body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(data.error ?? data.message ?? res.statusText);
+  }
+  return data;
+}
+function parseEnv(entries) {
+  if (entries.length === 0) return null;
+  return Object.fromEntries(entries.map((entry) => {
+    const idx = entry.indexOf("=");
+    if (idx < 0) return [entry, ""];
+    return [entry.slice(0, idx), entry.slice(idx + 1)];
+  }));
+}
+function getFlagValue(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === flag) return args[i + 1] ?? null;
+    if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1) || null;
+  }
+  return null;
+}
+function hasFlag(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function hasAnyFlag(args, flags) {
+  return flags.some((flag) => hasFlag(args, flag));
+}
+function expandPath(path) {
+  if (path === "~") return homedir7();
+  if (path.startsWith("~/")) return join7(homedir7(), path.slice(2));
+  return resolve6(path);
+}
+function envNumber(env, name, fallback) {
+  const value = env[name];
+  if (!value) return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveOpenClawTimeoutMs(env) {
+  const explicitMs = envNumber(env, "BOTAPP_OPENCLAW_TIMEOUT_MS", 0);
+  if (explicitMs > 0) return explicitMs;
+  const explicitSeconds = envNumber(env, "BOTAPP_OPENCLAW_TIMEOUT_SECONDS", 0);
+  if (explicitSeconds > 0) return explicitSeconds * 1e3;
+  return 15 * 60 * 1e3;
+}
+function resolveHermesTimeoutMs(env) {
+  const explicitMs = envNumber(env, "BOTAPP_HERMES_TIMEOUT_MS", 0);
+  if (explicitMs > 0) return explicitMs;
+  const explicitSeconds = envNumber(env, "BOTAPP_HERMES_TIMEOUT_SECONDS", 0);
+  if (explicitSeconds > 0) return explicitSeconds * 1e3;
+  return 15 * 60 * 1e3;
+}
+function parseMaybeJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+async function waitForChild(child, timeoutMs, label) {
+  return new Promise((resolveWait, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+      }, 5e3).unref();
+      reject(new Error(`${label} timed out after ${Math.round(timeoutMs / 1e3)}s`));
+    }, timeoutMs);
+    timeout.unref();
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      resolveWait(code);
+    });
+  });
+}
+
+// src/index.ts
+var version = "0.1.0";
+var program = new Command19().name("bot").description("botapp CLI \u2014 operate apps from the command line").version(version).enablePositionalOptions(true).option("--json", "Output as JSON").option("-s, --server <url>", "Server URL override").option("-t, --token <token>", "Auth token override").option("-v, --verbose", "Verbose output");
+program.addCommand(launchCommand);
+program.addCommand(runCommand);
+program.addCommand(appsCommand);
+program.addCommand(skillCommand);
+program.addCommand(connectCommand);
+program.addCommand(eventsCommand);
+program.addCommand(loginCommand);
+program.addCommand(agentCommand);
+program.addCommand(pairingCommand);
+program.addCommand(daemonCommand);
+program.addCommand(installCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(reloadCommand);
+program.addCommand(configCommand);
+program.addCommand(serverCommand);
+program.addCommand(devCommand, { hidden: true });
+program.addCommand(registerCommand, { hidden: true });
+program.addCommand(wrapCommand, { hidden: true });
+program.addHelpText(
+  "after",
+  `
+Examples:
+  $ bot start                     Connect to a server and log in
+  $ bot run trading quote --symbol NVDA
+                                  Run an app command
+  $ bot apps                      List installed apps
+  $ bot skill trading             Print the app's agent-facing skill doc
+  $ bot connect --subscribe 'trading.*'
+                                  Live event stream
+  $ bot pair                      Pair this machine (browser flow / local fast-path)
+  $ bot pair --token <jwt>        Pair with a token pasted from dashboard Settings
+  $ bot daemon run                Run the paired local daemon
+`
+);
+runCommand.addHelpText(
+  "after",
+  `
+Examples:
+  $ bot run hello greet --name alice
+  $ bot run trading quote --symbol NVDA
+  $ bot run trading buy --symbol AAPL --qty 10
+  $ bot --json run trading list-positions
+
+Arguments after <command> become the command's params object:
+  --key value       \u2192 params.key = value
+  --key             \u2192 params.key = true  (flag-only)
+  Numeric strings are auto-coerced: "--qty 10" \u2192 10
+
+To discover what params a command accepts:
+  $ bot apps --json | jq '.[] | select(.name == "trading") | .commands'
+`
+);
+program.on("command:*", (operands) => {
+  const first = operands[0];
+  const known = program.commands.filter((c) => !c._hidden).map((c) => c.name());
+  const topLevelHint = `Run ${pc20.cyan("bot --help")} for the list of top-level commands.`;
+  const argv = process.argv.slice(2);
+  const firstIdx = argv.indexOf(first);
+  const tail = firstIdx >= 0 ? argv.slice(firstIdx + 1) : [];
+  if (tail.length > 0) {
+    const suggested = `bot run ${first} ${tail.join(" ")}`;
+    console.error(
+      pc20.red(`error: unknown command '${first}'`) + `
+
+App commands go through ${pc20.bold("bot run")}. Did you mean:
+
+  ${pc20.cyan(suggested)}
+
+${topLevelHint}`
+    );
+    process.exit(1);
+  }
+  console.error(
+    pc20.red(`error: unknown command '${first}'`) + `
+
+If '${first}' is an app name, invoke one of its commands with:
+  ${pc20.cyan(`bot run ${first} <command> [--key value ...]`)}
+  ${pc20.cyan("bot apps --json")}   ${pc20.dim("(to see what commands exist)")}
+
+Top-level commands: ${known.join(", ")}
+${topLevelHint}`
+  );
+  process.exit(1);
+});
+export {
+  program
+};
+//# sourceMappingURL=index.js.map