@inceptionstack/roundhouse 0.5.2 → 0.5.4

package/src/cli/service-manager.ts

@@ -0,0 +1,192 @@
+/**
+ * cli/service-manager.ts — Platform-specific service lifecycle management
+ *
+ * Abstracts the difference between macOS (launchd) and Linux (systemd)
+ * behind a single interface. CLI commands delegate to getServiceManager()
+ * instead of branching on process.platform in every function.
+ */
+
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { SERVICE_NAME } from "../config";
+
+// ── Interface ────────────────────────────────────────
+
+export interface ServiceStatus {
+  running: boolean;
+  installed: boolean;
+  message: string;
+}
+
+export interface ServiceManager {
+  /** Start the service (load agent / start daemon) */
+  start(): Promise<{ started: boolean; message: string }>;
+  /** Stop the service */
+  stop(): Promise<{ message: string }>;
+  /** Restart the service (stop + start) */
+  restart(): Promise<{ message: string }>;
+  /** Get current service status */
+  status(): Promise<ServiceStatus>;
+  /** Tail logs (spawns a child process, returns it) */
+  logs(): void;
+  /** Uninstall the service (remove plist / unit file) */
+  uninstall(): Promise<{ message: string }>;
+}
+
+// ── LaunchdManager (macOS) ───────────────────────────
+
+class LaunchdManager implements ServiceManager {
+  private get plistPath(): string {
+    return resolve(homedir(), "Library", "LaunchAgents", "com.inceptionstack.roundhouse.plist");
+  }
+
+  private get label(): string {
+    return "com.inceptionstack.roundhouse";
+  }
+
+  private isInstalled(): boolean {
+    return existsSync(this.plistPath);
+  }
+
+  private isRunning(): boolean {
+    try {
+      const output = execFileSync("launchctl", ["list", this.label], { encoding: "utf8", stdio: "pipe" });
+      return output.includes(this.label);
+    } catch {
+      return false;
+    }
+  }
+
+  async start(): Promise<{ started: boolean; message: string }> {
+    if (!this.isInstalled()) {
+      return { started: false, message: "no-service" };
+    }
+    if (this.isRunning()) {
+      return { started: false, message: "Roundhouse is already running (LaunchAgent)." };
+    }
+    try {
+      execFileSync("launchctl", ["load", this.plistPath], { stdio: "pipe" });
+      return { started: true, message: "LaunchAgent started." };
+    } catch {
+      return { started: false, message: "Failed to load LaunchAgent." };
+    }
+  }
+
+  async stop(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed. Nothing to stop." };
+    }
+    try {
+      execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" });
+    } catch (e: any) {
+      if (!e.message?.includes("Could not find")) {
+        return { message: `(unload warning: ${e.message?.split("\n")[0]})` };
+      }
+    }
+    return { message: "LaunchAgent stopped." };
+  }
+
+  async restart(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed. Run: roundhouse setup --telegram" };
+    }
+    try { execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" }); } catch {}
+    execFileSync("launchctl", ["load", this.plistPath], { stdio: "pipe" });
+    return { message: "LaunchAgent restarted." };
+  }
+
+  async status(): Promise<ServiceStatus> {
+    if (this.isRunning()) {
+      return { running: true, installed: true, message: "Roundhouse is running (LaunchAgent)." };
+    }
+    if (this.isInstalled()) {
+      return { running: false, installed: true, message: "LaunchAgent installed but not running." };
+    }
+    return { running: false, installed: false, message: "Roundhouse is not running." };
+  }
+
+  logs(): void {
+    const logPath = resolve(homedir(), ".roundhouse", "logs", "roundhouse.log");
+    const child = spawn("tail", ["-f", "-n", "100", logPath], { stdio: "inherit" });
+    child.on("error", () => console.log("Could not read logs. Check ~/.roundhouse/logs/"));
+  }
+
+  async uninstall(): Promise<{ message: string }> {
+    if (!this.isInstalled()) {
+      return { message: "No LaunchAgent installed." };
+    }
+    try { execFileSync("launchctl", ["unload", this.plistPath], { stdio: "pipe" }); } catch {}
+    const { unlink } = await import("node:fs/promises");
+    try { await unlink(this.plistPath); } catch {}
+    return { message: "LaunchAgent removed." };
+  }
+}
+
+// ── SystemdManager (Linux) ───────────────────────────
+
+class SystemdManager implements ServiceManager {
+  async start(): Promise<{ started: boolean; message: string }> {
+    const { isServiceInstalled, isServiceActive, systemctl } = await import("./systemd");
+    if (!isServiceInstalled()) {
+      return { started: false, message: "no-service" }; // Signal to caller: fall through to foreground
+    }
+    if (isServiceActive()) {
+      return { started: false, message: "Roundhouse is already running." };
+    }
+    systemctl("start", "Daemon started.");
+    return { started: true, message: "Daemon started." };
+  }
+
+  async stop(): Promise<{ message: string }> {
+    const { systemctl } = await import("./systemd");
+    systemctl("stop", "Daemon stopped.");
+    return { message: "Daemon stopped." };
+  }
+
+  async restart(): Promise<{ message: string }> {
+    const { systemctl } = await import("./systemd");
+    systemctl("restart", "Daemon restarted.");
+    return { message: "Daemon restarted." };
+  }
+
+  async status(): Promise<ServiceStatus> {
+    const { isServiceActive, isServiceInstalled } = await import("./systemd");
+    if (isServiceActive()) {
+      return { running: true, installed: true, message: "Roundhouse is running." };
+    }
+    if (isServiceInstalled()) {
+      return { running: false, installed: true, message: "Service installed but not running." };
+    }
+    return { running: false, installed: false, message: "Roundhouse is not running." };
+  }
+
+  logs(): void {
+    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?"));
+  }
+
+  async uninstall(): Promise<{ message: string }> {
+    const { systemctl, runSudo, SERVICE_PATH } = await import("./systemd");
+    try { systemctl("stop"); } catch {}
+    try { systemctl("disable"); } catch {}
+    try { runSudo("rm", "-f", SERVICE_PATH); } catch {}
+    runSudo("systemctl", "daemon-reload");
+    return { message: "Daemon removed." };
+  }
+}
+
+// ── Factory ──────────────────────────────────────────
+
+/**
+ * Get the appropriate service manager for the current platform.
+ */
+export function getServiceManager(): ServiceManager {
+  if (process.platform === "darwin") {
+    return new LaunchdManager();
+  }
+  return new SystemdManager();
+}

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";