@inceptionstack/roundhouse 0.3.8 → 0.3.10

package/package.json

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

package/src/agents/pi.ts

@@ -6,7 +6,7 @@
  *   ~/.pi/agent/gateway-sessions/<thread_id>/<session>.jsonl
  */
 
-import { mkdir } from "node:fs/promises";
+import { mkdir, stat } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
@@ -24,7 +24,7 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 import type { AgentAdapter, AgentAdapterFactory, AgentMessage, AgentResponse, AgentStreamEvent } from "../types";
-import { DEBUG_STREAM, threadIdToDir } from "../util";
+import { DEBUG_STREAM, threadIdToDir, threadIdToDirLegacy } from "../util";
 
 interface SessionEntry {
   session: AgentSession;
@@ -159,7 +159,21 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
   }
 
   async function createSession(threadId: string): Promise<SessionEntry> {
-    const threadDir = join(sessionsDir, threadIdToDir(threadId));
+    let dirName = threadIdToDir(threadId);
+    const newPath = join(sessionsDir, dirName);
+    const legacyPath = join(sessionsDir, threadIdToDirLegacy(threadId));
+    // Migrate: if legacy dir exists but new doesn't, use legacy
+    if (dirName !== threadIdToDirLegacy(threadId)) {
+      try {
+        await stat(legacyPath);
+        // Legacy exists — check if new exists
+        try { await stat(newPath); } catch {
+          // New doesn't exist, use legacy to preserve session history
+          dirName = threadIdToDirLegacy(threadId);
+        }
+      } catch { /* legacy doesn't exist either, use new */ }
+    }
+    const threadDir = join(sessionsDir, dirName);
     await mkdir(threadDir, { recursive: true });
 
     let sessionManager: InstanceType<typeof SessionManager>;

package/src/cli/cli.ts

@@ -9,7 +9,7 @@ import { homedir } from "node:os";
 import { readFile, writeFile, mkdir, mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { readdirSync, statSync } from "node:fs";
-import { execSync, spawn } from "node:child_process";
+import { execSync, execFileSync, spawnSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -40,12 +40,16 @@ function run(cmd: string, opts?: { silent?: boolean }): string {
   }
 }
 
-function runSudo(cmd: string): void {
-  execSync(`sudo ${cmd}`, { stdio: "inherit" });
+function runSudo(...args: string[]): void {
+  // Try non-interactive first, fall back to interactive for password prompts
+  const result = spawnSync("sudo", ["-n", ...args], { stdio: "inherit" });
+  if (result.status !== 0) {
+    execFileSync("sudo", args, { stdio: "inherit" });
+  }
 }
 
 function systemctl(verb: string, message?: string): void {
-  runSudo(`systemctl ${verb} ${SERVICE_NAME}`);
+  runSudo("systemctl", verb, SERVICE_NAME);
   if (message) console.log(`  ✅ ${message}`);
 }
 
@@ -151,9 +155,9 @@ WantedBy=multi-user.target
   const tmpDir = await mkdtemp(resolve(tmpdir(), "roundhouse-"));
   const tmpUnit = resolve(tmpDir, `${SERVICE_NAME}.service`);
   await writeFile(tmpUnit, unit, { mode: 0o600 });
-  runSudo(`cp ${tmpUnit} ${SERVICE_PATH}`);
-  runSudo(`rm -rf -- ${tmpDir}`);
-  runSudo("systemctl daemon-reload");
+  runSudo("cp", tmpUnit, SERVICE_PATH);
+  runSudo("rm", "-rf", "--", tmpDir);
+  runSudo("systemctl", "daemon-reload");
   systemctl("enable");
   systemctl("start", "Daemon installed and started.");
 
@@ -174,8 +178,8 @@ async function cmdUninstall() {
   console.log("[roundhouse] Removing systemd daemon...");
   try { systemctl("stop"); } catch {}
   try { systemctl("disable"); } catch {}
-  try { runSudo(`rm -f ${SERVICE_PATH}`); } catch {}
-  runSudo("systemctl daemon-reload");
+  try { runSudo("rm", "-f", SERVICE_PATH); } catch {}
+  runSudo("systemctl", "daemon-reload");
   console.log("  ✅ Daemon removed. Config preserved at:", CONFIG_PATH);
 }
 

package/src/cli/setup.ts

@@ -189,7 +189,10 @@ export function parseSetupArgs(argv: string[]): SetupOptions {
     );
   }
   if (opts.users.length === 0) {
-    throw new Error("At least one --user USERNAME is required.");
+    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)) {
@@ -254,9 +257,23 @@ async function stepPreflight(opts: SetupOptions): Promise<void> {
     const hasAws =
       process.env.AWS_ACCESS_KEY_ID ||
       process.env.AWS_PROFILE ||
-      await fileExists(resolve(homedir(), ".aws", "credentials"));
+      await fileExists(resolve(homedir(), ".aws", "credentials")) ||
+      await fileExists(resolve(homedir(), ".aws", "config"));
+
+    // Also check instance metadata (EC2 IAM role)
+    let hasInstanceRole = false;
+    if (!hasAws) {
+      try {
+        const result = execSafe("curl", ["-sf", "--max-time", "2",
+          "http://169.254.169.254/latest/meta-data/iam/security-credentials/"], { silent: true });
+        hasInstanceRole = result.length > 0;
+      } catch {}
+    }
+
     if (hasAws) {
       ok("AWS credentials found");
+    } else if (hasInstanceRole) {
+      ok("AWS credentials found (instance IAM role)");
     } else {
       warn("AWS credentials not found — configure before first use");
     }
@@ -436,7 +453,7 @@ async function stepInstallPackages(opts: SetupOptions): Promise<void> {
 async function stepStoreSecrets(opts: SetupOptions, botInfo: BotInfo): Promise<void> {
   if (!opts.psst) return;
 
-  step("⑤", "Storing secrets in psst...");
+  step("⑥", "Storing secrets in psst...");
 
   const secrets: [string, string][] = [
     ["TELEGRAM_BOT_TOKEN", opts.botToken],
@@ -477,7 +494,7 @@ async function stepConfigure(
   botInfo: BotInfo,
   pairResult: PairResult | null,
 ): Promise<void> {
-  step("⑥", "Configuring...");
+  step("⑦", "Configuring...");
 
   await mkdir(ROUNDHOUSE_DIR, { recursive: true });
   await mkdir(dirname(PI_SETTINGS_PATH), { recursive: true });
@@ -602,6 +619,10 @@ async function stepConfigure(
     if (!envLines.some((l) => l.startsWith("AWS_DEFAULT_REGION="))) {
       envLines.push(`AWS_DEFAULT_REGION=${existingEnv.AWS_DEFAULT_REGION ?? '"us-east-1"'}`);
     }
+    // Pi agent requires AWS_REGION (not just AWS_DEFAULT_REGION) to discover Bedrock models
+    if (!envLines.some((l) => l.startsWith("AWS_REGION="))) {
+      envLines.push(`AWS_REGION=${existingEnv.AWS_REGION ?? existingEnv.AWS_DEFAULT_REGION ?? '"us-east-1"'}`);
+    }
   }
 
   await atomicWriteText(ENV_PATH, envLines.join("\n") + "\n");
@@ -609,7 +630,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) {
@@ -651,6 +672,11 @@ async function stepPair(opts: SetupOptions, botInfo: BotInfo): Promise<PairResul
 
   if (result) {
     ok(`Paired with @${result.username} (user id: ${result.userId}, chat: ${result.chatId})`);
+    // Add paired username to allowedUsers if not already present
+    const lcUsername = result.username.toLowerCase();
+    if (!opts.users.some((u) => u.toLowerCase() === lcUsername)) {
+      opts.users.push(result.username);
+    }
     return result;
   }
 
@@ -814,12 +840,12 @@ export async function cmdSetup(argv: string[]): Promise<void> {
     // Phase 2: Install packages
     await stepInstallPackages(opts);
 
-    // Phase 3: Store secrets
-    await stepStoreSecrets(opts, botInfo);
-
-    // Phase 4: Pair (before config, so we can include chat ID)
+    // Phase 3: Pair (before secrets/config, so paired username is included)
     const pairResult = await stepPair(opts, botInfo);
 
+    // Phase 4: Store secrets (after pairing, so ALLOWED_USERS includes paired user)
+    await stepStoreSecrets(opts, botInfo);
+
     // Phase 5: Write config (includes pair data)
     await stepConfigure(opts, botInfo, pairResult);
 
@@ -951,18 +977,20 @@ function printDryRun(opts: SetupOptions): void {
     log(`Would install: npm install -g psst-cli`);
     log(`Would initialize psst vault`);
     log(`Would install: pi-psst extension`);
-    log(`Would store TELEGRAM_BOT_TOKEN, BOT_USERNAME, ALLOWED_USERS in psst`);
   }
   for (const ext of opts.extensions) log(`Would install extension: ${ext}`);
+  if (!opts.nonInteractive && opts.notifyChatIds.length === 0) {
+    log(`Would pair via Telegram (interactive)`);
+  }
+  if (opts.psst) {
+    log(`Would store TELEGRAM_BOT_TOKEN, BOT_USERNAME, ALLOWED_USERS in psst`);
+  }
   log(`Would configure: ~/.pi/agent/settings.json`);
   log(`  Set defaultProvider: ${opts.provider}`);
   log(`  Set defaultModel: ${opts.model}`);
   log(`Would write: ~/.roundhouse/gateway.config.json`);
   log(`Would write: ~/.roundhouse/env${opts.psst ? " (non-secret config only)" : ""}`);
   log(`Would register ${BOT_COMMANDS.length} bot commands`);
-  if (!opts.nonInteractive && opts.notifyChatIds.length === 0) {
-    log(`Would pair via Telegram (interactive)`);
-  }
   if (opts.systemd) log(`Would install systemd service`);
   log("\nNo changes made.\n");
 }

package/src/config.ts

@@ -39,7 +39,7 @@ export const DEFAULT_CONFIG: GatewayConfig = {
     cwd: homedir(),
   },
   chat: {
-    botUsername: "roundhouse_bot",
+    botUsername: "",
     allowedUsers: [],
     adapters: {
       telegram: { mode: "polling" },

package/src/cron/scheduler.ts

@@ -276,7 +276,10 @@ export class CronSchedulerService {
           // Skip if already queued — don't write state that could race with the runner
           if (this.queuedJobIds.has(job.id)) continue;
 
-          // Update lastScheduledAt to prevent re-queueing next tick
+          // Update lastScheduledAt to prevent re-queueing next tick.
+          // NOTE: If the process crashes between here and run completion, this
+          // occurrence won't be retried on restart. Acceptable for periodic jobs;
+          // critical one-shot jobs should use external orchestration.
           state.lastScheduledAt = dueAt.toISOString();
           await this.store.writeState(state);
 

package/src/gateway.ts

@@ -22,13 +22,26 @@ import { maxPressure } from "./memory/policy";
 import type { PressureLevel } from "./memory/types";
 
 /** Match a Telegram command, handling optional @botname suffix */
+/** Bot username for command suffix validation (set during gateway init) */
+let _botUsername = "";
+
 function isCommand(text: string, cmd: string): boolean {
-  return text === cmd || text.startsWith(`${cmd}@`);
+  if (text === cmd) return true;
+  if (!text.startsWith(`${cmd}@`)) return false;
+  if (!_botUsername) return false; // no bot name configured, reject suffixed commands
+  const suffix = text.slice(cmd.length + 1).toLowerCase();
+  return suffix === _botUsername.toLowerCase();
 }
 
 /** Match a command that accepts subcommands (e.g. /crons trigger <id>) */
 function isCommandWithArgs(text: string, cmd: string): boolean {
-  return text === cmd || text.startsWith(`${cmd}@`) || text.startsWith(`${cmd} `);
+  if (text === cmd || text.startsWith(`${cmd} `)) return true;
+  if (!text.startsWith(`${cmd}@`)) return false;
+  if (!_botUsername) return false;
+  const rest = text.slice(cmd.length + 1);
+  const spaceIdx = rest.indexOf(" ");
+  const suffix = spaceIdx === -1 ? rest : rest.slice(0, spaceIdx);
+  return suffix.toLowerCase() === _botUsername.toLowerCase();
 }
 import { hostname, loadavg, totalmem, freemem, cpus } from "node:os";
 import { homedir } from "node:os";
@@ -166,10 +179,25 @@ async function saveAttachments(threadId: string, attachments: any[]): Promise<At
         continue;
       }
 
-      const buf = Buffer.isBuffer(data) ? data
-        : ArrayBuffer.isView(data) ? Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-        : data instanceof ArrayBuffer ? Buffer.from(data)
-        : Buffer.from(await (data as Blob).arrayBuffer());
+      // Convert to Buffer with size cap to prevent memory exhaustion
+      let buf: Buffer;
+      if (Buffer.isBuffer(data)) {
+        buf = data;
+      } else if (data instanceof Blob) {
+        // Stream blobs with size cap
+        if (data.size > MAX_FILE_SIZE) {
+          skipped.push(`${att.name ?? att.type} (${(data.size / 1024 / 1024).toFixed(1)} MB) exceeds size limit`);
+          continue;
+        }
+        buf = Buffer.from(await data.arrayBuffer());
+      } else if (ArrayBuffer.isView(data)) {
+        buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+      } else if (data instanceof ArrayBuffer) {
+        buf = Buffer.from(data);
+      } else {
+        console.warn(`[roundhouse] unknown attachment data type, skipping: ${att.name ?? att.type}`);
+        continue;
+      }
 
       if (buf.length > MAX_FILE_SIZE) {
         const sizeMB = (buf.length / 1024 / 1024).toFixed(1);
@@ -220,6 +248,7 @@ export class Gateway {
   constructor(router: AgentRouter, config: GatewayConfig) {
     this.router = router;
     this.config = config;
+    _botUsername = config.chat.botUsername || "";
   }
 
   async start() {
@@ -305,8 +334,8 @@ export class Gateway {
       // Handle /restart command — restart the gateway process
       // Only available when an allowlist is configured (all allowed users can restart)
       if (isCommand(userText.trim(), "/restart")) {
-        if (allowedUsers.length === 0) {
-          await thread.post("⚠️ /restart requires an allowedUsers list to be configured.");
+        if (allowedUsers.length === 0 && allowedUserIds.length === 0) {
+          await thread.post("⚠️ /restart requires an allowlist (allowedUsers or allowedUserIds) to be configured.");
           return;
         }
         console.log(`[roundhouse] /restart requested by @${authorName} in thread=${thread.id}`);

package/src/memory/state.ts

@@ -9,7 +9,7 @@ import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import { ROUNDHOUSE_DIR } from "../config";
-import { threadIdToDir } from "../util";
+import { threadIdToDir, threadIdToDirLegacy } from "../util";
 import type { ThreadMemoryState } from "./types";
 
 const STATE_DIR = resolve(ROUNDHOUSE_DIR, "memory-state");
@@ -18,12 +18,24 @@ function stateFilePath(threadId: string): string {
   return resolve(STATE_DIR, `${threadIdToDir(threadId)}.json`);
 }
 
+function legacyStateFilePath(threadId: string): string {
+  return resolve(STATE_DIR, `${threadIdToDirLegacy(threadId)}.json`);
+}
+
 /** Load per-thread memory state (returns empty state if none exists) */
 export async function loadThreadMemoryState(threadId: string): Promise<ThreadMemoryState> {
   try {
     const raw = await readFile(stateFilePath(threadId), "utf8");
     return JSON.parse(raw) as ThreadMemoryState;
   } catch {
+    // Fallback to legacy encoding for pre-v0.4 state files
+    try {
+      const legacyPath = legacyStateFilePath(threadId);
+      if (legacyPath !== stateFilePath(threadId)) {
+        const raw = await readFile(legacyPath, "utf8");
+        return JSON.parse(raw) as ThreadMemoryState;
+      }
+    } catch {}
     return {};
   }
 }

package/src/types.ts

@@ -98,6 +98,8 @@ export interface AgentRouter {
 // ── Gateway config ───────────────────────────────────
 
 export interface GatewayConfig {
+  /** Config schema version for future migrations */
+  _version?: number;
   agent: {
     type: string;
     [key: string]: unknown;

package/src/util.ts

@@ -97,12 +97,20 @@ export function startTypingLoop(
  * Uses a scheme that avoids collisions between different separators.
  */
 export function threadIdToDir(threadId: string): string {
-  // Escape underscores first, then encode special chars:
-  // ":" → "_c", "_" → "_u", everything else → "_x"
+  // Injective filesystem-safe encoding:
+  // "_" → "__", ":" → "_c", other special → "_xNN" (hex code)
   return threadId
-    .replace(/_/g, "_u")    // escape existing underscores first
-    .replace(/:/g, "_c")    // encode colons
-    .replace(/[^a-zA-Z0-9_-]/g, "_x"); // encode everything else
+    .replace(/_/g, "__")    // escape existing underscores first
+    .replace(/:/g, "_c")    // encode colons (common in thread IDs)
+    .replace(/[^a-zA-Z0-9_-]/g, (ch) => `_x${ch.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+
+/** Legacy encoding (v0.3.x) for migration fallback */
+export function threadIdToDirLegacy(threadId: string): string {
+  return threadId
+    .replace(/_/g, "_u")
+    .replace(/:/g, "_c")
+    .replace(/[^a-zA-Z0-9_-]/g, "_x");
 }
 
 /**