@inceptionstack/roundhouse 0.3.9 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.3.9",
+  "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/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/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");
 }
 
 /**