@inceptionstack/roundhouse 0.4.2 → 0.4.4

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";
@@ -183,7 +183,7 @@ export function provisionMcporterConfig(opts: ProvisionOpts = {}): void {
 }
 
 /**
- * Provision all bundle dependencies (skills + CLI tools + config).
+ * Provision all bundle dependencies (skills + CLI tools + config + extensions).
  * Non-fatal — logs warnings on failure but never throws.
  */
 export function provisionBundle(opts: ProvisionOpts = {}): void {
@@ -192,4 +192,85 @@ 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 = consoleLog } = opts;
+  const settingsPath = resolve(homedir(), ".pi", "agent", "settings.json");
+
+  const coreExtensions = [
+    "npm:@inceptionstack/pi-hard-no",
+    "npm:@inceptionstack/pi-branch-enforcer",
+  ];
+
+  try {
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    }
+    if (!Array.isArray(settings.packages)) settings.packages = [];
+    const pkgs = settings.packages as string[];
+
+    let added = 0;
+    for (const ext of coreExtensions) {
+      if (!pkgs.includes(ext)) {
+        pkgs.push(ext);
+        added++;
+      }
+    }
+
+    if (added > 0) {
+      mkdirSync(dirname(settingsPath), { recursive: true });
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      log.ok(`${added} extension(s) added to settings.json`);
+    } else {
+      log.ok("extensions (already configured)");
+    }
+  } catch (err: any) {
+    log.warn(`extensions provisioning failed: ${err.message}`);
+  }
 }

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,
@@ -74,12 +74,20 @@ async function cmdStart() {
 
   // No systemd service — fall back to foreground
   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() {
   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 +102,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,21 @@ 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 = [
+        "npm:@inceptionstack/pi-hard-no",
+        "npm:@inceptionstack/pi-branch-enforcer",
+      ];
+      for (const ext of coreExtensions) {
+        if (!pkgs.includes(ext)) pkgs.push(ext);
+      }
 
       // Add pi-psst if using psst
       if (ctx.psst) {
@@ -1246,7 +1257,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/gateway.ts

@@ -639,6 +639,18 @@ export class Gateway {
           lines.push(`📝 Context: no usage data yet (${windowK}K window)`);
         }
 
+        // Extensions
+        const extensions = Array.isArray(info.extensions) ? info.extensions as string[] : [];
+        if (extensions.length > 0) {
+          lines.push(``);
+          lines.push(`🧩 Extensions (${extensions.length}):`);
+          for (const ext of extensions) {
+            // Show short name: strip npm: prefix and path noise
+            const short = ext.replace(/^.*node_modules\//, "").replace(/\/index\.[tj]s$/, "");
+            lines.push(`   • ${short}`);
+          }
+        }
+
         await this.postWithFallback(thread, lines.join("\n"));
         console.log(`[roundhouse] /status for thread=${thread.id} agentThread=${agentThreadId}`);
         return;

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 {