claude-b 0.3.2

package/dist/cli/index.js

@@ -0,0 +1,1643 @@
+#!/usr/bin/env node
+import {
+  TelegramConfigManager,
+  detectClaude,
+  envTemplate,
+  getDataDir,
+  loadEnv
+} from "../chunk-6D3ICY25.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/daemon/client.ts
+import { createConnection } from "net";
+import { homedir } from "os";
+import { EventEmitter } from "events";
+var DaemonClient = class extends EventEmitter {
+  socket = null;
+  socketPath;
+  messageId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  constructor(socketPath) {
+    super();
+    this.socketPath = socketPath || `${homedir()}/.claude-b/daemon.sock`;
+  }
+  async connect() {
+    if (this.socket?.writable) {
+      return this.socket;
+    }
+    return new Promise((resolve, reject) => {
+      const socket = createConnection(this.socketPath);
+      socket.on("connect", () => {
+        this.socket = socket;
+        resolve(socket);
+      });
+      socket.on("data", (data) => {
+        this.handleData(data.toString());
+      });
+      socket.on("error", (error) => {
+        this.socket = null;
+        reject(error);
+      });
+      socket.on("close", () => {
+        this.socket = null;
+        this.emit("close");
+      });
+    });
+  }
+  handleData(data) {
+    this.buffer += data;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        if (message.type === "output") {
+          this.emit("output", message.data);
+          continue;
+        }
+        if (message.type === "status") {
+          this.emit("status", message.data);
+          continue;
+        }
+        if (message.id !== void 0) {
+          const pending = this.pendingRequests.get(message.id);
+          if (pending) {
+            this.pendingRequests.delete(message.id);
+            pending.resolve(message);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  async send(message) {
+    const socket = await this.connect();
+    const id = ++this.messageId;
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      const payload = JSON.stringify({ ...message, id }) + "\n";
+      socket.write(payload, (error) => {
+        if (error) {
+          this.pendingRequests.delete(id);
+          reject(error);
+        }
+      });
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error("Request timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  async attach(sessionId) {
+    const socket = await this.connect();
+    await this.send({ method: "session.attach", params: { sessionId } });
+    process.stdout.on("resize", () => {
+      this.send({ method: "terminal.resize", params: {
+        cols: process.stdout.columns,
+        rows: process.stdout.rows
+      } }).catch(() => {
+      });
+    });
+    this.on("output", (data) => {
+      process.stdout.write(data.content);
+    });
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      if (data.toString() === "") {
+        this.send({ method: "session.detach" }).finally(() => {
+          process.stdin.setRawMode?.(false);
+          process.exit(0);
+        });
+        return;
+      }
+      socket.write(JSON.stringify({ method: "stdin", params: { data: data.toString() } }) + "\n");
+    });
+    await new Promise((resolve) => {
+      this.on("close", resolve);
+    });
+  }
+  async watch() {
+    await this.connect();
+    await this.send({ method: "session.watch" });
+    this.on("output", (data) => {
+      process.stdout.write(data.content);
+    });
+    this.on("status", (data) => {
+      if (data.status === "processing") {
+        process.stdout.write(`\x1B[33m[Processing prompt ${data.promptId || ""}...]\x1B[0m
+`);
+      } else if (data.status === "completed") {
+        process.stdout.write(`\x1B[32m[Completed]\x1B[0m
+`);
+      } else if (data.status === "error") {
+        process.stdout.write(`\x1B[31m[Error]\x1B[0m
+`);
+      }
+    });
+    process.on("SIGINT", () => {
+      this.send({ method: "session.unwatch" }).finally(() => {
+        process.exit(0);
+      });
+    });
+    await new Promise((resolve) => {
+      this.on("close", resolve);
+    });
+  }
+  close() {
+    this.socket?.end();
+    this.socket = null;
+  }
+};
+
+// src/utils/version.ts
+var version = "0.1.0";
+
+// src/cli/init.ts
+import { createInterface } from "readline";
+import { writeFile, mkdir, readFile, chmod } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+function createPrompts() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  function ask(question, opts = {}) {
+    const suffix = opts.default ? chalk.gray(` [${opts.default}]`) : "";
+    return new Promise((resolve) => {
+      rl.question(`${question}${suffix} `, (answer) => {
+        resolve(answer.trim() || opts.default || "");
+      });
+    });
+  }
+  async function confirm(question, defaultYes) {
+    const hint = defaultYes ? "Y/n" : "y/N";
+    const answer = (await ask(`${question} ${chalk.gray(`(${hint})`)}`)).toLowerCase();
+    if (!answer) return defaultYes;
+    return answer.startsWith("y");
+  }
+  return { ask, confirm, close: () => rl.close() };
+}
+async function pingTelegramBot(token) {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+    const json = await res.json();
+    if (!json.ok) return { ok: false, error: json.description || "Invalid token" };
+    return { ok: true, username: json.result?.username };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function waitForFirstChat(token, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let offset = 0;
+  try {
+    const drain = await fetch(`https://api.telegram.org/bot${token}/getUpdates?offset=-1`);
+    const drainJson = await drain.json();
+    if (drainJson.ok && drainJson.result && drainJson.result.length > 0) {
+      offset = drainJson.result[drainJson.result.length - 1].update_id + 1;
+    }
+  } catch {
+  }
+  while (Date.now() < deadline) {
+    const remaining = Math.max(1, Math.floor((deadline - Date.now()) / 1e3));
+    const pollSeconds = Math.min(25, remaining);
+    try {
+      const res = await fetch(
+        `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${pollSeconds}`
+      );
+      const json = await res.json();
+      if (!json.ok || !json.result) continue;
+      for (const update of json.result) {
+        offset = update.update_id + 1;
+        const chat = update.message?.chat;
+        if (chat && (chat.type === "private" || chat.type === "group" || chat.type === "supergroup")) {
+          return String(chat.id);
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function sendTelegramMessage(token, chatId, text) {
+  try {
+    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text, parse_mode: "HTML" })
+    });
+  } catch {
+  }
+}
+function printBanner() {
+  console.log("");
+  console.log(chalk.bold.cyan("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
+  console.log(chalk.bold.cyan("  \u2502       Claude-B setup wizard      \u2502"));
+  console.log(chalk.bold.cyan("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
+  console.log("");
+  console.log(chalk.gray("  Writes config to ~/.claude-b/.env and optionally"));
+  console.log(chalk.gray("  configures a Telegram bot for remote control."));
+  console.log("");
+}
+function printBotFatherScript() {
+  console.log("");
+  console.log(chalk.bold("  Step 1: create a Telegram bot"));
+  console.log("");
+  console.log(`    1. Open Telegram and message ${chalk.cyan("@BotFather")}`);
+  console.log(`    2. Send ${chalk.yellow("/newbot")}`);
+  console.log(`    3. Pick a name, e.g. ${chalk.gray('"My Claude-B"')}`);
+  console.log(`    4. Pick a username ending in ${chalk.gray('"bot"')}, e.g. ${chalk.gray('"my_claude_b_bot"')}`);
+  console.log(`    5. BotFather replies with a token \u2014 copy it (looks like ${chalk.gray("123456:ABC...")})`);
+  console.log("");
+}
+function mergeEnvFile(existing, updates) {
+  const lines = existing.split(/\r?\n/);
+  const seen = /* @__PURE__ */ new Set();
+  const out = lines.map((line) => {
+    const match = line.match(/^\s*#?\s*([A-Z_][A-Z0-9_]*)\s*=/);
+    if (!match) return line;
+    const key = match[1];
+    if (!(key in updates)) return line;
+    seen.add(key);
+    return `${key}=${updates[key]}`;
+  });
+  const missing = Object.entries(updates).filter(([k]) => !seen.has(k));
+  if (missing.length > 0) {
+    if (out.length && out[out.length - 1] !== "") out.push("");
+    out.push("# Added by `cb init`");
+    for (const [k, v] of missing) out.push(`${k}=${v}`);
+    out.push("");
+  }
+  return out.join("\n");
+}
+async function runInit() {
+  printBanner();
+  const dataDir = getDataDir();
+  await mkdir(dataDir, { recursive: true });
+  const envPath = join(dataDir, ".env");
+  const firstRun = !existsSync(envPath);
+  if (!firstRun) {
+    console.log(chalk.yellow(`  ~/.claude-b/.env already exists \u2014 updating in place.`));
+    console.log("");
+  }
+  const prompts = createPrompts();
+  const collected = {};
+  try {
+    const existingAnthropic = process.env.ANTHROPIC_API_KEY;
+    if (existingAnthropic) {
+      console.log(chalk.green(`  \u2713 ANTHROPIC_API_KEY already set (${existingAnthropic.slice(0, 8)}\u2026)`));
+    } else {
+      console.log(chalk.bold("  Anthropic API key"));
+      console.log(chalk.gray("    Get one at https://console.anthropic.com/settings/keys"));
+      const key = await prompts.ask("    Paste ANTHROPIC_API_KEY (or empty to skip):");
+      if (key) collected.ANTHROPIC_API_KEY = key;
+      console.log("");
+    }
+    const wantTelegram = await prompts.confirm("  Set up Telegram bot for remote control?", true);
+    console.log("");
+    let telegramToken;
+    let telegramChatId;
+    if (wantTelegram) {
+      printBotFatherScript();
+      while (true) {
+        const token = await prompts.ask("    Paste bot token:");
+        if (!token) {
+          console.log(chalk.yellow("    Skipped."));
+          break;
+        }
+        console.log(chalk.gray("    Verifying token..."));
+        const ping = await pingTelegramBot(token);
+        if (!ping.ok) {
+          console.log(chalk.red(`    \u2717 ${ping.error}`));
+          const retry = await prompts.confirm("    Try another token?", true);
+          if (!retry) break;
+          continue;
+        }
+        console.log(chalk.green(`    \u2713 Connected as @${ping.username}`));
+        telegramToken = token;
+        console.log("");
+        console.log(chalk.bold("  Step 2: register your chat"));
+        console.log(chalk.gray(`    Open @${ping.username} in Telegram and send ${chalk.yellow("/start")}.`));
+        console.log(chalk.gray("    Waiting up to 3 minutes for your first message..."));
+        console.log("");
+        const chatId = await waitForFirstChat(token, 3 * 60 * 1e3);
+        if (!chatId) {
+          console.log(chalk.yellow("    Timed out waiting for /start."));
+          console.log(chalk.gray("    You can run `cb --telegram <token>` later to retry."));
+          break;
+        }
+        telegramChatId = chatId;
+        console.log(chalk.green(`    \u2713 Registered chat id ${chatId}`));
+        await sendTelegramMessage(
+          token,
+          chatId,
+          "<b>Claude-B</b> is connected \u{1F389}\nRun <code>cb --telegram-status</code> locally to confirm."
+        );
+        break;
+      }
+      console.log("");
+    }
+    if (wantTelegram) {
+      const wantVoice = await prompts.confirm(
+        "  Enable voice notes (Whisper STT + TTS playback)?",
+        false
+      );
+      console.log("");
+      if (wantVoice) {
+        const existingOpenAI = process.env.OPENAI_API_KEY;
+        if (existingOpenAI) {
+          console.log(chalk.green(`  \u2713 OPENAI_API_KEY already set`));
+        } else {
+          const key = await prompts.ask("    Paste OPENAI_API_KEY (or empty to skip):");
+          if (key) collected.OPENAI_API_KEY = key;
+        }
+        console.log("");
+      }
+    }
+    if (telegramToken) {
+      const tgConfig = new TelegramConfigManager(dataDir);
+      await tgConfig.load();
+      await tgConfig.setToken(telegramToken);
+      if (telegramChatId) await tgConfig.addChatId(telegramChatId);
+      if (collected.OPENAI_API_KEY || process.env.OPENAI_API_KEY) {
+        const openaiKey = collected.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+        await tgConfig.setSTTProvider({ provider: "openai", apiKey: openaiKey });
+        await tgConfig.setAIProvider({ provider: "anthropic", apiKey: collected.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY || "" });
+      }
+      collected.TELEGRAM_BOT_TOKEN = telegramToken;
+      if (telegramChatId) collected.TELEGRAM_ALLOWED_CHAT_IDS = telegramChatId;
+    }
+    let existingEnv = "";
+    if (existsSync(envPath)) {
+      existingEnv = await readFile(envPath, "utf-8");
+    } else {
+      existingEnv = envTemplate();
+    }
+    const merged = mergeEnvFile(existingEnv, collected);
+    await writeFile(envPath, merged);
+    await chmod(envPath, 384);
+    console.log(chalk.bold.green(`  \u2713 Wrote ${envPath}`));
+    console.log("");
+    console.log(chalk.bold("  Next steps"));
+    console.log(`    \u2022 Start the daemon:  ${chalk.yellow("cb")} ${chalk.gray('"hello"')}   ${chalk.gray("(auto-starts on first use)")}`);
+    if (telegramToken) {
+      console.log(`    \u2022 Telegram bot:      ${chalk.yellow("cb --telegram-status")}`);
+    }
+    console.log(`    \u2022 REST API:          ${chalk.yellow("cb -r")}`);
+    console.log("");
+  } finally {
+    prompts.close();
+  }
+}
+
+// src/cli/index.ts
+loadEnv();
+var program = new Command();
+program.name("cb").description("Claude-B: Background Claude Code with async workflows").version(version);
+program.command("init").description("Interactive setup: writes ~/.claude-b/.env, connects Telegram bot").action(async () => {
+  try {
+    await runInit();
+    process.exit(0);
+  } catch (err) {
+    console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+program.argument("[prompt...]", "Prompt to send to Claude").option("-l, --last", "Show status and output of last prompt").option("-s, --sess", "List all sessions").option("-a, --attach <id>", "Attach to session (foreground mode)").option("-d, --detach", "Detach from current session").option("-n, --new [name]", "Create new session").option("-m, --model <model>", "Claude model to use").option("-k, --kill <id>", "Kill/terminate session").option("-w, --watch", "Watch live output (tail -f style)").option("-x, --select <id>", "Select session for subsequent commands").option("-c, --current", "Show current selected session").option("-r, --rest [port]", "Start REST API server").option("--rest-stop", "Stop REST API server").option("--status", "Daemon status and health").option("--logs", "View daemon logs").option("--hook <event> <cmd>", "Register shell hook for event").option("--hook-session <id>", "Only trigger hook for this session (use with --hook)").option("--unhook <id>", "Remove a shell hook").option("--hooks", "List all shell hooks").option("--webhook <url>", "Register webhook for notifications").option("--webhook-event <event>", "Event type for webhook (default: *)").option("--webhook-session <id>", "Only trigger webhook for this session (use with --webhook)").option("--unwebhook <id>", "Remove a webhook").option("--webhooks", "List all webhooks").option("--hook-stats", "Show hook statistics").option("--api-key", "Generate/show API key for REST access").option("--config", "Edit configuration").option("--export <id>", "Export session transcript").option("--import <file>", "Import session from file").option("--remote-add <url>", "Add a remote Claude-B host").option("--remote-key <apiKey>", "API key for remote host (use with --remote-add)").option("--remote-name <name>", "Name for remote host (use with --remote-add)").option("--remote-priority <n>", "Priority for remote host (use with --remote-add)").option("--remote-remove <id>", "Remove a remote host").option("--remote-toggle <id>", "Toggle remote host enabled/disabled").option("--remote-hosts", "List all remote hosts").option("--remote-health", "Show health status of remote hosts").option("--remote-stats", "Show orchestration statistics").option("--remote <hostId>", "Send prompt to specific remote host").option("-f, --fire", "Fire and forget (launch task in background, no watching)").option("-g, --goal <description>", "Goal/objective for fire-and-forget task (use with -f)").option("-i, --inbox", "Show notification inbox (completed tasks)").option("--inbox-clear", "Mark all notifications as read").option("--inbox-count", "Show unread notification count").option("--remote-fire <hostId>", "Fire and forget to remote host").option("--telegram <token>", "Set up Telegram bot with token").option("--telegram-stop", "Disable Telegram notifications").option("--telegram-status", "Show Telegram bot status").option("--telegram-forward <on|off>", "Toggle forwarding all session completions to Telegram").option("--voice-setup <provider>", "Configure STT provider: speechmatics, deepgram, or openai").option("--ai-provider <config>", 'Set AI provider: "anthropic <key>" or "openrouter <key>"').option("--voice-status", "Show voice pipeline status").option("--shell-init", "Output shell hook for inbox notifications (add to .bashrc/.zshrc)").action(async (promptParts, options) => {
+  if (options.shellInit) {
+    printShellInit();
+    return;
+  }
+  const client = new DaemonClient();
+  try {
+    if (options.last) {
+      await showLastOutput(client);
+      return;
+    }
+    if (options.sess) {
+      await listSessions(client);
+      return;
+    }
+    if (options.attach) {
+      await attachSession(client, options.attach);
+      return;
+    }
+    if (options.detach) {
+      await detachSession(client);
+      return;
+    }
+    if (options.new !== void 0) {
+      const name = typeof options.new === "string" ? options.new : void 0;
+      await createSession(client, name, options.model);
+      return;
+    }
+    if (options.kill) {
+      await killSession(client, options.kill);
+      return;
+    }
+    if (options.watch) {
+      await watchSession(client);
+      return;
+    }
+    if (options.select) {
+      await selectSession(client, options.select);
+      return;
+    }
+    if (options.current) {
+      await showCurrentSession(client);
+      return;
+    }
+    if (options.rest !== void 0) {
+      const port = typeof options.rest === "string" ? parseInt(options.rest, 10) : 3847;
+      await startRestServer(client, port);
+      return;
+    }
+    if (options.restStop) {
+      await stopRestServer(client);
+      return;
+    }
+    if (options.apiKey) {
+      await showApiKey(client);
+      return;
+    }
+    if (options.status) {
+      await showStatus(client);
+      return;
+    }
+    if (options.logs) {
+      await showLogs();
+      return;
+    }
+    if (options.hook) {
+      const args = promptParts;
+      if (args.length < 1) {
+        console.error(chalk2.red("Usage: cb --hook <event> <command>"));
+        console.error(chalk2.gray("Events: session.created, session.destroyed, prompt.received, prompt.completed, prompt.error, daemon.started, daemon.stopped, rest.started, rest.stopped, * (all)"));
+        console.error(chalk2.gray("Use --hook-session <id> to filter by session"));
+        return;
+      }
+      const event = options.hook;
+      const command = args.join(" ");
+      await addShellHook(client, event, command, options.hookSession);
+      return;
+    }
+    if (options.unhook) {
+      await removeShellHook(client, options.unhook);
+      return;
+    }
+    if (options.hooks) {
+      await listShellHooks(client);
+      return;
+    }
+    if (options.webhook) {
+      const event = options.webhookEvent || "*";
+      await addWebhook(client, event, options.webhook, options.webhookSession);
+      return;
+    }
+    if (options.unwebhook) {
+      await removeWebhook(client, options.unwebhook);
+      return;
+    }
+    if (options.webhooks) {
+      await listWebhooks(client);
+      return;
+    }
+    if (options.hookStats) {
+      await showHookStats(client);
+      return;
+    }
+    if (options.remoteAdd) {
+      if (!options.remoteKey) {
+        console.error(chalk2.red("API key required. Use --remote-key <apiKey>"));
+        return;
+      }
+      await addRemoteHost(client, options.remoteAdd, options.remoteKey, {
+        name: options.remoteName,
+        priority: options.remotePriority ? parseInt(options.remotePriority, 10) : void 0
+      });
+      return;
+    }
+    if (options.remoteRemove) {
+      await removeRemoteHost(client, options.remoteRemove);
+      return;
+    }
+    if (options.remoteToggle) {
+      await toggleRemoteHost(client, options.remoteToggle);
+      return;
+    }
+    if (options.remoteHosts) {
+      await listRemoteHosts(client);
+      return;
+    }
+    if (options.remoteHealth) {
+      await showRemoteHealth(client);
+      return;
+    }
+    if (options.remoteStats) {
+      await showOrchestrationStats(client);
+      return;
+    }
+    if (options.remote) {
+      if (promptParts.length === 0) {
+        console.error(chalk2.red("Prompt required for remote execution"));
+        return;
+      }
+      const prompt = promptParts.join(" ");
+      await sendRemotePrompt(client, options.remote, prompt);
+      return;
+    }
+    if (options.inbox) {
+      await showInbox(client);
+      return;
+    }
+    if (options.inboxClear) {
+      await clearInbox(client);
+      return;
+    }
+    if (options.inboxCount) {
+      await showInboxCount(client);
+      return;
+    }
+    if (options.telegram) {
+      await setupTelegram(client, options.telegram);
+      return;
+    }
+    if (options.telegramStop) {
+      await stopTelegram(client);
+      return;
+    }
+    if (options.telegramStatus) {
+      await showTelegramStatus(client);
+      return;
+    }
+    if (options.telegramForward) {
+      const enabled = options.telegramForward === "on";
+      await setTelegramForward(client, enabled);
+      return;
+    }
+    if (options.voiceSetup) {
+      const apiKey = promptParts[0];
+      if (!apiKey) {
+        console.error(chalk2.red("Usage: cb --voice-setup <speechmatics|deepgram|openai> <api-key>"));
+        process.exit(1);
+      }
+      await setupVoicePipeline(client, options.voiceSetup, apiKey);
+      return;
+    }
+    if (options.aiProvider) {
+      const provider = options.aiProvider;
+      const apiKey = promptParts[0];
+      const model = promptParts[1];
+      if (!apiKey) {
+        console.error(chalk2.red("Usage: cb --ai-provider <anthropic|openrouter> <api-key> [model]"));
+        process.exit(1);
+      }
+      await setupVoiceAI(client, provider, apiKey, model);
+      return;
+    }
+    if (options.voiceStatus) {
+      await showVoiceStatus(client);
+      return;
+    }
+    if (options.remoteFire) {
+      if (promptParts.length === 0) {
+        console.error(chalk2.red("Prompt required for remote fire-and-forget"));
+        return;
+      }
+      const prompt = promptParts.join(" ");
+      await fireRemotePrompt(client, options.remoteFire, prompt, options.goal);
+      return;
+    }
+    if (promptParts.length > 0) {
+      const prompt = promptParts.join(" ");
+      if (options.fire) {
+        await fireAndForgetPrompt(client, prompt, options.goal);
+      } else {
+        await sendPrompt(client, prompt, options.model);
+      }
+      return;
+    }
+    program.help();
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("ENOENT")) {
+        console.error(chalk2.yellow("Daemon not running. Starting daemon..."));
+        await startDaemon();
+        await waitForDaemon();
+        console.log(chalk2.green("Daemon started. Retrying..."));
+        await program.parseAsync(process.argv);
+        return;
+      } else {
+        console.error(chalk2.red(`Error: ${error.message}`));
+      }
+    }
+    process.exit(1);
+  }
+});
+async function showLastOutput(client) {
+  const result = await client.send({ method: "session.last" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  if (!data) {
+    console.log(chalk2.gray("No output available"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold(`Session: ${data.sessionId}`));
+  console.log(chalk2.gray(`Status: ${data.status}`));
+  console.log("");
+  console.log(data.output);
+  process.exit(0);
+}
+async function listSessions(client) {
+  const result = await client.send({ method: "session.list" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const sessions = data?.sessions || [];
+  if (sessions.length === 0) {
+    console.log(chalk2.gray("No active sessions"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold("Sessions:"));
+  for (const session of sessions) {
+    const marker = session.selected ? chalk2.green("*") : " ";
+    const status = session.status === "busy" ? chalk2.yellow("busy") : chalk2.gray("idle");
+    console.log(`${marker} ${chalk2.cyan(session.id)} ${session.name ? chalk2.gray(`(${session.name})`) : ""} [${status}]`);
+  }
+  process.exit(0);
+}
+async function attachSession(client, sessionId) {
+  console.log(chalk2.green(`Attaching to session ${sessionId}...`));
+  console.log(chalk2.gray("Press Ctrl+D to detach"));
+  await client.attach(sessionId);
+}
+async function detachSession(client) {
+  await client.send({ method: "session.detach" });
+  client.close();
+  console.log(chalk2.green("Detached from session"));
+  process.exit(0);
+}
+async function createSession(client, name, model) {
+  const result = await client.send({ method: "session.create", params: { name, model } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Created session: ${data?.sessionId}`));
+  if (name) {
+    console.log(chalk2.gray(`Name: ${name}`));
+  }
+  if (model) {
+    console.log(chalk2.gray(`Model: ${model}`));
+  }
+  process.exit(0);
+}
+async function killSession(client, sessionId) {
+  const result = await client.send({ method: "session.kill", params: { sessionId } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Killed session: ${sessionId}`));
+  process.exit(0);
+}
+async function watchSession(client) {
+  console.log(chalk2.gray("Watching session output (Ctrl+C to stop)..."));
+  await client.watch();
+}
+async function selectSession(client, sessionId) {
+  const result = await client.send({ method: "session.select", params: { sessionId } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Selected session: ${sessionId}`));
+  process.exit(0);
+}
+async function showCurrentSession(client) {
+  const result = await client.send({ method: "session.current" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  if (!data?.sessionId) {
+    console.log(chalk2.gray("No session selected"));
+    process.exit(0);
+  }
+  console.log(chalk2.cyan(data.sessionId));
+  if (data.name) {
+    console.log(chalk2.gray(`Name: ${data.name}`));
+  }
+  console.log(chalk2.gray(`Status: ${data.status}`));
+  process.exit(0);
+}
+async function startRestServer(client, port) {
+  console.log(chalk2.gray(`Starting REST API server on port ${port}...`));
+  const result = await client.send({ method: "rest.start", params: { port } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`REST API server started!`));
+  console.log(`  Address: ${chalk2.cyan(data?.address)}`);
+  console.log(`  API Key: ${chalk2.cyan(data?.apiKey)}`);
+  console.log("");
+  console.log(chalk2.gray("Example usage:"));
+  console.log(chalk2.gray(`  # Get token`));
+  console.log(chalk2.gray(`  curl -X POST http://localhost:${port}/api/auth/token \\`));
+  console.log(chalk2.gray(`    -H "Content-Type: application/json" \\`));
+  console.log(chalk2.gray(`    -d '{"api_key": "${data?.apiKey}"}'`));
+  console.log("");
+  console.log(chalk2.gray(`  # List sessions`));
+  console.log(chalk2.gray(`  curl http://localhost:${port}/api/sessions \\`));
+  console.log(chalk2.gray(`    -H "Authorization: Bearer <token>"`));
+  process.exit(0);
+}
+async function stopRestServer(client) {
+  const statusResult = await client.send({ method: "rest.status" });
+  const statusData = statusResult.data;
+  if (!statusData?.running) {
+    client.close();
+    console.log(chalk2.gray("REST server is not running."));
+    process.exit(0);
+  }
+  const result = await client.send({ method: "rest.stop" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green("REST API server stopped"));
+  process.exit(0);
+}
+async function showApiKey(client) {
+  const statusResult = await client.send({ method: "rest.status" });
+  const statusData = statusResult.data;
+  if (!statusData?.running) {
+    client.close();
+    console.log(chalk2.yellow("REST server is not running."));
+    console.log(chalk2.gray("Start it with: cb -r [port]"));
+    process.exit(0);
+  }
+  const result = await client.send({ method: "rest.apikey" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.bold("API Key:"));
+  console.log(chalk2.cyan(data?.apiKey));
+  process.exit(0);
+}
+async function showStatus(client) {
+  const result = await client.send({ method: "daemon.status" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  if (!data) {
+    console.error(chalk2.red("No status data available"));
+    process.exit(1);
+  }
+  console.log(chalk2.bold("Daemon Status:"));
+  console.log(`  PID: ${chalk2.cyan(data.pid)}`);
+  console.log(`  Uptime: ${chalk2.cyan(data.uptime)}`);
+  console.log(`  Sessions: ${chalk2.cyan(data.sessionCount)}`);
+  console.log(`  Memory: ${chalk2.cyan(data.memoryUsage)}`);
+  const claude = detectClaude();
+  if (claude) {
+    const version2 = claude.version ? ` v${claude.version}` : "";
+    console.log(`  Claude: ${chalk2.green(claude.path)}${chalk2.gray(version2)} (${claude.type})`);
+  } else {
+    console.log(`  Claude: ${chalk2.red("Not found")} - set CLAUDE_PATH or install Claude Code`);
+  }
+  process.exit(0);
+}
+async function showLogs() {
+  const { homedir: homedir2 } = await import("os");
+  const logFile = `${homedir2()}/.claude-b/daemon.log`;
+  console.log(chalk2.gray(`Log file: ${logFile}`));
+  console.log(chalk2.gray("(Log viewing implementation pending)"));
+  process.exit(0);
+}
+async function sendPrompt(client, prompt, model) {
+  console.log(chalk2.gray("Sending prompt..."));
+  const result = await client.send({ method: "prompt.send", params: { prompt, model } });
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    return;
+  }
+  const data = result.data;
+  const sessionInfo = data?.sessionId ? ` on ${chalk2.cyan(data.sessionId)}` : "";
+  console.log(chalk2.green(`Prompt queued (ID: ${data?.promptId})${sessionInfo}`));
+  console.log(chalk2.gray("Watching output (Ctrl+C to detach)...\n"));
+  await client.send({ method: "session.watch" });
+  client.on("status", (statusData) => {
+    if (statusData.status === "processing") {
+      console.log(chalk2.yellow(`[Processing prompt ${statusData.promptId || ""}...]`));
+    } else if (statusData.status === "completed") {
+      console.log(chalk2.green(`
+[Completed]`));
+    } else if (statusData.status === "error") {
+      console.log(chalk2.red(`
+[Error]`));
+    }
+  });
+  let jsonAccumulator = "";
+  client.on("output", (outputData) => {
+    jsonAccumulator += outputData.content;
+    try {
+      const parsed = JSON.parse(jsonAccumulator.trim());
+      if (parsed.result !== void 0) {
+        process.stdout.write(parsed.result);
+        jsonAccumulator = "";
+        return;
+      }
+    } catch {
+    }
+    process.stdout.write(outputData.content);
+  });
+  process.on("SIGINT", () => {
+    console.log(chalk2.gray('\n\nDetaching... (use "cb -l" to check result or "cb -w" to resume watching)'));
+    client.send({ method: "session.unwatch" }).finally(() => {
+      process.exit(0);
+    });
+  });
+  await new Promise((resolve) => {
+    client.on("close", resolve);
+  });
+}
+async function startDaemon() {
+  const { spawn } = await import("child_process");
+  const { homedir: homedir2 } = await import("os");
+  const { mkdir: mkdir2 } = await import("fs/promises");
+  const configDir = `${homedir2()}/.claude-b`;
+  await mkdir2(configDir, { recursive: true });
+  const daemon = spawn("node", ["dist/daemon/index.js"], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: "ignore"
+  });
+  daemon.unref();
+}
+async function waitForDaemon(maxWaitMs = 5e3) {
+  const interval = 200;
+  const maxAttempts = Math.ceil(maxWaitMs / interval);
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const testClient = new DaemonClient();
+      const result = await testClient.send({ method: "status" });
+      testClient.close();
+      if (result.data) return;
+    } catch {
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error("Daemon failed to start within timeout");
+}
+async function addShellHook(client, event, command, sessionFilter) {
+  const result = await client.send({
+    method: "hook.shell.add",
+    params: { event, command, sessionFilter }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Shell hook added: ${data.hook?.id}`));
+  console.log(chalk2.gray(`  Event: ${event}`));
+  console.log(chalk2.gray(`  Command: ${command}`));
+  if (sessionFilter) {
+    console.log(chalk2.gray(`  Session filter: ${sessionFilter}`));
+  }
+  process.exit(0);
+}
+async function removeShellHook(client, id) {
+  const result = await client.send({
+    method: "hook.shell.remove",
+    params: { id }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Shell hook removed: ${id}`));
+  process.exit(0);
+}
+async function listShellHooks(client) {
+  const result = await client.send({ method: "hook.shell.list" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const hooks = data.hooks || [];
+  if (hooks.length === 0) {
+    console.log(chalk2.gray("No shell hooks registered"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold("Shell Hooks:"));
+  for (const hook of hooks) {
+    const status = hook.enabled ? chalk2.green("enabled") : chalk2.gray("disabled");
+    console.log(`  ${chalk2.cyan(hook.id)} [${status}]`);
+    console.log(`    Event: ${chalk2.yellow(hook.event)}`);
+    console.log(`    Command: ${chalk2.gray(hook.command)}`);
+    if (hook.sessionFilter) {
+      console.log(`    Session: ${chalk2.magenta(hook.sessionFilter)}`);
+    }
+  }
+  process.exit(0);
+}
+async function addWebhook(client, event, url, sessionFilter) {
+  const result = await client.send({
+    method: "hook.webhook.add",
+    params: { event, url, sessionFilter }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Webhook added: ${data.webhook?.id}`));
+  console.log(chalk2.gray(`  Event: ${event}`));
+  console.log(chalk2.gray(`  URL: ${url}`));
+  if (sessionFilter) {
+    console.log(chalk2.gray(`  Session filter: ${sessionFilter}`));
+  }
+  process.exit(0);
+}
+async function removeWebhook(client, id) {
+  const result = await client.send({
+    method: "hook.webhook.remove",
+    params: { id }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Webhook removed: ${id}`));
+  process.exit(0);
+}
+async function listWebhooks(client) {
+  const result = await client.send({ method: "hook.webhook.list" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const webhooks = data.webhooks || [];
+  if (webhooks.length === 0) {
+    console.log(chalk2.gray("No webhooks registered"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold("Webhooks:"));
+  for (const webhook of webhooks) {
+    const status = webhook.enabled ? chalk2.green("enabled") : chalk2.gray("disabled");
+    console.log(`  ${chalk2.cyan(webhook.id)} [${status}]`);
+    console.log(`    Event: ${chalk2.yellow(webhook.event)}`);
+    console.log(`    URL: ${chalk2.gray(webhook.url)}`);
+    if (webhook.sessionFilter) {
+      console.log(`    Session: ${chalk2.magenta(webhook.sessionFilter)}`);
+    }
+  }
+  process.exit(0);
+}
+async function showHookStats(client) {
+  const result = await client.send({ method: "hook.stats" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.bold("Hook Statistics:"));
+  console.log(`  Shell Hooks: ${chalk2.cyan(data.enabledShellHooks)}/${data.shellHooks} enabled`);
+  console.log(`  Webhooks: ${chalk2.cyan(data.enabledWebhooks)}/${data.webhooks} enabled`);
+  console.log(`  Events Processed: ${chalk2.cyan(data.eventCount)}`);
+  process.exit(0);
+}
+async function addRemoteHost(client, url, apiKey, options) {
+  const result = await client.send({
+    method: "orchestration.host.add",
+    params: { url, apiKey, name: options.name, priority: options.priority }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Remote host added: ${data.host?.id}`));
+  console.log(chalk2.gray(`  Name: ${data.host?.name}`));
+  console.log(chalk2.gray(`  URL: ${url}`));
+  console.log(chalk2.gray(`  Priority: ${data.host?.priority}`));
+  process.exit(0);
+}
+async function removeRemoteHost(client, hostId) {
+  const result = await client.send({
+    method: "orchestration.host.remove",
+    params: { hostId }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Remote host removed: ${hostId}`));
+  process.exit(0);
+}
+async function toggleRemoteHost(client, hostId) {
+  const listResult = await client.send({ method: "orchestration.host.list" });
+  if (listResult.error) {
+    client.close();
+    console.error(chalk2.red(listResult.error));
+    process.exit(1);
+  }
+  const hosts = listResult.data.hosts || [];
+  const host = hosts.find((h) => h.id === hostId);
+  if (!host) {
+    client.close();
+    console.error(chalk2.red("Host not found"));
+    process.exit(1);
+  }
+  const newEnabled = !host.enabled;
+  const result = await client.send({
+    method: "orchestration.host.toggle",
+    params: { hostId, enabled: newEnabled }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`Remote host ${hostId}: ${newEnabled ? "enabled" : "disabled"}`));
+  process.exit(0);
+}
+async function listRemoteHosts(client) {
+  const result = await client.send({ method: "orchestration.host.list" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const hosts = result.data.hosts || [];
+  if (hosts.length === 0) {
+    console.log(chalk2.gray("No remote hosts configured"));
+    console.log(chalk2.gray("Add one with: cb --remote-add <url> --remote-key <apiKey>"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold("Remote Hosts:"));
+  for (const host of hosts) {
+    const status = host.enabled ? chalk2.green("enabled") : chalk2.gray("disabled");
+    console.log(`  ${chalk2.cyan(host.id)} [${status}] - ${chalk2.yellow(host.name)}`);
+    console.log(`    URL: ${chalk2.gray(host.url)}`);
+    console.log(`    Priority: ${chalk2.gray(String(host.priority))}`);
+  }
+  process.exit(0);
+}
+async function showRemoteHealth(client) {
+  const result = await client.send({ method: "orchestration.health" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const overallStatus = data.overall.healthy ? chalk2.green("HEALTHY") : chalk2.red("UNHEALTHY");
+  console.log(chalk2.bold(`Overall Status: ${overallStatus}`));
+  console.log(`  Healthy: ${chalk2.cyan(data.overall.healthyPercentage.toFixed(1))}%`);
+  console.log("");
+  if (data.hosts.length === 0) {
+    console.log(chalk2.gray("No hosts to show"));
+    process.exit(0);
+  }
+  console.log(chalk2.bold("Host Health:"));
+  for (const host of data.hosts) {
+    const status = host.healthy ? chalk2.green("healthy") : chalk2.red("unhealthy");
+    console.log(`  ${chalk2.cyan(host.hostId)} [${status}]`);
+    console.log(`    Uptime: ${chalk2.gray(host.uptime.toFixed(1) + "%")}`);
+    console.log(`    Avg Latency: ${chalk2.gray(host.avgLatency.toFixed(0) + "ms")}`);
+    console.log(`    P99 Latency: ${chalk2.gray(host.p99Latency.toFixed(0) + "ms")}`);
+    console.log(`    Success Rate: ${chalk2.gray(host.successRate.toFixed(1) + "%")}`);
+    if (host.lastError) {
+      console.log(`    Last Error: ${chalk2.red(host.lastError)}`);
+    }
+  }
+  process.exit(0);
+}
+async function showOrchestrationStats(client) {
+  const result = await client.send({ method: "orchestration.stats" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.bold("Orchestration Statistics:"));
+  console.log("");
+  console.log(chalk2.bold("  Hosts:"));
+  console.log(`    Total: ${chalk2.cyan(data.hosts.total)}`);
+  console.log(`    Healthy: ${chalk2.green(data.hosts.healthy)}`);
+  console.log(`    Unhealthy: ${data.hosts.unhealthy > 0 ? chalk2.red(data.hosts.unhealthy) : chalk2.gray("0")}`);
+  console.log("");
+  console.log(chalk2.bold("  Requests:"));
+  console.log(`    Total: ${chalk2.cyan(data.requests.total)}`);
+  console.log(`    Successful: ${chalk2.green(data.requests.successful)}`);
+  console.log(`    Failed: ${data.requests.failed > 0 ? chalk2.red(data.requests.failed) : chalk2.gray("0")}`);
+  console.log(`    Failovers: ${chalk2.yellow(data.requests.failovers)}`);
+  console.log("");
+  console.log(chalk2.bold("  Pipelines:"));
+  console.log(`    Total: ${chalk2.cyan(data.pipelines.total)}`);
+  console.log(`    Completed: ${chalk2.green(data.pipelines.completed)}`);
+  console.log(`    Failed: ${data.pipelines.failed > 0 ? chalk2.red(data.pipelines.failed) : chalk2.gray("0")}`);
+  console.log(`    Partial: ${chalk2.yellow(data.pipelines.partial)}`);
+  const cbEntries = Object.entries(data.circuitBreakers);
+  if (cbEntries.length > 0) {
+    console.log("");
+    console.log(chalk2.bold("  Circuit Breakers:"));
+    for (const [hostId, cb] of cbEntries) {
+      const stateColor = cb.state === "closed" ? chalk2.green : cb.state === "open" ? chalk2.red : chalk2.yellow;
+      console.log(`    ${hostId}: ${stateColor(cb.state)} (${cb.failures} failures)`);
+    }
+  }
+  process.exit(0);
+}
+async function sendRemotePrompt(client, hostId, prompt) {
+  console.log(chalk2.gray(`Sending prompt to remote host ${hostId}...`));
+  const result = await client.send({
+    method: "orchestration.prompt",
+    params: { hostId, prompt }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Prompt completed on ${data.host}`));
+  console.log(chalk2.gray(`  Session: ${data.sessionId}`));
+  console.log(chalk2.gray(`  Status: ${data.status}`));
+  console.log(chalk2.gray(`  Latency: ${data.latency}ms`));
+  if (data.output) {
+    console.log("");
+    console.log(chalk2.bold("Output:"));
+    console.log(data.output);
+  }
+  if (data.error) {
+    console.log("");
+    console.error(chalk2.red(`Error: ${data.error}`));
+  }
+  process.exit(0);
+}
+async function fireAndForgetPrompt(client, prompt, goal) {
+  const result = await client.send({
+    method: "prompt.fire",
+    params: { prompt, goal }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green("Task launched in background"));
+  console.log(`  Session: ${chalk2.cyan(data.sessionId)}`);
+  console.log(`  Goal: ${chalk2.gray(data.goal)}`);
+  console.log("");
+  console.log(chalk2.gray("Check status:"));
+  console.log(`  ${chalk2.yellow("cb -i")}          ${chalk2.gray("# notification inbox")}`);
+  console.log(`  ${chalk2.yellow("cb -l")}          ${chalk2.gray("# view output")}`);
+  console.log(`  ${chalk2.yellow("cb -w")}          ${chalk2.gray("# watch live")}`);
+  process.exit(0);
+}
+async function fireRemotePrompt(client, hostId, prompt, goal) {
+  const result = await client.send({
+    method: "orchestration.fire",
+    params: { hostId, prompt, goal }
+  });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green("Remote task dispatched"));
+  console.log(`  Host: ${chalk2.cyan(hostId)}`);
+  console.log(`  Goal: ${chalk2.gray(data.goal)}`);
+  console.log("");
+  console.log(`  ${chalk2.yellow("cb -i")}  ${chalk2.gray("# check when done")}`);
+  process.exit(0);
+}
+function renderMarkdown(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      result.push(inCodeBlock ? chalk2.gray("  \u250C\u2500") : chalk2.gray("  \u2514\u2500"));
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(chalk2.gray(`  \u2502 ${line}`));
+      continue;
+    }
+    if (line.startsWith("### ")) {
+      result.push(chalk2.bold.dim(line.slice(4)));
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      result.push(chalk2.bold(line.slice(3)));
+      continue;
+    }
+    if (line.startsWith("# ")) {
+      result.push(chalk2.bold.underline(line.slice(2)));
+      continue;
+    }
+    if (line.startsWith("> ")) {
+      result.push(chalk2.gray(`  \u2502 ${line.slice(2)}`));
+      continue;
+    }
+    if (/^[-*] /.test(line)) {
+      result.push(`  \u2022 ${renderInline(line.slice(2))}`);
+      continue;
+    }
+    const orderedMatch = line.match(/^(\d+)\. (.*)$/);
+    if (orderedMatch) {
+      result.push(`  ${orderedMatch[1]}. ${renderInline(orderedMatch[2])}`);
+      continue;
+    }
+    result.push(`  ${renderInline(line)}`);
+  }
+  return result.join("\n");
+}
+function renderInline(text) {
+  text = text.replace(/\*\*(.+?)\*\*/g, (_, m) => chalk2.bold(m));
+  text = text.replace(/(?<!\*)\*([^*]+?)\*(?!\*)/g, (_, m) => chalk2.italic(m));
+  text = text.replace(/`([^`]+?)`/g, (_, m) => chalk2.cyan(m));
+  return text;
+}
+async function showInbox(client) {
+  const result = await client.send({ method: "notification.list", params: { unreadOnly: false } });
+  if (result.error) {
+    client.close();
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const notifications = [...data.notifications || []].reverse();
+  if (notifications.length === 0) {
+    client.close();
+    console.log(chalk2.gray("No notifications"));
+    process.exit(0);
+  }
+  let currentIndex = 0;
+  function render() {
+    const rows = process.stdout.rows || 24;
+    const cols = process.stdout.columns || 80;
+    const n = notifications[currentIndex];
+    const total = notifications.length;
+    const unreadCount = notifications.filter((x) => !x.read).length;
+    process.stdout.write("\x1B[2J\x1B[H");
+    const headerLeft = `\u2500\u2500 Inbox (${currentIndex + 1}/${total})${n.read ? "" : " * unread"}`;
+    const headerRight = unreadCount > 0 ? `${unreadCount} unread \u2500\u2500` : "\u2500\u2500";
+    console.log(chalk2.bold(headerLeft) + chalk2.gray(` ${"\u2500".repeat(Math.max(2, cols - headerLeft.length - headerRight.length - 2))} ${headerRight}`));
+    console.log("");
+    const statusIcon = n.type === "prompt.completed" ? chalk2.green("OK") : chalk2.red("ERR");
+    const duration = n.durationMs ? `${(n.durationMs / 1e3).toFixed(1)}s` : "";
+    const cost = n.costUsd ? `$${n.costUsd.toFixed(4)}` : "";
+    const time = new Date(n.timestamp).toLocaleTimeString();
+    console.log(`  ${statusIcon}  ${chalk2.cyan.bold(n.sessionName || n.sessionId)}  ${chalk2.gray(time)}  ${chalk2.gray(duration)}  ${chalk2.gray(cost)}`);
+    if (n.goal) {
+      console.log(`  ${chalk2.gray("Goal:")} ${n.goal}`);
+    }
+    console.log("");
+    const bodyText = n.resultFull || n.resultPreview || "";
+    if (bodyText) {
+      const rendered = renderMarkdown(bodyText);
+      const maxBodyLines = rows - 10;
+      const bodyLines = rendered.split("\n");
+      if (bodyLines.length > maxBodyLines) {
+        console.log(bodyLines.slice(0, maxBodyLines).join("\n"));
+        console.log(chalk2.gray(`  ... (${bodyLines.length - maxBodyLines} more lines)`));
+      } else {
+        console.log(rendered);
+      }
+    } else {
+      console.log(chalk2.gray("  (no output)"));
+    }
+    console.log("");
+    if (n.claudeSessionId) {
+      console.log(`  ${chalk2.gray("Resume:")} ${chalk2.yellow('cb "your follow-up here"')}`);
+    } else {
+      console.log(`  ${chalk2.gray("View:")} ${chalk2.yellow("cb -l")}`);
+    }
+    console.log("");
+    const footer = "\u2500\u2500 n=next  p=prev  r=read  d=delete  q=quit \u2500\u2500";
+    console.log(chalk2.gray(footer));
+  }
+  function cleanup() {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdout.write("\x1B[2J\x1B[H");
+    client.close();
+  }
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  render();
+  process.stdin.on("data", async (key) => {
+    switch (key) {
+      case "n":
+      case "j":
+      case "\x1B[C":
+      case "\x1B[B":
+        if (currentIndex < notifications.length - 1) {
+          currentIndex++;
+          render();
+        }
+        break;
+      case "p":
+      case "k":
+      case "\x1B[D":
+      case "\x1B[A":
+        if (currentIndex > 0) {
+          currentIndex--;
+          render();
+        }
+        break;
+      case "r": {
+        const n = notifications[currentIndex];
+        if (!n.read) {
+          await client.send({ method: "notification.markRead", params: { id: n.id } });
+          n.read = true;
+          render();
+        }
+        break;
+      }
+      case "d": {
+        const n = notifications[currentIndex];
+        await client.send({ method: "notification.delete", params: { id: n.id } });
+        notifications.splice(currentIndex, 1);
+        if (notifications.length === 0) {
+          cleanup();
+          console.log(chalk2.gray("No more notifications"));
+          process.exit(0);
+        }
+        if (currentIndex >= notifications.length) {
+          currentIndex = notifications.length - 1;
+        }
+        render();
+        break;
+      }
+      case "q":
+      case "":
+        cleanup();
+        process.exit(0);
+        break;
+      default:
+        if (key === "\x1B") {
+          cleanup();
+          process.exit(0);
+        }
+        break;
+    }
+  });
+  await new Promise(() => {
+  });
+}
+async function clearInbox(client) {
+  const result = await client.send({ method: "notification.clear" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green(`Marked ${data.cleared} notification${data.cleared !== 1 ? "s" : ""} as read`));
+  process.exit(0);
+}
+async function showInboxCount(client) {
+  const result = await client.send({ method: "notification.count" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  if (data.unread > 0) {
+    console.log(chalk2.yellow(`${data.unread} unread notification${data.unread !== 1 ? "s" : ""} (${data.total} total)`));
+    console.log(chalk2.gray("View with: cb -i"));
+  } else {
+    console.log(chalk2.gray(`No unread notifications (${data.total} total)`));
+  }
+  process.exit(0);
+}
+async function setupTelegram(client, token) {
+  console.log(chalk2.gray("Setting up Telegram bot..."));
+  const result = await client.send({ method: "telegram.setup", params: { token } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green("Telegram bot started!"));
+  if (data.username) {
+    console.log(`  Bot: ${chalk2.cyan(`@${data.username}`)}`);
+  }
+  console.log("");
+  console.log(chalk2.gray("Send /start to your bot in Telegram to register."));
+  process.exit(0);
+}
+async function stopTelegram(client) {
+  const result = await client.send({ method: "telegram.stop" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green("Telegram bot stopped and token cleared."));
+  process.exit(0);
+}
+async function showTelegramStatus(client) {
+  const result = await client.send({ method: "telegram.status" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  const status = data.running ? chalk2.green("running") : chalk2.gray("stopped");
+  console.log(chalk2.bold("Telegram Bot:"));
+  console.log(`  Status: ${status}`);
+  console.log(`  Enabled: ${data.enabled ? chalk2.green("yes") : chalk2.gray("no")}`);
+  if (data.chatIds.length > 0) {
+    console.log(`  Registered chats: ${chalk2.cyan(data.chatIds.length.toString())}`);
+  } else {
+    console.log(chalk2.gray("  No registered chats (send /start to your bot)"));
+  }
+  if (data.running) {
+    console.log(`  Forwarding: ${data.forwardAllSessions !== false ? chalk2.green("all sessions") : chalk2.gray("fire-and-forget only")}`);
+  }
+  if (!data.running && !data.enabled) {
+    console.log("");
+    console.log(chalk2.gray("Set up with: cb --telegram <token>"));
+  }
+  process.exit(0);
+}
+async function setTelegramForward(client, enabled) {
+  const result = await client.send({ method: "telegram.setForward", params: { enabled } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const status = enabled ? chalk2.green("enabled") : chalk2.gray("disabled");
+  console.log(`Telegram session forwarding: ${status}`);
+  process.exit(0);
+}
+function printShellInit() {
+  const script = `
+# Claude-B inbox notification hook
+_cb_check_inbox() {
+  local marker="$HOME/.claude-b/inbox-new"
+  if [ -f "$marker" ]; then
+    local msg
+    msg=$(cat "$marker" 2>/dev/null)
+    rm -f "$marker"
+    printf '\\e[33m[Claude-B]\\e[0m %s \u2014 run \\e[1mcb -i\\e[0m to view\\n' "$msg"
+  fi
+}
+
+# Install into the appropriate shell
+if [ -n "$ZSH_VERSION" ]; then
+  autoload -Uz add-zsh-hook 2>/dev/null
+  if typeset -f add-zsh-hook >/dev/null 2>&1; then
+    add-zsh-hook precmd _cb_check_inbox
+  else
+    precmd_functions+=(_cb_check_inbox)
+  fi
+elif [ -n "$BASH_VERSION" ]; then
+  if [[ ! "$PROMPT_COMMAND" =~ _cb_check_inbox ]]; then
+    PROMPT_COMMAND="_cb_check_inbox\${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+  fi
+fi
+`.trim();
+  console.log(script);
+}
+async function setupVoicePipeline(client, provider, apiKey) {
+  console.log(chalk2.gray(`Configuring STT provider (${provider})...`));
+  const result = await client.send({ method: "voice.setup", params: { provider, apiKey } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  console.log(chalk2.green(`STT provider configured: ${provider}`));
+  console.log("");
+  console.log(chalk2.gray("Next: set up an AI provider for prompt optimization:"));
+  console.log(chalk2.gray("  cb --ai-provider anthropic <api-key>"));
+  console.log(chalk2.gray("  cb --ai-provider openrouter <api-key>"));
+  process.exit(0);
+}
+async function setupVoiceAI(client, provider, apiKey, model) {
+  console.log(chalk2.gray(`Configuring AI provider (${provider})...`));
+  const result = await client.send({ method: "voice.ai", params: { provider, apiKey, model } });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.green("AI provider configured!"));
+  console.log(`  Provider: ${chalk2.cyan(data.provider || provider)}`);
+  console.log(`  Model: ${chalk2.cyan(data.model || "default")}`);
+  console.log("");
+  console.log(chalk2.gray("Voice pipeline is ready. Send a voice message in Telegram!"));
+  process.exit(0);
+}
+async function showVoiceStatus(client) {
+  const result = await client.send({ method: "voice.status" });
+  client.close();
+  if (result.error) {
+    console.error(chalk2.red(result.error));
+    process.exit(1);
+  }
+  const data = result.data;
+  console.log(chalk2.bold("Voice Pipeline:"));
+  if (data.sttProvider) {
+    console.log(`  STT Provider: ${chalk2.green(data.sttProvider.provider)}`);
+  } else {
+    console.log(`  STT Provider: ${chalk2.gray("not configured")}`);
+  }
+  if (data.aiProvider) {
+    console.log(`  AI Provider: ${chalk2.green(data.aiProvider.provider)} (${chalk2.cyan(data.aiProvider.model)})`);
+  } else {
+    console.log(`  AI Provider: ${chalk2.gray("not configured")}`);
+  }
+  console.log(`  Pipeline: ${data.pipelineActive ? chalk2.green("active") : chalk2.yellow("inactive")}`);
+  if (!data.sttProvider || !data.aiProvider) {
+    console.log("");
+    if (!data.sttProvider) {
+      console.log(chalk2.gray("  Set up STT: cb --voice-setup <speechmatics|deepgram|openai> <api-key>"));
+    }
+    if (!data.aiProvider) {
+      console.log(chalk2.gray("  Set up AI: cb --ai-provider <anthropic|openrouter> <api-key>"));
+    }
+  }
+  process.exit(0);
+}
+var hasArgs = process.argv.length > 2;
+if (!process.stdin.isTTY && !hasArgs) {
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    input += chunk;
+  });
+  process.stdin.on("end", () => {
+    if (input.trim()) {
+      const client = new DaemonClient();
+      sendPrompt(client, input.trim()).catch(console.error);
+    } else {
+      program.parse();
+    }
+  });
+} else {
+  program.parse();
+}