@inceptionstack/roundhouse 0.5.4 → 0.5.7

package/src/cli/{setup-telegram.ts → setup/telegram.ts}

@@ -1,12 +1,12 @@
 /**
- * cli/setup-telegram.ts — Telegram API helpers for setup
+ * cli/setup/telegram.ts — Telegram API helpers for setup
  *
  * Zero-dependency Telegram Bot API client using global fetch.
  * Token is never logged — redacted in all error messages.
  */
 
-import { randomBytes } from "node:crypto";
-import { BOT_COMMANDS } from "../commands";
+import { createPairingNonce } from "../../transports/telegram/pairing";
+import { BOT_COMMANDS } from "../../transports/telegram/bot-commands";
 
 // ── Types ────────────────────────────────────────────
 
@@ -90,7 +90,7 @@ export async function pairTelegram(
   log: (msg: string) => void = console.log,
   opts?: { nonce?: string; showLink?: boolean },
 ): Promise<PairResult | null> {
-  const nonce = opts?.nonce ?? `rh-${randomBytes(8).toString("hex")}`;
+  const nonce = opts?.nonce ?? createPairingNonce();
   const normalizedUsers = allowedUsers.map((u) => u.replace(/^@/, "").toLowerCase());
 
   // Clear stale updates — advance offset past existing

package/src/cli/setup/types.ts

@@ -18,17 +18,18 @@ export interface SetupOptions {
   systemd: boolean;
   voice: boolean;
   psst: boolean;
-  nonInteractive: boolean;
   force: boolean;
   dryRun: boolean;
   /** Telegram-focused setup flow */
   telegram: boolean;
-  /** Fully headless automation (no TTY prompts) */
-  headless: boolean;
+  /** Non-interactive mode (no TTY prompts) */
+  nonInteractive: boolean;
   /** QR code display mode */
   qr: "auto" | "always" | "never";
   /** Agent type (default: pi) */
   agent: string;
+  /** Whether --agent was explicitly passed on CLI */
+  _agentExplicit?: boolean;
   /** Set by detection: skip agent package install if already configured */
   _skipAgentInstall?: boolean;
 }

package/src/cli/setup.ts

@@ -10,7 +10,7 @@
  */
 
 import { readFile } from "node:fs/promises";
-import { BOT_COMMANDS } from "../commands";
+import { BOT_COMMANDS } from "../transports/telegram/bot-commands";
 import { atomicWriteJson, execSafe } from "./setup/helpers";
 import { type SetupOptions } from "./setup/types";
 import { parseSetupArgs } from "./setup/args";
@@ -27,7 +27,7 @@ import {
 import {
   validateBotToken,
   pairTelegram,
-} from "./setup-telegram";
+} from "./setup/telegram";
 import {
   stepPreflight,
   stepValidateToken,
@@ -42,7 +42,7 @@ import {
   stepPostflight,
 } from "./setup/steps";
 import { resolveAgentForSetup, textLog, textStepLog } from "./setup/runtime";
-import { runInteractiveTelegramSetup, runHeadlessTelegramSetup } from "./setup/flows";
+import { runInteractiveTelegramSetup, runNonInteractiveTelegramSetup } from "./setup/flows";
 
 // ── Orchestrator ─────────────────────────────────────
 
@@ -63,8 +63,8 @@ export async function cmdSetup(argv: string[]): Promise<void> {
 
   // Route to --telegram flows
   if (opts.telegram) {
-    if (opts.headless) {
-      await runHeadlessTelegramSetup(opts);
+    if (opts.nonInteractive) {
+      await runNonInteractiveTelegramSetup(opts);
     } else {
       await runInteractiveTelegramSetup(opts);
     }
@@ -258,12 +258,12 @@ function printSetupHelp(): void {
   console.log(`
 Usage:
   roundhouse setup --telegram                     Interactive wizard (recommended)
-  TELEGRAM_BOT_TOKEN=... roundhouse setup \\\n    --telegram --headless --user USERNAME          Headless automation (SSM/cloud-init)
+  TELEGRAM_BOT_TOKEN=... roundhouse setup \\\n    --telegram --non-interactive --user USERNAME   Non-interactive automation (SSM/cloud-init)
   TELEGRAM_BOT_TOKEN=... roundhouse setup \\\n    --user USERNAME                                Legacy (non-wizard) setup
 
 Modes:
-  --telegram                 Telegram-focused setup (wizard or headless)
-  --headless                 Non-interactive automation (implies --non-interactive)
+  --telegram                 Telegram-focused setup (wizard or non-interactive)
+  --non-interactive           Suppress all prompts (for automation/SSM/cloud-init)
                              Requires TELEGRAM_BOT_TOKEN env var and --user
 
 Required (or prompted in interactive --telegram):

package/src/cli/systemd.ts

@@ -127,6 +127,8 @@ WorkingDirectory=${home}
 ExecStart=${opts.execStart}
 Restart=on-failure
 RestartSec=5
+TimeoutStopSec=15
+KillMode=mixed
 EnvironmentFile=-${envFilePath}
 Environment=ROUNDHOUSE_CONFIG=${CONFIG_PATH}
 Environment=NODE_ENV=production

package/src/cli/update.ts

@@ -0,0 +1,111 @@
+/**
+ * commands/update.ts — Handle the /update command
+ *
+ * Transport-agnostic: receives a ProgressReporter interface,
+ * not a Telegram-specific thread object.
+ */
+
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { provisionBundle } from "../provisioning/bundle";
+
+const GLOBAL_PI_EXTENSION_PACKAGES = [
+  "@inceptionstack/pi-hard-no",
+  "@inceptionstack/pi-branch-enforcer",
+];
+
+export interface UpdateProgress {
+  update(text: string): Promise<void>;
+}
+
+export interface UpdateResult {
+  action: "already-latest" | "updated" | "error";
+  currentVersion: string;
+  latestVersion?: string;
+  error?: string;
+}
+
+/**
+ * Check for updates, install if newer, provision bundle, patch settings.
+ * Returns the result — caller decides how to present it and whether to restart.
+ */
+export async function performUpdate(progress: UpdateProgress): Promise<UpdateResult> {
+  // Get current version
+  const pkg = await import("../../package.json", { with: { type: "json" } });
+  const currentVersion = pkg.default?.version ?? "unknown";
+
+  // Check latest version on npm
+  let latestVersion: string;
+  try {
+    latestVersion = execSync("npm view @inceptionstack/roundhouse version 2>/dev/null", {
+      timeout: 30_000,
+      encoding: "utf8",
+    }).trim();
+  } catch (e) {
+    // Update extensions anyway, but flag that version check failed
+    latestVersion = "";
+    console.warn("[roundhouse] npm view failed:", e instanceof Error ? e.message : e);
+  }
+
+  // Always update extensions (even if roundhouse is already latest)
+  if (!latestVersion) {
+    await progress.update(`⚠️ Version check failed — updating extensions only`);
+  }
+  for (const extensionPackage of GLOBAL_PI_EXTENSION_PACKAGES) {
+    await progress.update(`📦 Updating extension: ${extensionPackage}...`);
+
+    try {
+      execSync(`npm install -g ${extensionPackage}@latest 2>&1`, {
+        timeout: 60_000,
+        encoding: "utf8",
+      });
+      await progress.update(`✅ ${extensionPackage} updated`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.warn(`[roundhouse] failed to update extension ${extensionPackage}:`, msg);
+      await progress.update(`⚠️ Failed to update ${extensionPackage}: ${msg.slice(0, 150)}`);
+    }
+  }
+
+  if (!latestVersion) {
+    return { action: "error", currentVersion, error: "Version check failed (extensions updated)" };
+  }
+  if (latestVersion === currentVersion) {
+    return { action: "already-latest", currentVersion };
+  }
+
+  await progress.update(`📦 Updating v${currentVersion} → v${latestVersion}...`);
+
+  try {
+    execSync("npm install -g @inceptionstack/roundhouse@latest 2>&1", {
+      timeout: 120_000,
+      encoding: "utf8",
+    });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.warn("[roundhouse] self-update failed:", msg);
+    return { action: "error", currentVersion, error: `Self-update failed: ${msg}` };
+  }
+
+  // Provision bundle (skills sync + CLI tools + config)
+  try {
+    provisionBundle();
+  } catch (e) {
+    console.warn("[roundhouse] bundle provisioning failed:", e instanceof Error ? e.message : e);
+  }
+
+  // Ensure settings.json includes roundhouse package (for pre-bundle upgrades)
+  try {
+    const settingsPath = `${homedir()}/.pi/agent/settings.json`;
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    const selfPkg = "npm:@inceptionstack/roundhouse";
+    if (!Array.isArray(settings.packages)) settings.packages = [];
+    if (!settings.packages.includes(selfPkg)) {
+      settings.packages.push(selfPkg);
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch { /* settings.json may not exist yet — fine, setup will create it */ }
+
+  return { action: "updated", currentVersion, latestVersion };
+}

package/src/cron/runner.ts

@@ -6,7 +6,8 @@
  */
 
 import { getAgentFactory } from "../agents/registry";
-import { sendTelegramToMany } from "../notify/telegram";
+// TODO: route through TransportAdapter.notify() when multi-transport lands
+import { sendTelegramToMany } from "../transports/telegram/notify";
 import { CronStore, generateRunId } from "./store";
 import { buildTemplateContext, renderTemplate } from "./template";
 import type { CronJobConfig, CronRunRecord } from "./types";

package/src/gateway/commands.ts

@@ -1,5 +1,5 @@
 /**
- * gateway/commands.ts — Telegram command handlers
+ * gateway/commands.ts — Chat command handlers
  *
  * Each handler is a standalone async function that receives a CommandContext.
  * Extracted from Gateway.start() to reduce method size and enable unit testing.
@@ -9,7 +9,8 @@ import type { AgentAdapter, AgentStreamEvent, GatewayConfig } from "../types";
 import { ROUNDHOUSE_VERSION } from "../config";
 import { startTypingLoop } from "../util";
 import { prepareMemoryForTurn, finalizeMemoryForTurn, flushMemoryThenCompact, determineMemoryMode } from "../memory/lifecycle";
-import { createProgressMessage } from "../telegram-progress";
+// TODO: move progress into TransportAdapter when multi-transport lands
+import { createProgressMessage } from "../transports/telegram/progress";
 import { getSystemResources } from "./helpers";
 
 // ── Types ────────────────────────────────────────────
@@ -70,10 +71,12 @@ export async function handleUpdate(ctx: CommandContext): Promise<void> {
   console.log(`[roundhouse] /update requested by @${authorName} in thread=${thread.id}`);
   const progress = await createProgressMessage(thread, "📦 Checking for updates...");
   try {
-    const { performUpdate } = await import("../commands/update");
+    const { performUpdate } = await import("../cli/update");
     const result = await performUpdate(progress);
     if (result.action === "already-latest") {
       await progress.update(`✅ Already on latest (v${result.currentVersion})`);
+    } else if (result.action === "error") {
+      await progress.update(`⚠️ ${(result.error ?? "Update failed").slice(0, 200)}`);
     } else if (result.action === "updated") {
       await progress.update(`✅ Updated v${result.currentVersion} → v${result.latestVersion}. Restarting...`);
       console.log(`[roundhouse] updated ${result.currentVersion} -> ${result.latestVersion}, restarting`);
@@ -160,15 +163,37 @@ export async function handleStatus(ctx: CommandContext): Promise<void> {
   const nodeVer = process.version;
   const memMB = (process.memoryUsage.rss() / 1024 / 1024).toFixed(1);
 
+  // Check for available update (async, non-blocking)
+  let updateAvailable = "";
+  try {
+    const { exec } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execAsync = promisify(exec);
+    const { stdout } = await execAsync("npm view @inceptionstack/roundhouse version 2>/dev/null", { timeout: 10_000 });
+    const latest = stdout.trim().split("\n").pop()!.trim();
+    if (latest && /^\d+\.\d+\.\d+$/.test(latest) && latest !== ROUNDHOUSE_VERSION) {
+      // Simple semver comparison: split and compare numerically
+      const [lM, lm, lp] = latest.split(".").map(Number);
+      const [cM, cm, cp] = ROUNDHOUSE_VERSION.split(".").map(Number);
+      if (lM > cM || (lM === cM && lm > cm) || (lM === cM && lm === cm && lp > cp)) {
+        updateAvailable = latest;
+      }
+    }
+  } catch { /* network unavailable — skip */ }
+
   const info = agent.getInfo ? agent.getInfo(agentThreadId) : {};
   const agentVersion = info.version ? `v${info.version}` : "";
   const agentLabel = agentVersion ? `\`${agent.name}\` (${agentVersion})` : `\`${agent.name}\``;
 
+  const versionLine = updateAvailable
+    ? `📦 Roundhouse: v${ROUNDHOUSE_VERSION} → ⬆️ v${updateAvailable} available (/update)`
+    : `📦 Roundhouse: v${ROUNDHOUSE_VERSION}`;
+
   const lines = [
     `📊 *Roundhouse Status*`,
     ``,
     `🎫 Session: \`${agentThreadId}\``,
-    `📦 Roundhouse: v${ROUNDHOUSE_VERSION}`,
+    versionLine,
     `🤖 Agent: ${agentLabel}`,
   ];