@inceptionstack/roundhouse 0.4.3 → 0.4.5

package/src/bundle.ts

@@ -7,7 +7,7 @@
 
 import { homedir } from "node:os";
 import { resolve, dirname } from "node:path";
-import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync } from "node:fs";
+import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, copyFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
@@ -192,14 +192,54 @@ export function provisionBundle(opts: ProvisionOpts = {}): void {
   provisionPlaywright(opts);
   provisionUvx(opts);
   provisionMcporterConfig(opts);
+  provisionExtensionFiles(opts);
   provisionExtensions(opts);
 }
 
+/**
+ * Copy shipped extension files to ~/.pi/agent/extensions/ if not already present.
+ * Does NOT overwrite existing files — user's version always wins.
+ */
+export function provisionExtensionFiles(opts: ProvisionOpts = {}): void {
+  const { log = consoleLog } = opts;
+  const shippedDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "pi", "extensions");
+  const targetDir = resolve(homedir(), ".pi", "agent", "extensions");
+
+  try {
+    if (!existsSync(shippedDir)) return;
+    const files = readdirSync(shippedDir).filter(f => f.endsWith(".ts"));
+    if (files.length === 0) return;
+
+    mkdirSync(targetDir, { recursive: true });
+
+    let installed = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const target = resolve(targetDir, file);
+      if (existsSync(target)) {
+        skipped++;
+      } else {
+        copyFileSync(resolve(shippedDir, file), target);
+        installed++;
+      }
+    }
+
+    if (installed > 0) {
+      log.ok(`${installed} extension(s) installed to ~/.pi/agent/extensions/`);
+    }
+    if (skipped > 0 && installed === 0) {
+      log.ok(`extensions (${skipped} already present, not overwritten)`);
+    }
+  } catch (err: any) {
+    log.warn(`extension file provisioning failed: ${err.message}`);
+  }
+}
+
 /**
  * Ensure core extensions are listed in ~/.pi/agent/settings.json packages array.
  */
 export function provisionExtensions(opts: ProvisionOpts = {}): void {
-  const { log = defaultLog } = opts;
+  const { log = consoleLog } = opts;
   const settingsPath = resolve(homedir(), ".pi", "agent", "settings.json");
 
   const coreExtensions = [

package/src/cli/cli.ts

@@ -24,7 +24,7 @@ import {
 } from "../config";
 import { getAgentSdkPackage } from "../agents/registry";
 import { threadIdToDir } from "../util";
-import { parseEnvFile, serializeEnvFile, envQuote } from "./env-file";
+import { parseEnvFile, serializeEnvFile, envQuote, unquoteEnvValue } from "./env-file";
 import {
   SERVICE_PATH,
   systemctl,
@@ -72,14 +72,33 @@ 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)...");
-  console.log("  Tip: run 'roundhouse install' to set up the systemd daemon.\n");
+  if (process.platform !== "darwin") {
+    console.log("  Tip: run 'roundhouse install' to set up the systemd daemon.\n");
+  } else {
+    console.log("");
+  }
   await cmdRun();
 }
 
 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
+  await loadEnvFile();
+
   const indexPath = resolve(__dirname, "..", "index.ts");
   const jsPath = resolve(__dirname, "..", "dist", "index.js");
 
@@ -94,7 +113,35 @@ async function cmdRun() {
   }
 }
 
+/**
+ * Load the roundhouse .env file into process.env.
+ * Does NOT override existing env vars (explicit env takes precedence).
+ */
+async function loadEnvFile(): Promise<void> {
+  const envPath = await resolveEnvFilePath();
+  if (!(await fileExists(envPath))) return;
+  try {
+    const entries = parseEnvFile(await readFile(envPath, "utf8"));
+    for (const [key, raw] of entries) {
+      if (!process.env[key]) {
+        process.env[key] = unquoteEnvValue(raw);
+      }
+    }
+  } catch (e: any) {
+    console.warn(`[roundhouse] warning: failed to load ${envPath}: ${e.message}`);
+  }
+}
+
 async function cmdInstall() {
+  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.");
+    process.exitCode = 1;
+    return;
+  }
+
   console.log("[roundhouse] Installing as systemd daemon...\n");
 
   await mkdir(CONFIG_DIR, { recursive: true });

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

@@ -4,7 +4,7 @@
  */
 
 import { readFile } from "node:fs/promises";
-import { parseEnvFile } from "../../env-file";
+import { parseEnvFile, unquoteEnvValue } from "../../env-file";
 import type { DoctorCheck, DoctorContext } from "../types";
 
 /**
@@ -17,7 +17,7 @@ export async function resolveToken(ctx: DoctorContext): Promise<string | null> {
     try {
       const entries = parseEnvFile(await readFile(ctx.envFilePath, "utf8"));
       const raw = entries.get("TELEGRAM_BOT_TOKEN");
-      if (raw) token = raw.replace(/^["']|["']$/g, "");
+      if (raw) token = unquoteEnvValue(raw);
     } catch {}
   }
   return token || null;

package/src/cli/env-file.ts

@@ -38,3 +38,28 @@ export function envQuote(value: string): string {
     .replace(/\n/g, "\\n");
   return `"${escaped}"`;
 }
+
+/**
+ * Reverse of envQuote: strip surrounding quotes and unescape interior sequences.
+ */
+export function unquoteEnvValue(raw: string): string {
+  // Strip surrounding double quotes (only if matched pair)
+  let value = raw;
+  if (value.startsWith('"') && value.endsWith('"')) {
+    value = value.slice(1, -1);
+  } else if (value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  // Single-pass unescape to handle \\ correctly (avoids double-replacement)
+  value = value.replace(/\\([\\"$`n])/g, (_match, ch) => {
+    switch (ch) {
+      case "n": return "\n";
+      case "\\": return "\\";
+      case '"': return '"';
+      case "$": return "$";
+      case "`": return "`";
+      default: return ch;
+    }
+  });
+  return value;
+}

package/src/cli/setup.ts

@@ -22,7 +22,7 @@ import {
   ENV_FILE_PATH as ENV_PATH,
   fileExists,
 } from "../config";
-import { envQuote, parseEnvFile } from "./env-file";
+import { envQuote, parseEnvFile, unquoteEnvValue } from "./env-file";
 import {
   whichSync,
   systemctl,
@@ -132,10 +132,12 @@ function resolveAgentForSetup(opts: SetupOptions): AgentDefinition {
       // Ensure packages array exists
       if (!Array.isArray(settings.packages)) settings.packages = [];
 
-      // Add roundhouse itself (ships extensions via pi.extensions in package.json)
-      const selfPkg = "npm:@inceptionstack/roundhouse";
       const pkgs = settings.packages as string[];
-      if (!pkgs.includes(selfPkg)) pkgs.push(selfPkg);
+
+      // Remove stale self-reference (roundhouse no longer ships pi extensions)
+      const selfPkg = "npm:@inceptionstack/roundhouse";
+      const selfIdx = pkgs.indexOf(selfPkg);
+      if (selfIdx !== -1) pkgs.splice(selfIdx, 1);
 
       // Add code review + branch protection extensions
       const coreExtensions = [
@@ -441,7 +443,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");
@@ -462,7 +464,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");
@@ -594,12 +596,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],
@@ -638,7 +640,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}`),
@@ -655,7 +657,7 @@ async function stepConfigure(
   pairResult: PairResult | null,
   agent: AgentDefinition,
 ): Promise<void> {
-  step("⑦", "Configuring...");
+  step("⑨", "Configuring...");
 
   await mkdir(ROUNDHOUSE_DIR, { recursive: true });
 
@@ -764,7 +766,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) {
@@ -820,13 +822,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)");
@@ -871,7 +873,7 @@ async function stepInstallSystemd(opts: SetupOptions): Promise<void> {
 }
 
 async function stepPostflight(): Promise<void> {
-  step("⑩", "Postflight checks...");
+  step("⑪", "Postflight checks...");
 
   if (platform() === "linux") {
     if (isServiceActive()) {
@@ -892,6 +894,11 @@ async function stepPostflight(): Promise<void> {
   if (!whichSync("ffmpeg")) {
     warn("ffmpeg not found (install for voice support)");
   }
+
+  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 ──────────────────────────────────
@@ -949,11 +956,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`);
@@ -962,6 +969,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 },
@@ -975,17 +992,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!
@@ -1255,7 +1272,7 @@ export async function cmdPair(argv: string[]): Promise<void> {
     try {
       const entries = parseEnvFile(await readFile(ENV_PATH, "utf8"));
       const raw = entries.get("TELEGRAM_BOT_TOKEN");
-      if (raw) token = raw.replace(/^["']|["']$/g, "");
+      if (raw) token = unquoteEnvValue(raw);
     } catch {}
   }
 

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;

package/src/types.ts

@@ -45,41 +45,87 @@ export type AgentStreamEvent =
   | { type: "agent_end" }
   | { type: "custom_message"; customType: string; content: string };
 
+// ── AdapterInfo ──────────────────────────────────────
+
+/**
+ * Information returned by getInfo(). All fields optional.
+ * Consumers (gateway /status, memory lifecycle) read these keys.
+ */
+export interface AdapterInfo {
+  /** Agent SDK/CLI version string */
+  version?: string;
+  /** Currently active model identifier */
+  model?: string;
+  /** Working directory the agent operates in */
+  cwd?: string;
+  /** Number of active sessions managed by this adapter */
+  activeSessions?: number;
+
+  // ── Context usage (drives memory pressure detection) ─
+
+  /** Current token count in context */
+  contextTokens?: number | null;
+  /** Maximum context window size in tokens */
+  contextWindow?: number | null;
+  /** Percentage of context used (0-100) */
+  contextPercent?: number | null;
+
+  // ── Memory system integration ──────────────────────
+
+  /** Whether agent has its own memory extension (determines roundhouse memory mode) */
+  hasMemoryExtension?: boolean;
+  /** Names of memory-related tools the agent exposes */
+  memoryTools?: string[];
+
+  // ── Extensions / capabilities ──────────────────────
+
+  /** List of loaded extension paths/names */
+  extensions?: string[];
+
+  /** Additional adapter-specific fields */
+  [key: string]: unknown;
+}
+
+/**
+ * AgentAdapter interface — the contract between gateway and adapters.
+ *
+ * New adapters should extend BaseAdapter (from ./agents/base-adapter.ts)
+ * which provides default implementations for optional methods.
+ */
 export interface AgentAdapter {
   /** Unique agent name, e.g. "pi", "kiro" */
-  name: string;
+  readonly name: string;
+
+  // ── Required ─────────────────────────────────────────
 
   /** Send a user message and return the full assistant response */
   prompt(threadId: string, message: AgentMessage): Promise<AgentResponse>;
 
-  /**
-   * Send a prompt using a specific model (for maintenance turns like memory flush).
-   * Falls back to prompt() if not implemented or model unavailable.
-   */
-  promptWithModel?(threadId: string, message: AgentMessage, modelId: string): Promise<AgentResponse>;
+  /** Send a user message and stream back events in real time. */
+  promptStream(threadId: string, message: AgentMessage): AsyncIterable<AgentStreamEvent>;
+
+  /** Tear down all sessions and release resources. */
+  dispose(): Promise<void>;
+
+  // ── Optional (have defaults in BaseAdapter) ──────────
 
-  /**
-   * Send a user message and stream back events in real time.
-   * Falls back to prompt() if not implemented.
-   */
-  promptStream?(threadId: string, message: AgentMessage): AsyncIterable<AgentStreamEvent>;
+  /** Prompt using a specific model (e.g. Haiku for memory flush). */
+  promptWithModel?(threadId: string, message: AgentMessage, modelId: string): Promise<AgentResponse>;
 
-  /** Dispose the session for a thread and start fresh on next prompt */
+  /** Dispose the session for a thread and start fresh on next prompt. */
   restart?(threadId: string): Promise<void>;
 
-  /** Compact the session context for a thread */
+  /** Compact the session context for a thread. */
   compact?(threadId: string): Promise<{ tokensBefore: number; tokensAfter: number | null } | null>;
-  /** Compact with a specific model (avoids restoring to default between flush and compact) */
+
+  /** Compact with a specific model. */
   compactWithModel?(threadId: string, modelId: string): Promise<{ tokensBefore: number; tokensAfter: number | null } | null>;
 
-  /** Abort the current agent run for a thread */
+  /** Abort the current agent run for a thread. */
   abort?(threadId: string): Promise<void>;
 
-  /** Return runtime info about the agent (model, version, etc.) */
-  getInfo?(threadId?: string): Record<string, unknown>;
-
-  /** Tear down all sessions */
-  dispose(): Promise<void>;
+  /** Return runtime info about the agent (model, version, etc.). */
+  getInfo?(threadId?: string): AdapterInfo;
 }
 
 export interface AgentResponse {