@inceptionstack/roundhouse 0.4.5 → 0.5.1

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

package/package.json

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

package/pi/extensions/web-search.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
 
 export default function (pi: ExtensionAPI) {
   pi.registerTool({

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);
@@ -80,7 +74,7 @@ async function cmdStart() {
 
   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");
+    console.log("  Tip: run 'roundhouse setup --telegram' to install as systemd daemon.\n");
   } else {
     console.log("");
   }
@@ -108,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
+      },
     });
   }
 }
@@ -133,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 {}
@@ -215,19 +166,23 @@ async function cmdUpdate() {
   }
 
   console.log(`[roundhouse] Updated to v${result.latestVersion}`);
-  console.log("\n[roundhouse] Restarting daemon...");
-  try {
-    systemctl("restart", "Updated and restarted.");
-  } catch {
-    console.log("  ⚠️  Daemon not running. Start with: roundhouse install");
+
+  if (process.platform === "darwin" || !isServiceInstalled()) {
+    console.log("\n  ✅ Update complete. Restart with: roundhouse start");
+  } else {
+    console.log("\n[roundhouse] Restarting daemon...");
+    try {
+      systemctl("restart", "Updated and restarted.");
+    } catch {
+      console.log("  ⚠️  Could not restart. Run: roundhouse start");
+    }
   }
 }
 
 async function cmdStatus() {
   if (!isServiceActive()) {
     console.log("\n  ❌ Roundhouse is not running.\n");
-    console.log("  Install with: roundhouse install");
-    console.log("  Or start foreground: roundhouse start\n");
+    console.log("  Start with: roundhouse start\n");
     return;
   }
 

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/doctor/checks/config.ts

@@ -47,7 +47,7 @@ export const configChecks: DoctorCheck[] = [
           details: [`${ctx.configPath} does not exist`],
           fix: {
             description: "Create default config",
-            command: `roundhouse install`,
+            command: `roundhouse setup --telegram`,
             run: async () => {
               const configDir = dirname(ctx.configPath);
               await mkdir(configDir, { recursive: true });

package/src/cli/doctor/checks/systemd.ts

@@ -23,7 +23,7 @@ export const systemdChecks: DoctorCheck[] = [
         id: "systemd-unit", category: "systemd", name: "Service unit",
         status: result ? "pass" : "warn",
         summary: result ? "installed" : "not installed",
-        details: !result ? ["Run: roundhouse install"] : undefined,
+        details: !result ? ["Run: roundhouse setup --telegram"] : undefined,
       };
     },
   },

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,
@@ -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);
+      }
     }
   }
 
@@ -846,7 +853,7 @@ async function stepInstallSystemd(opts: SetupOptions): Promise<void> {
   if (!hasSudoAccess()) {
     warn("No passwordless sudo — cannot install systemd service");
     log("   Run manually: roundhouse start");
-    log("   Or install with: sudo roundhouse install");
+    log("   Or install with: roundhouse setup --telegram");
     return;
   }
 
@@ -895,6 +902,16 @@ async function stepPostflight(): Promise<void> {
     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");
@@ -926,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("");