@inceptionstack/roundhouse 0.2.2 → 0.3.0

package/src/cli/cli.ts

@@ -2,46 +2,34 @@
 
 /**
  * roundhouse CLI entry point
- *
- * Commands:
- *   roundhouse start      — start the gateway (foreground)
- *   roundhouse install    — install as a systemd daemon
- *   roundhouse uninstall  — remove the systemd daemon
- *   roundhouse update     — update to latest version from npm + restart daemon
- *   roundhouse status     — show daemon status
- *   roundhouse logs       — tail daemon logs
- *   roundhouse stop       — stop the daemon
- *   roundhouse restart    — restart the daemon
- *   roundhouse config     — show config path and current config
  */
 
 import { resolve, dirname } from "node:path";
 import { homedir } from "node:os";
-import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { readFile, writeFile, mkdir, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { readdirSync, statSync } from "node:fs";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
+import {
+  CONFIG_DIR,
+  CONFIG_PATH,
+  ENV_FILE_PATH,
+  DEFAULT_CONFIG,
+  SERVICE_NAME,
+  fileExists,
+  loadConfig,
+  resolveEnvFilePath,
+} from "../config";
+import { getAgentSdkPackage } from "../agents/registry";
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const SERVICE_NAME = "roundhouse";
-const CONFIG_DIR = resolve(homedir(), ".config", "roundhouse");
-const CONFIG_PATH = resolve(CONFIG_DIR, "gateway.config.json");
 const SERVICE_PATH = `/etc/systemd/system/${SERVICE_NAME}.service`;
 
-const DEFAULT_CONFIG = {
-  agent: {
-    type: "pi",
-    cwd: homedir(),
-  },
-  chat: {
-    botUsername: "roundhouse_bot",
-    allowedUsers: [] as string[],
-    adapters: {
-      telegram: { mode: "polling" },
-    },
-  },
-};
+// ── Shell helpers ───────────────────────────────────
 
 function run(cmd: string, opts?: { silent?: boolean }): string {
   try {
@@ -56,40 +44,31 @@ function runSudo(cmd: string): void {
   execSync(`sudo ${cmd}`, { stdio: "inherit" });
 }
 
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
+function systemctl(verb: string, message?: string): void {
+  runSudo(`systemctl ${verb} ${SERVICE_NAME}`);
+  if (message) console.log(`  ✅ ${message}`);
 }
 
 // ── Commands ────────────────────────────────────────
 
 async function cmdStart() {
-  // Import and run the gateway in-process (foreground)
   process.env.ROUNDHOUSE_CONFIG = CONFIG_PATH;
-  const indexPath = resolve(__dirname, "..", "src", "index.ts");
-
-  // If running from installed npm package, use compiled JS
+  const indexPath = resolve(__dirname, "..", "index.ts");
   const jsPath = resolve(__dirname, "..", "dist", "index.js");
+
   if (await fileExists(jsPath)) {
     await import(jsPath);
   } else {
-    // Dev mode: use tsx
-    const { execSync } = await import("node:child_process");
-    execSync(`node ${resolve(__dirname, "..", "node_modules", "tsx", "dist", "cli.mjs")} ${indexPath}`, {
-      stdio: "inherit",
-      env: { ...process.env, ROUNDHOUSE_CONFIG: CONFIG_PATH },
-    });
+    execSync(
+      `node ${resolve(__dirname, "..", "node_modules", "tsx", "dist", "cli.mjs")} ${indexPath}`,
+      { stdio: "inherit", env: { ...process.env, ROUNDHOUSE_CONFIG: CONFIG_PATH } },
+    );
   }
 }
 
 async function cmdInstall() {
   console.log("[roundhouse] Installing as systemd daemon...\n");
 
-  // 1. Create config if missing
   await mkdir(CONFIG_DIR, { recursive: true });
   if (await fileExists(CONFIG_PATH)) {
     console.log(`  Config exists: ${CONFIG_PATH}`);
@@ -99,19 +78,55 @@ async function cmdInstall() {
     console.log(`  ⚠️  Edit this file to set allowedUsers and other settings.`);
   }
 
-  // 2. Find roundhouse binary
-  const binPath = run("which roundhouse", { silent: true }) || resolve(__dirname, "cli.ts");
-  const nodePath = run("which node", { silent: true }) || process.execPath;
-
-  // 3. Gather env vars for the service (only known safe ones)
-  const envLines: string[] = [];
-  for (const key of ["TELEGRAM_BOT_TOKEN", "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "BOT_USERNAME", "ALLOWED_USERS"]) {
+  // Write environment file for secrets — merge with existing to preserve manually-added keys
+  const ENV_KEYS = ["TELEGRAM_BOT_TOKEN", "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "BOT_USERNAME", "ALLOWED_USERS", "NOTIFY_CHAT_IDS", "AWS_PROFILE", "AWS_DEFAULT_REGION", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN"];
+  const existing = new Map<string, string>();
+  const resolvedEnvPath = await resolveEnvFilePath();
+  if (await fileExists(resolvedEnvPath)) {
+    const raw = await readFile(resolvedEnvPath, "utf8");
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq > 0) existing.set(trimmed.slice(0, eq), trimmed.slice(eq + 1));
+    }
+  }
+  // Override with current env vars for known keys
+  let envChanged = false;
+  for (const key of ENV_KEYS) {
     if (process.env[key]) {
-      envLines.push(`Environment=${key}=${process.env[key]}`);
+      existing.set(key, `"${process.env[key].replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$$").replace(/`/g, "\\`").replace(/\n/g, "\\n")}"`);
+      envChanged = true;
     }
   }
+  if (envChanged || !(await fileExists(ENV_FILE_PATH))) {
+    if (resolvedEnvPath !== ENV_FILE_PATH && await fileExists(resolvedEnvPath)) {
+      console.log(`  Copying env file from ${resolvedEnvPath} to ${ENV_FILE_PATH}`);
+    }
+    const envFileContent = [...existing.entries()].map(([k, v]) => `${k}=${v}`).join("\n") + "\n";
+    await writeFile(ENV_FILE_PATH, envFileContent, { mode: 0o600 });
+    console.log(`  Environment file: ${ENV_FILE_PATH}`);
+  }
+
+  // Resolve paths — prefer the installed bin, fall back to tsx + source
+  const binPath = run("which roundhouse", { silent: true });
+  const nodePath = run("which node", { silent: true }) || process.execPath;
+  const tsxPath = resolve(__dirname, "..", "node_modules", ".bin", "tsx");
+  const srcIndex = resolve(__dirname, "..", "index.ts");
+
+  let execStart: string;
+  if (binPath) {
+    execStart = `${nodePath} ${binPath} start`;
+  } else {
+    // No global install — use tsx directly
+    const tsxBin = run("which tsx", { silent: true }) || tsxPath;
+    execStart = `${tsxBin} ${srcIndex}`;
+  }
+
+  // Compute PATH that includes node's bin dir (for mise/nvm setups)
+  const nodeBinDir = dirname(nodePath);
+  const pathValue = `${nodeBinDir}:/usr/local/bin:/usr/bin:/bin`;
 
-  // 4. Create systemd unit
   const unit = `[Unit]
 Description=Roundhouse Chat Gateway
 After=network.target
@@ -120,47 +135,45 @@ After=network.target
 Type=simple
 User=${process.env.USER || "root"}
 WorkingDirectory=${homedir()}
-ExecStart=${nodePath} ${binPath} start
+ExecStart=${execStart}
 Restart=on-failure
 RestartSec=5
-${envLines.join("\n")}
+EnvironmentFile=-${ENV_FILE_PATH}
 Environment=ROUNDHOUSE_CONFIG=${CONFIG_PATH}
 Environment=NODE_ENV=production
+Environment=PATH=${pathValue}
 
 [Install]
 WantedBy=multi-user.target
 `;
 
-  const tmpUnit = `/tmp/${SERVICE_NAME}.service`;
-  await writeFile(tmpUnit, unit);
+  const tmpDir = await mkdtemp(resolve(tmpdir(), "roundhouse-"));
+  const tmpUnit = resolve(tmpDir, `${SERVICE_NAME}.service`);
+  await writeFile(tmpUnit, unit, { mode: 0o600 });
   runSudo(`cp ${tmpUnit} ${SERVICE_PATH}`);
+  runSudo(`rm -rf -- ${tmpDir}`);
   runSudo("systemctl daemon-reload");
-  runSudo(`systemctl enable ${SERVICE_NAME}`);
-  runSudo(`systemctl start ${SERVICE_NAME}`);
-
-  console.log(`\n  ✅ Daemon installed and started.`);
-  console.log(`\n  Config:  ${CONFIG_PATH}`);
-  console.log(`  Service: ${SERVICE_PATH}`);
-  console.log(`  Logs:    roundhouse logs`);
-  console.log(`  Status:  roundhouse status`);
-
-  if (envLines.length === 0) {
-    console.log(`\n  ⚠️  No env vars detected. You may need to add TELEGRAM_BOT_TOKEN etc.`);
-    console.log(`     Edit ${SERVICE_PATH} or use an EnvironmentFile=`);
+  systemctl("enable");
+  systemctl("start", "Daemon installed and started.");
+
+  console.log(`\n  Config:   ${CONFIG_PATH}`);
+  console.log(`  Env file: ${ENV_FILE_PATH}`);
+  console.log(`  Service:  ${SERVICE_PATH}`);
+  console.log(`  Logs:     roundhouse logs`);
+  console.log(`  Status:   roundhouse status`);
+
+  if (!envChanged) {
+    console.log(`\n  ⚠️  No env vars detected. Edit ${ENV_FILE_PATH} with your secrets:`);
+    console.log(`     TELEGRAM_BOT_TOKEN=...`);
+    console.log(`     Then add your API keys and run: roundhouse restart`);
   }
 }
 
 async function cmdUninstall() {
   console.log("[roundhouse] Removing systemd daemon...");
-  try {
-    runSudo(`systemctl stop ${SERVICE_NAME}`);
-  } catch {}
-  try {
-    runSudo(`systemctl disable ${SERVICE_NAME}`);
-  } catch {}
-  try {
-    runSudo(`rm -f ${SERVICE_PATH}`);
-  } catch {}
+  try { systemctl("stop"); } catch {}
+  try { systemctl("disable"); } catch {}
+  try { runSudo(`rm -f ${SERVICE_PATH}`); } catch {}
   runSudo("systemctl daemon-reload");
   console.log("  ✅ Daemon removed. Config preserved at:", CONFIG_PATH);
 }
@@ -170,84 +183,143 @@ async function cmdUpdate() {
   run("npm update -g roundhouse");
   console.log("\n[roundhouse] Restarting daemon...");
   try {
-    runSudo(`systemctl restart ${SERVICE_NAME}`);
-    console.log("  ✅ Updated and restarted.");
+    systemctl("restart", "Updated and restarted.");
   } catch {
     console.log("  ⚠️  Daemon not running. Start with: roundhouse install");
   }
 }
 
-function cmdStatus() {
+async function cmdStatus() {
+  // Show systemd status
+  const isActive = run(`systemctl is-active ${SERVICE_NAME}`, { silent: true }) === "active";
+
+  if (!isActive) {
+    console.log("\n  ❌ Roundhouse is not running.\n");
+    console.log("  Install with: roundhouse install");
+    console.log("  Or start foreground: roundhouse start\n");
+    return;
+  }
+
+  // Load config for details
+  let config: Awaited<ReturnType<typeof loadConfig>> | null = null;
   try {
-    run(`systemctl status ${SERVICE_NAME}`);
-  } catch {
-    console.log("Daemon is not installed. Run: roundhouse install");
+    config = await loadConfig();
+  } catch {}
+
+  // Gather systemd info
+  const pid = run(`systemctl show -p MainPID --value ${SERVICE_NAME}`, { silent: true });
+  const activeState = run(`systemctl show -p ActiveState --value ${SERVICE_NAME}`, { silent: true });
+  const startedAt = run(`systemctl show -p ActiveEnterTimestamp --value ${SERVICE_NAME}`, { silent: true });
+
+  // Compute uptime
+  let uptimeStr = "unknown";
+  if (startedAt) {
+    const startMs = new Date(startedAt).getTime();
+    if (!isNaN(startMs)) {
+      const sec = Math.max(0, Math.floor((Date.now() - startMs) / 1000));
+      if (sec < 3600) uptimeStr = `${Math.floor(sec / 60)}m ${sec % 60}s`;
+      else uptimeStr = `${Math.floor(sec / 3600)}h ${Math.floor((sec % 3600) / 60)}m`;
+    }
+  }
+
+  // Memory from PID
+  let memStr = "unknown";
+  if (pid && pid !== "0" && /^\d+$/.test(pid)) {
+    const rssKb = run(`ps -o rss= -p ${pid}`, { silent: true }).trim();
+    if (rssKb) {
+      const parsed = parseInt(rssKb, 10);
+      if (!isNaN(parsed)) memStr = `${(parsed / 1024).toFixed(1)} MB`;
+    }
   }
+
+  // Read env file for debug flags
+  let debugStream = false;
+  const statusEnvPath = await resolveEnvFilePath();
+  try {
+    const envContent = await readFile(statusEnvPath, "utf8");
+    debugStream = envContent.includes("ROUNDHOUSE_DEBUG_STREAM=1") || envContent.includes('ROUNDHOUSE_DEBUG_STREAM="1"');
+  } catch {}
+
+  // Read versions
+  let roundhouseVersion = "unknown";
+  let agentVersion = "unknown";
+  try {
+    const pkgPath = resolve(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    roundhouseVersion = pkg.version;
+  } catch {}
+
+  // Resolve agent SDK version from registry
+  const agentPkg = config ? getAgentSdkPackage(config.agent.type) : undefined;
+  if (agentPkg) {
+    try {
+      const agentPkgPath = resolve(__dirname, "..", "..", "node_modules", ...agentPkg.split("/"), "package.json");
+      agentVersion = JSON.parse(await readFile(agentPkgPath, "utf8")).version;
+    } catch {}
+  }
+
+  console.log("\n  🟢 Roundhouse is running\n");
+  console.log(`  Version:        v${roundhouseVersion}`);
+  console.log(`  State:          ${activeState}`);
+  console.log(`  PID:            ${pid}`);
+  console.log(`  Uptime:         ${uptimeStr}`);
+  console.log(`  Memory:         ${memStr}`);
+
+  if (config) {
+    const platforms = Object.keys(config.chat.adapters).join(", ");
+    const allowedCount = config.chat.allowedUsers?.length ?? 0;
+    console.log(`  Agent:          ${config.agent.type} (v${agentVersion})`);
+    console.log(`  Agent CWD:      ${config.agent.cwd ?? process.cwd()}`);
+    console.log(`  Platforms:      ${platforms}`);
+    console.log(`  Bot:            @${config.chat.botUsername}`);
+    console.log(`  Allowed users:  ${allowedCount === 0 ? "all (no allowlist)" : config.chat.allowedUsers!.join(", ")}`);
+    console.log(`  Notify chats:   ${config.chat.notifyChatIds?.join(", ") ?? "none"}`);
+  }
+
+  console.log(`  Debug stream:   ${debugStream ? "on" : "off"}`);
+  console.log(`  Config:         ${CONFIG_PATH}`);
+  console.log(`  Env file:       ${statusEnvPath}`);
+  console.log();
 }
 
 function cmdLogs() {
   const child = spawn("journalctl", ["-u", SERVICE_NAME, "-f", "--no-pager", "-n", "100"], {
     stdio: "inherit",
   });
-  child.on("error", () => {
-    console.log("Could not read logs. Is the daemon installed?");
-  });
+  child.on("error", () => console.log("Could not read logs. Is the daemon installed?"));
 }
 
-function cmdStop() {
-  runSudo(`systemctl stop ${SERVICE_NAME}`);
-  console.log("  ✅ Daemon stopped.");
-}
-
-function cmdRestart() {
-  runSudo(`systemctl restart ${SERVICE_NAME}`);
-  console.log("  ✅ Daemon restarted.");
-}
+function cmdStop() { systemctl("stop", "Daemon stopped."); }
+function cmdRestart() { systemctl("restart", "Daemon restarted."); }
 
 async function cmdConfig() {
   console.log(`Config path: ${CONFIG_PATH}\n`);
   if (await fileExists(CONFIG_PATH)) {
-    const content = await readFile(CONFIG_PATH, "utf8");
-    console.log(content);
+    console.log(await readFile(CONFIG_PATH, "utf8"));
   } else {
     console.log("(no config file — defaults will be used)");
   }
 }
 
 async function cmdTui() {
-  // 1. Load config to determine agent type
-  let config: any = DEFAULT_CONFIG;
-  if (await fileExists(CONFIG_PATH)) {
-    try {
-      config = JSON.parse(await readFile(CONFIG_PATH, "utf8"));
-    } catch {}
-  }
-
+  const config = await loadConfig();
   const agentType = config.agent?.type ?? "pi";
 
   if (agentType !== "pi") {
     console.error(`roundhouse tui: agent type "${agentType}" does not support TUI yet.`);
-    console.error("Only \"pi\" is supported currently.");
     process.exit(1);
   }
 
-  // 2. Find gateway sessions
-  const sessionsBase = config.agent?.sessionDir ?? resolve(homedir(), ".pi", "agent", "gateway-sessions");
+  const sessionsBase = (config.agent as any)?.sessionDir
+    ?? resolve(homedir(), ".pi", "agent", "gateway-sessions");
+
   let threadDirs: string[] = [];
   try {
-    const { readdirSync, statSync } = await import("node:fs");
     threadDirs = readdirSync(sessionsBase)
-      .filter((d: string) => {
-        try {
-          return statSync(resolve(sessionsBase, d)).isDirectory();
-        } catch {
-          return false;
-        }
-      })
+      .filter((d) => { try { return statSync(resolve(sessionsBase, d)).isDirectory(); } catch { return false; } })
       .sort();
   } catch {
     console.error(`No gateway sessions found at ${sessionsBase}`);
-    console.error("Send a message via Telegram/Slack first to create a session.");
     process.exit(1);
   }
 
@@ -256,26 +328,18 @@ async function cmdTui() {
     process.exit(1);
   }
 
-  // 3. Find session files in each thread dir, pick the most recent
-  const { readdirSync, statSync } = await import("node:fs");
-  const threadArg = process.argv[3]; // optional: roundhouse tui <thread>
+  const threadArg = process.argv[3];
 
-  interface SessionCandidate {
-    threadDir: string;
-    sessionFile: string;
-    mtime: number;
-  }
+  interface SessionCandidate { threadDir: string; sessionFile: string; mtime: number; }
 
   const candidates: SessionCandidate[] = [];
   for (const dir of threadDirs) {
     if (threadArg && !dir.includes(threadArg)) continue;
     const threadPath = resolve(sessionsBase, dir);
     try {
-      const files = readdirSync(threadPath).filter((f: string) => f.endsWith(".jsonl"));
-      for (const f of files) {
+      for (const f of readdirSync(threadPath).filter((f) => f.endsWith(".jsonl"))) {
         const fullPath = resolve(threadPath, f);
-        const st = statSync(fullPath);
-        candidates.push({ threadDir: dir, sessionFile: fullPath, mtime: st.mtimeMs });
+        candidates.push({ threadDir: dir, sessionFile: fullPath, mtime: statSync(fullPath).mtimeMs });
       }
     } catch {}
   }
@@ -291,10 +355,8 @@ async function cmdTui() {
     process.exit(1);
   }
 
-  // Sort by most recently modified
   candidates.sort((a, b) => b.mtime - a.mtime);
 
-  // If multiple threads and no filter, let user pick
   let selected: SessionCandidate;
   const uniqueThreads = [...new Set(candidates.map((c) => c.threadDir))];
 
@@ -316,14 +378,10 @@ async function cmdTui() {
     }
     console.log();
 
-    // Simple prompt
     const readline = await import("node:readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise<string>((resolve) => {
-      rl.question("Pick a session [1]: ", (ans) => {
-        rl.close();
-        resolve(ans.trim() || "1");
-      });
+    const answer = await new Promise<string>((r) => {
+      rl.question("Pick a session [1]: ", (ans) => { rl.close(); r(ans.trim() || "1"); });
     });
 
     const idx = parseInt(answer, 10) - 1;
@@ -331,28 +389,17 @@ async function cmdTui() {
       console.error("Invalid selection.");
       process.exit(1);
     }
-    // Find most recent session file for the selected thread
     selected = candidates.find((c) => c.threadDir === shown[idx].threadDir)!;
   }
 
   console.log(`\nOpening: ${selected.sessionFile}\n`);
 
-  // 4. Launch pi --resume <session>
-  const piArgs = ["--resume", selected.sessionFile];
-  const child = spawn("pi", piArgs, { stdio: "inherit" });
-
+  const child = spawn("pi", ["--resume", selected.sessionFile], { stdio: "inherit" });
   child.on("error", (err) => {
-    if ((err as any).code === "ENOENT") {
-      console.error("'pi' not found in PATH. Install pi first.");
-    } else {
-      console.error("Failed to launch pi:", err.message);
-    }
+    console.error((err as any).code === "ENOENT" ? "'pi' not found in PATH." : `Failed: ${err.message}`);
     process.exit(1);
   });
-
-  child.on("exit", (code) => {
-    process.exit(code ?? 0);
-  });
+  child.on("exit", (code) => process.exit(code ?? 0));
 }
 
 function printHelp() {
@@ -363,6 +410,8 @@ Usage:
   roundhouse <command>
 
 Commands:
+  setup               One-command install & configure (also works via npx)
+  pair                Pair Telegram account for notifications
   start               Start the gateway (foreground)
   tui [thread]        Open agent TUI on a gateway session
   install             Install as a systemd daemon (requires sudo)
@@ -373,9 +422,15 @@ Commands:
   stop                Stop the daemon
   restart             Restart the daemon
   config              Show config path and contents
+  agent <message>     Send a message to the agent and print response
+                       Options: --thread <id>, --stdin, --timeout <sec>,
+                                --no-timeout, --verbose
+  doctor [--fix]       Check system health and configuration
+                       Options: --fix, --json, --verbose
+  cron <command>       Manage scheduled jobs (add, list, trigger, etc.)
 
 Config:
-  ~/.config/roundhouse/gateway.config.json
+  ~/.roundhouse/gateway.config.json
 
 Environment:
   TELEGRAM_BOT_TOKEN    Telegram bot token
@@ -386,40 +441,180 @@ Environment:
 
 // ── Main ────────────────────────────────────────────
 
+async function cmdAgent() {
+  // Usage: roundhouse agent <message>
+  //        roundhouse agent --thread <id> <message>
+  //        echo "message" | roundhouse agent --stdin
+  const args = process.argv.slice(3);
+  let threadId = "";
+  let messageText = "";
+  let useStdin = false;
+  let timeoutMs = 120_000;
+  let verbose = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--thread" && args[i + 1]) {
+      threadId = args[++i];
+    } else if (args[i] === "--stdin") {
+      useStdin = true;
+    } else if (args[i] === "--timeout" && args[i + 1]) {
+      const val = parseInt(args[++i], 10);
+      if (isNaN(val) || val <= 0) { console.error("--timeout must be a positive number (seconds)"); process.exit(1); }
+      timeoutMs = val * 1000;
+    } else if (args[i] === "--no-timeout") {
+      timeoutMs = 0;
+    } else if (args[i] === "--verbose") {
+      verbose = true;
+    } else if (args[i].startsWith("-")) {
+      console.error(`Unknown flag: ${args[i]}`);
+      process.exit(1);
+    } else {
+      messageText = args.slice(i).join(" ");
+      break;
+    }
+  }
+
+  if (useStdin) {
+    const chunks: Buffer[] = [];
+    let totalBytes = 0;
+    const MAX_INPUT = 1024 * 1024; // 1 MB
+    for await (const chunk of process.stdin) {
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_INPUT) {
+        console.error(`Input exceeds ${MAX_INPUT / 1024}KB limit. Use a file instead.`);
+        process.exit(1);
+      }
+      chunks.push(chunk);
+    }
+    // Strip single trailing newline (shell echo adds one)
+    let raw = Buffer.concat(chunks).toString("utf8");
+    if (raw.endsWith("\n")) raw = raw.slice(0, -1);
+    messageText = raw;
+  }
+
+  if (!messageText) {
+    console.error("Usage: roundhouse agent <message>");
+    console.error("       roundhouse agent --thread <id> <message>");
+    console.error("       echo \"message\" | roundhouse agent --stdin");
+    console.error("       roundhouse agent --timeout 60 <message>");
+    console.error("       roundhouse agent --verbose <message>");
+    process.exit(1);
+  }
+
+  // Default: ephemeral thread ID (no session persistence across invocations)
+  // --thread <id> opts into persistent/shared sessions
+  if (!threadId) {
+    threadId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+
+  // Suppress debug/info logs unless --verbose
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origError = console.error;
+  if (!verbose) {
+    console.log = () => {};
+    console.warn = () => {};
+  }
+
+  let agent: import("../types").AgentAdapter | undefined;
+  let aborted = false;
+
+  // Clean abort on SIGINT/SIGTERM
+  const handleSignal = async () => {
+    if (aborted) return;
+    aborted = true;
+    console.log = origLog;
+    console.warn = origWarn;
+    console.error = origError;
+    try { await agent?.abort?.(threadId); } catch {}
+    try { await agent?.dispose(); } catch {}
+    process.exit(130);
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+
+  // Timeout race
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = timeoutMs > 0
+    ? new Promise<never>((_, reject) => {
+        timer = setTimeout(async () => {
+          aborted = true;
+          try { await agent?.abort?.(threadId); } catch {}
+          reject(new Error(`Timeout after ${timeoutMs / 1000}s`));
+        }, timeoutMs);
+      })
+    : null;
+
+  try {
+    const config = await loadConfig();
+    const { getAgentFactory } = await import("../agents/registry");
+    const factory = getAgentFactory(config.agent.type);
+    agent = factory(config.agent);
+
+    const runAgent = async () => {
+      if (agent!.promptStream) {
+        for await (const event of agent!.promptStream(threadId, { text: messageText })) {
+          if (event.type === "text_delta") {
+            process.stdout.write(event.text);
+          }
+        }
+        process.stdout.write("\n");
+      } else {
+        const response = await agent!.prompt(threadId, { text: messageText });
+        origLog(response.text);
+      }
+    };
+
+    if (timeoutPromise) {
+      await Promise.race([runAgent(), timeoutPromise]);
+    } else {
+      await runAgent();
+    }
+  } catch (err: any) {
+    console.error = origError;
+    console.error(`Error: ${err.message}`);
+    process.exit(aborted ? 124 : 1); // 124 = timeout (like coreutils)
+  } finally {
+    if (timer) clearTimeout(timer);
+    process.off("SIGINT", handleSignal);
+    process.off("SIGTERM", handleSignal);
+    console.log = origLog;
+    console.warn = origWarn;
+    console.error = origError;
+    if (!aborted) await agent?.dispose();
+  }
+}
+
+import { cmdDoctor } from "./doctor";
+import { cmdCron } from "./cron";
+import { cmdSetup, cmdPair } from "./setup";
+
 const command = process.argv[2];
 
-switch (command) {
-  case "start":
-    cmdStart();
-    break;
-  case "install":
-    cmdInstall();
-    break;
-  case "uninstall":
-    cmdUninstall();
-    break;
-  case "update":
-    cmdUpdate();
-    break;
-  case "status":
-    cmdStatus();
-    break;
-  case "logs":
-    cmdLogs();
-    break;
-  case "stop":
-    cmdStop();
-    break;
-  case "restart":
-    cmdRestart();
-    break;
-  case "config":
-    cmdConfig();
-    break;
-  case "tui":
-    cmdTui();
-    break;
-  default:
-    printHelp();
-    break;
+const commands: Record<string, () => void | Promise<void>> = {
+  setup: () => cmdSetup(process.argv.slice(3)),
+  pair: () => cmdPair(process.argv.slice(3)),
+  start: cmdStart,
+  install: cmdInstall,
+  uninstall: cmdUninstall,
+  update: cmdUpdate,
+  status: cmdStatus,
+  logs: cmdLogs,
+  stop: cmdStop,
+  restart: cmdRestart,
+  config: cmdConfig,
+  tui: cmdTui,
+  doctor: () => cmdDoctor(process.argv.slice(3)),
+  cron: () => cmdCron(process.argv.slice(3)),
+  agent: cmdAgent,
+};
+
+const fn = command ? commands[command] : undefined;
+if (fn) {
+  Promise.resolve(fn()).catch((err) => {
+    console.error(`[roundhouse] ${command} failed:`, err);
+    process.exit(1);
+  });
+} else {
+  printHelp();
 }