@inceptionstack/roundhouse 0.5.1 → 0.5.3

package/src/cli/setup/args.ts

@@ -0,0 +1,109 @@
+/**
+ * cli/setup/args.ts — CLI argument parsing for setup command
+ */
+
+import { homedir, platform } from "node:os";
+import { getAgentDefinition } from "../../agents/registry";
+import { type SetupOptions, DEFAULT_PROVIDER, DEFAULT_MODEL, EXTENSION_NAME_RE } from "./types";
+
+export function parseSetupArgs(argv: string[]): SetupOptions {
+  const opts: SetupOptions = {
+    botToken: "",
+    users: [],
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL,
+    extensions: [],
+    cwd: homedir(),
+    notifyChatIds: [],
+    systemd: platform() === "linux",
+    voice: platform() === "linux",  // Default off on macOS (whisper install is heavy)
+    psst: false,
+    nonInteractive: false,
+    force: false,
+    dryRun: false,
+    telegram: false,
+    headless: false,
+    qr: "auto",
+    agent: "pi",
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      if (i + 1 >= argv.length) throw new Error(`Missing value for ${arg}`);
+      return argv[++i];
+    };
+
+    switch (arg) {
+      case "--bot-token": opts.botToken = next(); break;
+      case "--user": opts.users.push(next().replace(/^@/, "")); break;
+      case "--provider": opts.provider = next(); break;
+      case "--model": opts.model = next(); break;
+      case "--extension": opts.extensions.push(next()); break;
+      case "--cwd": opts.cwd = next(); break;
+      case "--notify-chat": opts.notifyChatIds.push(parseInt(next(), 10)); break;
+      case "--no-systemd": opts.systemd = false; break;
+      case "--no-voice": opts.voice = false; break;
+      case "--with-psst": opts.psst = true; break;
+      case "--non-interactive": opts.nonInteractive = true; break;
+      case "--telegram": opts.telegram = true; break;
+      case "--headless": opts.headless = true; opts.nonInteractive = true; break;
+      case "--agent": opts.agent = next().toLowerCase(); break;
+      case "--qr": opts.qr = "always"; break;
+      case "--no-qr": opts.qr = "never"; break;
+      case "--force": opts.force = true; break;
+      case "--dry-run": opts.dryRun = true; break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`Unknown flag: ${arg}`);
+        throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  // Token from env if not in flags
+  if (!opts.botToken) {
+    opts.botToken = process.env.TELEGRAM_BOT_TOKEN ?? "";
+  }
+
+  // Headless: reject --bot-token (argv visible in process listings)
+  if (opts.headless && argv.some((a) => a === "--bot-token")) {
+    throw new Error(
+      "--bot-token is not accepted in --headless mode (argv visible in process listings).\n" +
+      "Use: TELEGRAM_BOT_TOKEN=... roundhouse setup --telegram --headless --user USERNAME",
+    );
+  }
+
+  // Validate agent type
+  try {
+    getAgentDefinition(opts.agent);
+  } catch (err: any) {
+    throw new Error(err.message);
+  }
+
+  // Interactive --telegram defers token/user prompting to the wizard
+  const isInteractiveTelegram = opts.telegram && !opts.headless && !opts.nonInteractive && process.stdin.isTTY;
+
+  // Validate
+  if (!opts.botToken && !opts.dryRun && !isInteractiveTelegram) {
+    throw new Error(
+      "Bot token required. Provide via:\n" +
+      "  TELEGRAM_BOT_TOKEN=... roundhouse setup --user USERNAME\n" +
+      "  roundhouse setup --bot-token TOKEN --user USERNAME",
+    );
+  }
+  if (opts.users.length === 0 && !isInteractiveTelegram) {
+    throw new Error(
+      "At least one --user USERNAME is required.\n" +
+      "This is your Telegram username (without @).",
+    );
+  }
+  for (const ext of opts.extensions) {
+    if (!EXTENSION_NAME_RE.test(ext)) {
+      throw new Error(`Invalid extension name: ${ext}`);
+    }
+  }
+  if (opts.notifyChatIds.some(isNaN)) {
+    throw new Error("--notify-chat must be a number");
+  }
+
+  return opts;
+}

package/src/cli/setup/flows.ts

@@ -0,0 +1,273 @@
+import { platform } from "node:os";
+import { execFileSync } from "node:child_process";
+import { type SetupOptions } from "./types";
+import { promptText, promptMasked } from "../setup-prompts";
+import { createJsonLogger, type SetupDiagnostics, printDiagnosticError } from "../setup-logger";
+import { printQr } from "../qr";
+import {
+  createPairingNonce,
+  createPairingLink,
+  readPendingPairing,
+  writePendingPairing,
+  type PendingPairing,
+} from "../../pairing";
+import { detectEnvironment, formatDetectionResults } from "../detect";
+import { fileExists, ROUNDHOUSE_DIR, CONFIG_PATH, ENV_FILE_PATH as ENV_PATH } from "../../config";
+import { pairTelegram } from "../setup-telegram";
+import {
+  stepPreflight,
+  stepValidateToken,
+  stepStopGateway,
+  stepInstallPackages,
+  stepStoreSecrets,
+  stepInstallBundle,
+  stepConfigure,
+  stepRegisterCommands,
+  stepInstallSystemd,
+  stepPostflight,
+} from "./steps";
+import { resolveAgentForSetup, textLog, textStepLog, createStepLog } from "./runtime";
+
+export async function runInteractiveTelegramSetup(opts: SetupOptions): Promise<void> {
+  const logger = textStepLog;
+  const agent = resolveAgentForSetup(opts, logger);
+  textLog("\n🔧 Roundhouse Telegram Setup");
+  textLog("━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+  try {
+    await stepPreflight(logger, opts, agent);
+
+    const env = detectEnvironment();
+    if (env.agents.length > 0) {
+      textLog("");
+      textLog("  🔍 Agent detection:");
+      for (const line of formatDetectionResults(env)) {
+        logger.ok(line);
+      }
+      if (!opts.force) {
+        const selected = env.agents.find(a => a.type === opts.agent);
+        if (selected?.configured) {
+          opts._skipAgentInstall = true;
+        }
+      }
+    }
+
+    if (!opts.botToken) {
+      textLog("");
+      printBotFatherGuide();
+      opts.botToken = await promptMasked("  Paste your bot token");
+      if (!opts.botToken) {
+        logger.fail("No token provided");
+        process.exit(2);
+      }
+    }
+    const botInfo = await stepValidateToken(logger, opts);
+
+    if (opts.users.length === 0) {
+      logger.step("③", "Telegram username...");
+      const username = await promptText("  Your Telegram username (without @)");
+      if (!username) {
+        logger.fail("Username required");
+        process.exit(2);
+      }
+      opts.users.push(username.replace(/^@/, ""));
+      logger.ok(`Allowed: ${opts.users.map(u => `@${u}`).join(", ")}`);
+    }
+
+    await stepStopGateway(logger);
+    await stepInstallPackages(logger, opts, agent);
+    await stepInstallBundle(logger, opts);
+
+    logger.step("⑦", "Pairing with Telegram...");
+    const nonce = createPairingNonce();
+    const pairingLink = createPairingLink(botInfo.username, nonce);
+    textLog(`\n  Open this link to pair:\n`);
+    textLog(`  🔗 ${pairingLink}\n`);
+    printQr(pairingLink, opts.qr);
+    textLog(`  Or send /start ${nonce} to @${botInfo.username}`);
+    textLog("");
+
+    if (process.platform === "darwin") {
+      try {
+        execFileSync("open", [pairingLink], { stdio: "ignore" });
+        textLog("  (Opened in Telegram — switch to the app to complete pairing)");
+      } catch {}
+    }
+
+    textLog("  Waiting for you to tap the link in Telegram...");
+
+    const pairResult = await pairTelegram(
+      opts.botToken, botInfo.username, opts.users,
+      300_000, textLog, { nonce, showLink: false },
+    );
+    if (!pairResult) {
+      logger.warn("Pairing timed out. Run 'roundhouse pair' later.");
+    } else {
+      logger.ok(`Paired with @${pairResult.username} (chat: ${pairResult.chatId})`);
+      if (!opts.notifyChatIds.includes(pairResult.chatId)) {
+        opts.notifyChatIds.push(pairResult.chatId);
+      }
+    }
+
+    await stepStoreSecrets(logger, opts, botInfo);
+    await stepConfigure(logger, opts, botInfo, pairResult, agent);
+    await stepRegisterCommands(logger, opts);
+    await stepInstallSystemd(logger, opts);
+    await stepPostflight(logger);
+
+    textLog("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    textLog("✅ Roundhouse is ready!");
+    textLog(`   Bot: @${botInfo.username}`);
+    textLog(`   Send /status to @${botInfo.username} on Telegram.\n`);
+  } catch (err: any) {
+    textLog("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    textLog(`❌ Setup failed: ${err.message}`);
+    textLog("   Re-run: roundhouse setup --telegram\n");
+    process.exit(1);
+  }
+}
+
+export async function runHeadlessTelegramSetup(opts: SetupOptions): Promise<void> {
+  const logger = createJsonLogger();
+  const stepLogger = createStepLog(logger);
+  const agent = resolveAgentForSetup(opts, stepLogger);
+
+  try {
+    if (!opts.botToken) {
+      logger.error("validation.failed", "TELEGRAM_BOT_TOKEN env var required for --headless");
+      process.exit(2);
+    }
+    if (opts.users.length === 0) {
+      logger.error("validation.failed", "--user is required for --headless");
+      process.exit(2);
+    }
+
+    logger.step(1, 9, "preflight.start", "Running preflight checks");
+    await stepPreflight(stepLogger, opts, agent);
+    logger.ok("Preflight passed");
+
+    logger.step(2, 9, "telegram.validate", "Validating Telegram bot token");
+    const botInfo = await stepValidateToken(stepLogger, opts);
+    logger.ok(`Bot: @${botInfo.username} (id: ${botInfo.id})`);
+
+    logger.step(3, 9, "gateway.stop", "Checking for running gateway");
+    await stepStopGateway(stepLogger);
+
+    logger.step(4, 9, "packages.install", "Installing packages");
+    await stepInstallPackages(stepLogger, opts, agent);
+    logger.ok("Packages installed");
+
+    await stepInstallBundle(stepLogger, opts);
+
+    logger.step(5, 9, "pairing.pending", "Creating pending pairing");
+    let nonce: string;
+    const existing = await readPendingPairing();
+    if (existing?.status === "pending" && !opts.force) {
+      nonce = existing.nonce;
+      logger.info("pairing.reuse", `Reusing existing nonce: ${nonce}`);
+    } else {
+      nonce = createPairingNonce();
+    }
+    const pairingLink = createPairingLink(botInfo.username, nonce);
+    const pendingPairing: PendingPairing = {
+      version: 1,
+      nonce,
+      botUsername: botInfo.username,
+      allowedUsers: opts.users,
+      createdAt: new Date().toISOString(),
+      status: "pending",
+    };
+    await writePendingPairing(pendingPairing);
+    logger.info("pairing.link", `Pairing link: ${pairingLink}`, { pairingLink, nonce });
+
+    logger.step(6, 9, "secrets.store", "Storing secrets");
+    await stepStoreSecrets(stepLogger, opts, botInfo);
+
+    logger.step(7, 9, "config.write", "Writing configuration");
+    await stepConfigure(stepLogger, opts, botInfo, null, agent);
+    logger.ok("Config written");
+
+    logger.step(8, 9, "commands.register", "Registering bot commands");
+    await stepRegisterCommands(stepLogger, opts);
+    logger.ok("Bot commands registered");
+
+    let serviceInstalled = false;
+    logger.step(9, 9, "service.install", "Installing and starting service");
+    if (!opts.systemd && platform() !== "darwin") {
+      logger.warn("service.skip", "--no-systemd: service not installed. Start manually: roundhouse start");
+    } else {
+      await stepInstallSystemd(stepLogger, opts);
+
+      if (platform() === "darwin") {
+        try {
+          const { isLaunchAgentRunning } = await import("../launchd.ts");
+          if (isLaunchAgentRunning()) {
+            logger.ok("LaunchAgent is running");
+            serviceInstalled = true;
+          } else {
+            logger.warn("service.state", "LaunchAgent loaded but not yet running");
+          }
+        } catch {
+          logger.warn("service.state", "Could not verify LaunchAgent state");
+        }
+      } else {
+        try {
+          const state = execFileSync("systemctl", ["is-active", "roundhouse"], { encoding: "utf8" }).trim();
+          if (state === "active") {
+            logger.ok("Service is active");
+            serviceInstalled = true;
+          } else {
+            logger.warn("service.state", `Service state: ${state}`);
+          }
+        } catch {
+          logger.warn("service.state", "Could not verify service state");
+        }
+      }
+    }
+
+    logger.info("setup.complete", "Headless setup complete", {
+      botUsername: botInfo.username,
+      pairingLink,
+      pairingStatus: "pending",
+      serviceInstalled,
+    });
+    stepLogger.log("");
+    stepLogger.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    stepLogger.log(`✅ Roundhouse installed and running!`);
+    stepLogger.log(``);
+    stepLogger.log(`   Bot: @${botInfo.username}`);
+    stepLogger.log(`   Pairing: Open ${pairingLink} to complete setup`);
+    stepLogger.log(`   Gateway is running and will accept pairing automatically.`);
+    stepLogger.log(``);
+  } catch (err: any) {
+    const diag: SetupDiagnostics = {
+      node: process.version,
+      platform: platform(),
+      arch: process.arch,
+      cwd: process.cwd(),
+      roundhouseDir: ROUNDHOUSE_DIR,
+      configExists: await fileExists(CONFIG_PATH).catch(() => false),
+      envExists: await fileExists(ENV_PATH).catch(() => false),
+      pairingStatus: (await readPendingPairing())?.status ?? "not found",
+      serviceState: "unknown",
+      error: { name: err.name, message: err.message, stack: err.stack },
+    };
+    try {
+      diag.serviceState = execFileSync("systemctl", ["is-active", "roundhouse"], { encoding: "utf8" }).trim();
+    } catch {}
+    printDiagnosticError(diag, true);
+    process.exit(1);
+  }
+}
+
+function printBotFatherGuide(): void {
+  textLog("");
+  textLog("  🤖 Create a Telegram Bot");
+  textLog("  ────────────────────────");
+  textLog("  1. Open https://t.me/BotFather");
+  textLog("  2. Send /newbot");
+  textLog("  3. Choose a display name (e.g. 'My Roundhouse')");
+  textLog("  4. Choose a username ending in 'bot' (e.g. 'my_roundhouse_bot')");
+  textLog("  5. Copy the token BotFather returns");
+  textLog("");
+}

package/src/cli/setup/helpers.ts

@@ -0,0 +1,66 @@
+/**
+ * cli/setup/helpers.ts — Low-level utilities for setup flows
+ *
+ * Atomic file writes, safe exec wrappers, and other primitives
+ * shared by interactive and headless setup paths.
+ */
+
+import { writeFile, rename, unlink } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+
+/**
+ * Atomically write JSON to a file (write to tmp, rename).
+ */
+export async function atomicWriteJson(path: string, data: unknown): Promise<void> {
+  const tmp = `${path}.tmp.${randomBytes(4).toString("hex")}`;
+  try {
+    await writeFile(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+    await rename(tmp, path);
+  } catch (err) {
+    try { await unlink(tmp); } catch {}
+    throw err;
+  }
+}
+
+/**
+ * Atomically write text to a file (write to tmp, rename).
+ */
+export async function atomicWriteText(path: string, content: string, mode = 0o600): Promise<void> {
+  const tmp = `${path}.tmp.${randomBytes(4).toString("hex")}`;
+  try {
+    await writeFile(tmp, content, { mode });
+    await rename(tmp, path);
+  } catch (err) {
+    try { await unlink(tmp); } catch {}
+    throw err;
+  }
+}
+
+/**
+ * Execute a command, returning stdout or empty string on failure. Never throws.
+ */
+export function execSafe(cmd: string, args: string[], opts: { silent?: boolean; input?: string } = {}): string {
+  try {
+    const result = execFileSync(cmd, args, {
+      encoding: "utf8",
+      stdio: opts.silent ? "pipe" : opts.input ? ["pipe", "pipe", "pipe"] : "pipe",
+      input: opts.input,
+      timeout: 120_000,
+    });
+    return result.trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Execute a command, throwing a descriptive error on failure.
+ */
+export function execOrFail(cmd: string, args: string[], label: string): string {
+  try {
+    return execFileSync(cmd, args, { encoding: "utf8", stdio: "pipe", timeout: 120_000 }).trim();
+  } catch (err: any) {
+    throw new Error(`${label}: ${err.stderr?.trim() || err.message}`);
+  }
+}

package/src/cli/setup/index.ts

@@ -0,0 +1,7 @@
+/**
+ * cli/setup/index.ts — Barrel export for setup module
+ */
+
+export { atomicWriteJson, atomicWriteText, execSafe, execOrFail } from "./helpers";
+export { type SetupOptions, type StepStatus, PI_SETTINGS_PATH, DEFAULT_PROVIDER, DEFAULT_MODEL, EXTENSION_NAME_RE } from "./types";
+export { parseSetupArgs } from "./args";

package/src/cli/setup/runtime.ts

@@ -0,0 +1,109 @@
+import { dirname } from "node:path";
+import { readFile, mkdir } from "node:fs/promises";
+import { atomicWriteJson, execOrFail } from "./helpers";
+import { type SetupOptions, type StepLog, PI_SETTINGS_PATH } from "./types";
+import {
+  getAgentDefinition,
+  type AgentDefinition,
+  type AgentSetupContext,
+} from "../../agents/registry";
+import { type SetupLogger } from "../setup-logger";
+
+export function resolveAgentForSetup(opts: SetupOptions, logger: StepLog): AgentDefinition {
+  const agent = { ...getAgentDefinition(opts.agent) };
+
+  if (agent.type === "pi") {
+    agent.configure = async (ctx: AgentSetupContext) => {
+      let existing: Record<string, unknown> = {};
+      try {
+        existing = JSON.parse(await readFile(PI_SETTINGS_PATH, "utf8"));
+      } catch {}
+
+      const settings: Record<string, unknown> = { ...existing };
+
+      if (ctx.force) {
+        settings.defaultProvider = ctx.provider;
+        settings.defaultModel = ctx.model;
+      } else {
+        if (existing.defaultProvider && existing.defaultProvider !== ctx.provider) {
+          logger.warn(`Pi provider already set to '${existing.defaultProvider}' (keeping, use --force to override)`);
+        } else {
+          settings.defaultProvider = ctx.provider;
+        }
+        if (existing.defaultModel && existing.defaultModel !== ctx.model) {
+          logger.warn(`Pi model already set to '${existing.defaultModel}' (keeping, use --force to override)`);
+        } else {
+          settings.defaultModel = ctx.model;
+        }
+      }
+
+      if (!Array.isArray(settings.packages)) settings.packages = [];
+
+      const pkgs = settings.packages as string[];
+      const selfPkg = "npm:@inceptionstack/roundhouse";
+      const selfIdx = pkgs.indexOf(selfPkg);
+      if (selfIdx !== -1) pkgs.splice(selfIdx, 1);
+
+      const coreExtensions = [
+        "npm:@inceptionstack/pi-hard-no",
+        "npm:@inceptionstack/pi-branch-enforcer",
+      ];
+      for (const ext of coreExtensions) {
+        if (!pkgs.includes(ext)) pkgs.push(ext);
+      }
+
+      if (ctx.psst) {
+        const psstPkg = "npm:@miclivs/pi-psst";
+        if (!pkgs.includes(psstPkg)) pkgs.push(psstPkg);
+      }
+
+      await mkdir(dirname(PI_SETTINGS_PATH), { recursive: true });
+      await atomicWriteJson(PI_SETTINGS_PATH, settings);
+      logger.ok(`~/.pi/agent/settings.json (${settings.defaultProvider}, ${settings.defaultModel})`);
+    };
+
+    agent.installExtension = async (ext: string) => {
+      execOrFail("pi", ["install", `npm:${ext}`], `extension ${ext}`);
+    };
+  }
+
+  return agent;
+}
+
+export const textLog = (msg: string): void => { console.log(msg); };
+
+export const textStepLog: StepLog = {
+  log: textLog,
+  step(n, label) {
+    textLog(`\n${n} ${label}`);
+  },
+  ok(msg) {
+    textLog(`   ✓ ${msg}`);
+  },
+  warn(msg) {
+    textLog(`   ⚠ ${msg}`);
+  },
+  fail(msg) {
+    textLog(`   ✗ ${msg}`);
+  },
+};
+
+export function createStepLog(logger: SetupLogger): StepLog {
+  return {
+    log(msg) {
+      logger.info("log", msg);
+    },
+    step(n, label) {
+      logger.info("step", label, { stepLabel: n });
+    },
+    ok(msg) {
+      logger.ok(msg);
+    },
+    warn(msg) {
+      logger.warn("warn", msg);
+    },
+    fail(msg) {
+      logger.fail(msg);
+    },
+  };
+}