@inceptionstack/roundhouse 0.4.4 → 0.5.0

package/README.md

@@ -9,6 +9,8 @@ Multiple chat inputs (Telegram, Slack, Discord via [Vercel Chat SDK](https://cha
 
 ```bash
 npm install -g @inceptionstack/roundhouse
+roundhouse setup --telegram
+roundhouse start  # macOS (foreground) — Linux auto-starts via systemd
 ```
 
 ## Architecture
@@ -178,7 +180,7 @@ Without a config file, defaults are used with env vars (`TELEGRAM_BOT_TOKEN`, `B
 
 | Field | Description |
 |-------|-------------|
-| `agent.type` | Agent backend: `"pi"` (more coming) |
+| `agent.type` | Agent backend: `"pi"`, `"kiro"` |
 | `agent.cwd` | Working directory for the agent |
 | `agent.sessionDir` | Override session storage path |
 | `chat.botUsername` | Bot display name for Chat SDK |
@@ -492,7 +494,7 @@ No other changes needed — the gateway's unified handler covers all platforms.
 | `src/agents/base-adapter.ts` | Abstract base class — adapter interface contract |
 | `src/agents/registry.ts` | Agent type → factory registry |
 | `src/config.ts` | Shared config loading, defaults, env overrides |
-| `test/` | Unit tests (vitest, 75 passing) |
+| `test/` | Unit + integration tests (vitest, 311 passing) |
 
 ## CI/CD
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/pi/extensions/web-search.ts

@@ -46,6 +46,13 @@ export default function (pi: ExtensionAPI) {
           }),
           signal: controller.signal,
         });
+      } catch (err: any) {
+        clearTimeout(timeout);
+        const msg = err.name === "AbortError" ? "Request timed out (30s)" : `Network error: ${err.message}`;
+        return {
+          content: [{ type: "text", text: msg }],
+          details: { query: params.query, error: err.name },
+        };
       } finally {
         clearTimeout(timeout);
       }

package/src/agents/kiro/kiro-adapter.ts

@@ -13,6 +13,7 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type { AgentAdapterFactory, AgentMessage, AgentResponse, AgentStreamEvent, AdapterInfo } from "../../types.js";
+import { ROUNDHOUSE_VERSION } from "../../config.js";
 import { BaseAdapter } from "../base-adapter.js";
 import { spawnKiroCli, shutdownProcess, getKiroCliVersion, type AcpProcess, type InitializeResult, type SessionNewResult } from "./acp/index.js";
 import { SessionStore, type SessionEntry } from "./session.js";
@@ -188,7 +189,7 @@ class KiroAdapter extends BaseAdapter {
 
     await this.mainProcess.client.call<InitializeResult>("initialize", {
       protocolVersion: "1.0",
-      clientInfo: { name: "roundhouse", version: "0.4.3" },
+      clientInfo: { name: "roundhouse", version: ROUNDHOUSE_VERSION },
     });
 
     if (!this.reaperInterval) {

package/src/cli/cli.ts

@@ -5,17 +5,14 @@
  */
 
 import { resolve, dirname } from "node:path";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { readdirSync, statSync } from "node:fs";
 import { execSync, execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { performUpdate } from "../commands/update";
 
 import {
-  CONFIG_DIR,
   CONFIG_PATH,
-  ENV_FILE_PATH,
-  DEFAULT_CONFIG,
   SESSIONS_DIR,
   SERVICE_NAME,
   fileExists,
@@ -24,7 +21,7 @@ import {
 } from "../config";
 import { getAgentSdkPackage } from "../agents/registry";
 import { threadIdToDir } from "../util";
-import { parseEnvFile, serializeEnvFile, envQuote, unquoteEnvValue } from "./env-file";
+import { parseEnvFile, unquoteEnvValue } from "./env-file";
 import {
   SERVICE_PATH,
   systemctl,
@@ -32,9 +29,6 @@ import {
   isServiceInstalled,
   isServiceActive,
   systemctlShow,
-  resolveExecStart,
-  generateUnit,
-  writeServiceUnit,
 } from "./systemd";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -72,7 +66,12 @@ async function cmdStart() {
     return;
   }
 
-  // No systemd service — fall back to foreground
+  // No systemd service — fall back to foreground. Check config before launching.
+  if (!(await fileExists(CONFIG_PATH))) {
+    console.error("No config found. Run 'roundhouse setup --telegram' first.");
+    process.exit(1);
+  }
+
   console.log("No systemd service found. Running in foreground (use Ctrl+C to stop)...");
   if (process.platform !== "darwin") {
     console.log("  Tip: run 'roundhouse install' to set up the systemd daemon.\n");
@@ -83,6 +82,12 @@ async function cmdStart() {
 }
 
 async function cmdRun() {
+  // Guard: check config exists before launching gateway
+  if (!(await fileExists(CONFIG_PATH))) {
+    console.error("No config found. Run 'roundhouse setup --telegram' first.");
+    process.exit(1);
+  }
+
   process.env.ROUNDHOUSE_CONFIG = CONFIG_PATH;
 
   // Load .env file so secrets (TELEGRAM_BOT_TOKEN, etc.) are available
@@ -97,7 +102,11 @@ async function cmdRun() {
     const tsxPath = resolve(__dirname, "..", "..", "node_modules", "tsx", "dist", "cli.mjs");
     execFileSync(process.execPath, [tsxPath, indexPath], {
       stdio: "inherit",
-      env: { ...process.env, ROUNDHOUSE_CONFIG: CONFIG_PATH },
+      env: {
+        ...process.env,
+        ROUNDHOUSE_CONFIG: CONFIG_PATH,
+        NODE_NO_WARNINGS: "1",  // Suppress npm deprecation spam
+      },
     });
   }
 }
@@ -122,70 +131,23 @@ async function loadEnvFile(): Promise<void> {
 }
 
 async function cmdInstall() {
+  console.log("[roundhouse] 'install' is deprecated — use 'roundhouse setup --telegram' instead.\n");
+
   if (process.platform === "darwin") {
-    console.log("[roundhouse] macOS detected — systemd is not available.\n");
-    console.log("  On macOS, use 'roundhouse start' to run in foreground,");
-    console.log("  or set up a launchd plist manually.\n");
-    console.log("  Tip: run 'roundhouse setup --telegram' to configure first.");
+    console.log("  On macOS:");
+    console.log("    1. roundhouse setup --telegram");
+    console.log("    2. roundhouse start\n");
     process.exitCode = 1;
     return;
   }
 
-  console.log("[roundhouse] Installing as systemd daemon...\n");
-
-  await mkdir(CONFIG_DIR, { recursive: true });
-  if (await fileExists(CONFIG_PATH)) {
-    console.log(`  Config exists: ${CONFIG_PATH}`);
-  } else {
-    await writeFile(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
-    console.log(`  Created config: ${CONFIG_PATH}`);
-    console.log(`  ⚠️  Edit this file to set allowedUsers and other settings.`);
-  }
-
-  // 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 resolvedEnvPath = await resolveEnvFilePath();
-  const existing = await fileExists(resolvedEnvPath)
-    ? parseEnvFile(await readFile(resolvedEnvPath, "utf8"))
-    : new Map<string, string>();
-
-  // Override with current env vars for known keys
-  let envChanged = false;
-  for (const key of ENV_KEYS) {
-    if (process.env[key]) {
-      existing.set(key, envQuote(process.env[key]));
-      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}`);
-    }
-    await writeFile(ENV_FILE_PATH, serializeEnvFile(existing), { mode: 0o600 });
-    console.log(`  Environment file: ${ENV_FILE_PATH}`);
-  }
-
-  // Generate and install systemd unit
-  const { execStart, nodeBinDir } = resolveExecStart();
-  const unit = generateUnit({ execStart, nodeBinDir });
-  await writeServiceUnit(unit);
-  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`);
-  }
+  console.log("  Recommended:");
+  console.log("    roundhouse setup --telegram\n");
+  console.log("  This sets up config, installs packages, pairs Telegram,");
+  console.log("  and installs the systemd service — all in one command.\n");
 }
-
 async function cmdUninstall() {
+
   console.log("[roundhouse] Removing systemd daemon...");
   try { systemctl("stop"); } catch {}
   try { systemctl("disable"); } catch {}

package/src/cli/detect.ts

@@ -0,0 +1,157 @@
+/**
+ * detect.ts — Agent environment detection for setup wizard
+ *
+ * Detects which agent backends are available on the system
+ * so setup can skip unnecessary installs and offer smart defaults.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { whichSync } from "./systemd";
+
+// ── Types ────────────────────────────────────────────
+
+export interface DetectedAgent {
+  type: "pi" | "kiro" | "openclaw";
+  binary: string | null;       // Path to binary (null if not found)
+  version: string | null;      // Version string (null if couldn't determine)
+  configured: boolean;         // Has config/settings present
+  details: Record<string, string>;  // Extra info (provider, model, etc.)
+}
+
+export interface DetectedEnvironment {
+  agents: DetectedAgent[];
+  recommended: "pi" | "kiro" | "openclaw" | null;
+}
+
+// ── Detection ────────────────────────────────────────
+
+function detectPi(): DetectedAgent | null {
+  const binary = whichSync("pi");
+  if (!binary) return null;
+
+  let version: string | null = null;
+  try {
+    
+    version = execFileSync("pi", ["--version"], { encoding: "utf8", timeout: 5000 }).trim();
+  } catch {}
+
+  const settingsPath = resolve(homedir(), ".pi", "agent", "settings.json");
+  let configured = false;
+  const details: Record<string, string> = {};
+
+  if (existsSync(settingsPath)) {
+    configured = true;
+    try {
+      const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+      if (settings.defaultProvider) details.provider = settings.defaultProvider;
+      if (settings.defaultModel) details.model = settings.defaultModel;
+    } catch {}
+  }
+
+  return { type: "pi", binary, version, configured, details };
+}
+
+function detectKiro(): DetectedAgent | null {
+  const binary = whichSync("kiro-cli");
+  if (!binary) return null;
+
+  let version: string | null = null;
+  try {
+    
+    version = execFileSync("kiro-cli", ["--version"], { encoding: "utf8", timeout: 5000 }).trim();
+  } catch {}
+
+  // Check for kiro config directory
+  const configDir = resolve(homedir(), ".kiro");
+  const configured = existsSync(configDir);
+  return { type: "kiro", binary, version, configured, details: {} };
+}
+
+function detectOpenClaw(): DetectedAgent | null {
+  const binary = whichSync("oc");
+  if (!binary) return null;
+
+  let version: string | null = null;
+  try {
+    
+    version = execFileSync("oc", ["--version"], { encoding: "utf8", timeout: 5000 }).trim();
+  } catch {}
+
+  const configPath = resolve(homedir(), ".openclaw", "openclaw.json");
+  let configured = false;
+  const details: Record<string, string> = {};
+
+  if (existsSync(configPath)) {
+    configured = true;
+    // Check if gateway is configured
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      if (config.gateway?.port) details.port = String(config.gateway.port);
+    } catch {}
+  }
+
+  return { type: "openclaw", binary, version, configured, details };
+}
+
+// ── Public API ───────────────────────────────────────
+
+/**
+ * Detect which agent backends are available on the system.
+ * Returns all detected agents and a recommended default.
+ */
+export function detectEnvironment(): DetectedEnvironment {
+  const agents: DetectedAgent[] = [];
+
+  const pi = detectPi();
+  if (pi) agents.push(pi);
+
+  const kiro = detectKiro();
+  if (kiro) agents.push(kiro);
+
+  const oc = detectOpenClaw();
+  if (oc) agents.push(oc);
+
+  // Recommendation: prefer configured agent, then Pi as default
+  let recommended: DetectedEnvironment["recommended"] = null;
+  const configured = agents.filter(a => a.configured);
+  if (configured.length === 1) {
+    recommended = configured[0].type;
+  } else if (configured.length > 1) {
+    // Multiple configured — prefer Pi (most common for roundhouse)
+    recommended = configured.find(a => a.type === "pi")?.type ?? configured[0].type;
+  } else if (agents.length === 1) {
+    recommended = agents[0].type;
+  }
+
+  return { agents, recommended };
+}
+
+/**
+ * Format detection results for display in setup output.
+ */
+export function formatDetectionResults(env: DetectedEnvironment): string[] {
+  const lines: string[] = [];
+
+  if (env.agents.length === 0) {
+    lines.push("No agent backends detected (will install Pi)");
+    return lines;
+  }
+
+  for (const agent of env.agents) {
+    const ver = agent.version ? ` (${agent.version})` : "";
+    const status = agent.configured ? "configured" : "found";
+    let line = `${agent.type}${ver} — ${status}`;
+    if (agent.details.provider) line += ` [${agent.details.provider}]`;
+    if (agent.details.model) line += ` [${agent.details.model}]`;
+    lines.push(line);
+  }
+
+  if (env.recommended) {
+    lines.push(`→ Using: ${env.recommended}`);
+  }
+
+  return lines;
+}

package/src/cli/setup.ts

@@ -58,6 +58,7 @@ import {
   writePendingPairing,
   type PendingPairing,
 } from "../pairing";
+import { detectEnvironment, formatDetectionResults } from "./detect";
 
 // ── Types ────────────────────────────────────────────
 
@@ -83,6 +84,8 @@ interface SetupOptions {
   qr: "auto" | "always" | "never";
   /** Agent type (default: pi) */
   agent: string;
+  /** Set by detection: skip agent package install if already configured */
+  _skipAgentInstall?: boolean;
 }
 
 type StepStatus = "ok" | "warn" | "skip" | "fail";
@@ -231,7 +234,7 @@ export function parseSetupArgs(argv: string[]): SetupOptions {
     cwd: homedir(),
     notifyChatIds: [],
     systemd: platform() === "linux",
-    voice: true,
+    voice: platform() === "linux",  // Default off on macOS (whisper install is heavy)
     psst: false,
     nonInteractive: false,
     force: false,
@@ -443,7 +446,7 @@ async function stepValidateToken(opts: SetupOptions): Promise<BotInfo> {
 }
 
 async function stepStopGateway(): Promise<void> {
-  step("③", "Checking for running gateway...");
+  step("④", "Checking for running gateway...");
 
   if (platform() !== "linux") {
     ok("Not Linux — skipping service check");
@@ -464,7 +467,7 @@ async function stepStopGateway(): Promise<void> {
 }
 
 async function stepInstallPackages(opts: SetupOptions, agent: AgentDefinition): Promise<void> {
-  step("④", "Installing packages...");
+  step("⑤", "Installing packages...");
 
   // Roundhouse
   const rhInstalled = whichSync("roundhouse");
@@ -477,18 +480,22 @@ async function stepInstallPackages(opts: SetupOptions, agent: AgentDefinition):
   }
 
   // Agent packages (driven by agent definition)
-  for (const pkg of agent.packages) {
-    const label = pkg.name ?? pkg.packageName;
-    const installed = pkg.binary ? whichSync(pkg.binary) : false;
-    if (installed && !opts.force) {
-      ok(`${label} (already installed)`);
-    } else {
-      log(`   Installing ${label}...`);
-      const args = pkg.install === "global"
-        ? ["install", "-g", pkg.packageName]
-        : ["install", pkg.packageName];
-      execOrFail("npm", args, `${label} install`);
-      ok(label);
+  if (opts._skipAgentInstall) {
+    ok("Agent already configured — skipping package install");
+  } else {
+    for (const pkg of agent.packages) {
+      const label = pkg.name ?? pkg.packageName;
+      const installed = pkg.binary ? whichSync(pkg.binary) : false;
+      if (installed && !opts.force) {
+        ok(`${label} (already installed)`);
+      } else {
+        log(`   Installing ${label}...`);
+        const args = pkg.install === "global"
+          ? ["install", "-g", pkg.packageName]
+          : ["install", pkg.packageName];
+        execOrFail("npm", args, `${label} install`);
+        ok(label);
+      }
     }
   }
 
@@ -596,12 +603,12 @@ async function stepInstallPackages(opts: SetupOptions, agent: AgentDefinition):
 
 async function stepStoreSecrets(opts: SetupOptions, botInfo: BotInfo): Promise<void> {
   if (!opts.psst) {
-    step("⑥", "Storing secrets...");
+    step("⑧", "Storing secrets...");
     ok("Skipped (default — use --with-psst to enable)");
     return;
   }
 
-  step("⑥", "Storing secrets in psst...");
+  step("⑧", "Storing secrets in psst...");
 
   const secrets: [string, string][] = [
     ["TELEGRAM_BOT_TOKEN", opts.botToken],
@@ -640,7 +647,7 @@ async function stepStoreSecrets(opts: SetupOptions, botInfo: BotInfo): Promise<v
 // ── Bundle install ──────────────────────────────────────────────────
 
 async function stepInstallBundle(opts: SetupOptions): Promise<void> {
-  step("⑥b", "Installing bundle (skills + CLI tools)...");
+  step("⑥", "Installing bundle (skills + CLI tools)...");
 
   const bundleLog: ProvisionLog = {
     info: (msg) => log(`   ${msg}`),
@@ -657,7 +664,7 @@ async function stepConfigure(
   pairResult: PairResult | null,
   agent: AgentDefinition,
 ): Promise<void> {
-  step("⑦", "Configuring...");
+  step("⑨", "Configuring...");
 
   await mkdir(ROUNDHOUSE_DIR, { recursive: true });
 
@@ -766,7 +773,7 @@ async function stepConfigure(
 }
 
 async function stepPair(opts: SetupOptions, botInfo: BotInfo): Promise<PairResult | null> {
-  step("⑤", "Pairing with Telegram...");
+  step("⑦", "Pairing with Telegram...");
 
   // Skip if chat IDs already known
   if (opts.notifyChatIds.length > 0) {
@@ -822,13 +829,13 @@ async function stepPair(opts: SetupOptions, botInfo: BotInfo): Promise<PairResul
 }
 
 async function stepRegisterCommands(opts: SetupOptions): Promise<void> {
-  step("⑧", "Registering bot commands...");
+  step("⑩", "Registering bot commands...");
   await registerBotCommands(opts.botToken);
   ok(`${BOT_COMMANDS.length} commands registered with Telegram`);
 }
 
 async function stepInstallSystemd(opts: SetupOptions): Promise<void> {
-  step("⑨", "Installing systemd service...");
+  step("⑩b", "Installing systemd service...");
 
   if (!opts.systemd) {
     ok("Skipped (--no-systemd)");
@@ -873,7 +880,7 @@ async function stepInstallSystemd(opts: SetupOptions): Promise<void> {
 }
 
 async function stepPostflight(): Promise<void> {
-  step("⑩", "Postflight checks...");
+  step("⑪", "Postflight checks...");
 
   if (platform() === "linux") {
     if (isServiceActive()) {
@@ -894,6 +901,21 @@ async function stepPostflight(): Promise<void> {
   if (!whichSync("ffmpeg")) {
     warn("ffmpeg not found (install for voice support)");
   }
+
+  // Whisper STT check (only if voice is enabled)
+  if (platform() === "linux" || process.env.ROUNDHOUSE_VOICE === "1") {
+    if (!whichSync("whisper")) {
+      warn("whisper not found — STT will auto-install on first voice message");
+      log("    Pre-install: pip3 install openai-whisper");
+    } else {
+      ok("whisper available");
+    }
+  }
+
+  if (!process.env.TAVILY_API_KEY) {
+    warn("TAVILY_API_KEY not set — web search extension won't work");
+    log("    Get a free key at https://tavily.com and add to ~/.roundhouse/.env");
+  }
 }
 
 // ── BotFather Guide ──────────────────────────────────
@@ -921,6 +943,23 @@ async function runInteractiveTelegramSetup(opts: SetupOptions): Promise<void> {
     // Step 1: Preflight
     await stepPreflight(opts, agent);
 
+    // Detect existing agent installations
+    const env = detectEnvironment();
+    if (env.agents.length > 0) {
+      log("");
+      log("  🔍 Agent detection:");
+      for (const line of formatDetectionResults(env)) {
+        ok(line);
+      }
+      // If the selected agent is already configured, skip package install
+      if (!opts.force) {
+        const selected = env.agents.find(a => a.type === opts.agent);
+        if (selected?.configured) {
+          opts._skipAgentInstall = true;
+        }
+      }
+    }
+
     // Step 2: Get bot token (prompt if not provided)
     if (!opts.botToken) {
       log("");
@@ -951,11 +990,11 @@ async function runInteractiveTelegramSetup(opts: SetupOptions): Promise<void> {
     // Step 5: Install packages
     await stepInstallPackages(opts, agent);
 
-    // Step 5b: Install bundle (skills + CLI tools)
+    // Step 6: Install bundle (skills + CLI tools)
     await stepInstallBundle(opts);
 
-    // Step 6: Pair via Telegram
-    step("⑥", "Pairing with Telegram...");
+    // Step 7: Pair via Telegram
+    step("⑦", "Pairing with Telegram...");
     const nonce = createPairingNonce();
     const pairingLink = createPairingLink(botInfo.username, nonce);
     log(`\n  Open this link to pair:\n`);
@@ -964,6 +1003,16 @@ async function runInteractiveTelegramSetup(opts: SetupOptions): Promise<void> {
     log(`  Or send /start ${nonce} to @${botInfo.username}`);
     log("");
 
+    // Auto-open the pairing link on macOS
+    if (process.platform === "darwin") {
+      try {
+        execFileSync("open", [pairingLink], { stdio: "ignore" });
+        log("  (Opened in Telegram — switch to the app to complete pairing)");
+      } catch { /* ignore if open fails */ }
+    }
+
+    log("  Waiting for you to tap the link in Telegram...");
+
     const pairResult = await pairTelegram(
       opts.botToken, botInfo.username, opts.users,
       300_000, log, { nonce, showLink: false },
@@ -977,17 +1026,17 @@ async function runInteractiveTelegramSetup(opts: SetupOptions): Promise<void> {
       }
     }
 
-    // Step 7: Store secrets
+    // Step 8: Store secrets
     await stepStoreSecrets(opts, botInfo);
 
-    // Step 8: Write config
+    // Step 9: Write config
     await stepConfigure(opts, botInfo, pairResult, agent);
 
-    // Step 9: Register commands + install service
+    // Step 10: Register commands + install service
     await stepRegisterCommands(opts);
     await stepInstallSystemd(opts);
 
-    // Step 10: Verify
+    // Step 11: Verify
     await stepPostflight();
 
     // Done!

package/src/config.ts

@@ -8,8 +8,21 @@
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { readFile, access } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { GatewayConfig } from "./types";
 
+// ── Version ──────────────────────────────────────────
+
+const __configDir = dirname(fileURLToPath(import.meta.url));
+
+/** Roundhouse package version (read from package.json at startup) */
+export const ROUNDHOUSE_VERSION: string = (() => {
+  try { return JSON.parse(readFileSync(join(__configDir, "..", "package.json"), "utf8")).version; }
+  catch { return "unknown"; }
+})();
+
 // ── Path constants ───────────────────────────────────
 
 /** New canonical config root */

package/src/gateway.ts

@@ -13,7 +13,7 @@ import { isTelegramThread, postTelegramHtml, handleTelegramHtmlStream } from "./
 import { SttService, enrichAttachmentsWithTranscripts, DEFAULT_STT_CONFIG } from "./voice/stt-service";
 import { sendTelegramToMany } from "./notify/telegram";
 import { runDoctor, formatDoctorTelegram, createDoctorContext } from "./cli/doctor/runner";
-import { ROUNDHOUSE_DIR } from "./config";
+import { ROUNDHOUSE_DIR, ROUNDHOUSE_VERSION } from "./config";
 import { CronSchedulerService } from "./cron/scheduler";
 import { isBuiltinJob } from "./cron/helpers";
 import { formatSchedule, formatRunCounts, jobEnabledIcon } from "./cron/format";
@@ -65,10 +65,6 @@ import { join, dirname, basename } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __gatewayDir = dirname(fileURLToPath(import.meta.url));
-const ROUNDHOUSE_VERSION: string = (() => {
-  try { return JSON.parse(readFileSync(join(__gatewayDir, "..", "package.json"), "utf8")).version; }
-  catch { return "unknown"; }
-})();
 
 function telegramChatIdFromThreadId(threadId: unknown): number | null {
   if (typeof threadId !== "string") return null;