@inceptionstack/roundhouse 0.3.14 → 0.3.16

package/package.json

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

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

@@ -1,62 +1,48 @@
 /**
- * Credential checks
+ * Credential checks — validates token presence and format.
+ * API connectivity is tested by the telegram checks (checks/telegram.ts).
  */
 
-import type { DoctorCheck } from "../types";
+import { readFile } from "node:fs/promises";
+import { parseEnvFile } from "../../env-file";
+import type { DoctorCheck, DoctorContext } from "../types";
+
+/**
+ * Resolve the Telegram bot token from process env or the .env file.
+ * Shared by credential and telegram checks.
+ */
+export async function resolveToken(ctx: DoctorContext): Promise<string | null> {
+  let token = ctx.env.TELEGRAM_BOT_TOKEN;
+  if (!token) {
+    try {
+      const entries = parseEnvFile(await readFile(ctx.envFilePath, "utf8"));
+      const raw = entries.get("TELEGRAM_BOT_TOKEN");
+      if (raw) token = raw.replace(/^["']|["']$/g, "");
+    } catch {}
+  }
+  return token || null;
+}
 
 export const credentialChecks: DoctorCheck[] = [
   {
     id: "telegram-token", category: "credentials", name: "Telegram bot token",
     async run(ctx) {
-      // Check both process env and the systemd env file
-      let token = ctx.env.TELEGRAM_BOT_TOKEN;
-      if (!token) {
-        try {
-          const { readFile } = await import("node:fs/promises");
-          const envContent = await readFile(ctx.envFilePath, "utf8");
-          const match = envContent.match(/^TELEGRAM_BOT_TOKEN=(.+)$/m);
-          if (match) token = match[1].trim().replace(/^["']|["']$/g, "");
-        } catch {}
-      }
+      const base = { id: "telegram-token", category: "credentials" as const, name: "Telegram bot token" };
+      const token = await resolveToken(ctx);
+
       if (!token) {
         return {
-          id: "telegram-token", category: "credentials", name: "Telegram bot token",
-          status: "fail", summary: "TELEGRAM_BOT_TOKEN not set",
+          ...base, status: "fail", summary: "TELEGRAM_BOT_TOKEN not set",
           details: ["Set TELEGRAM_BOT_TOKEN in your environment or ~/.roundhouse/.env"],
         };
       }
       if (!/^\d+:[A-Za-z0-9_-]+$/.test(token)) {
         return {
-          id: "telegram-token", category: "credentials", name: "Telegram bot token",
-          status: "fail", summary: "invalid format",
+          ...base, status: "fail", summary: "invalid format",
           details: ["Token should match pattern: digits:alphanumeric"],
         };
       }
-      // Try getMe
-      try {
-        const res = await fetch(`https://api.telegram.org/bot${token}/getMe`, {
-          signal: AbortSignal.timeout(10000),
-        });
-        if (res.ok) {
-          const data = await res.json() as any;
-          const username = data.result?.username ?? "unknown";
-          return {
-            id: "telegram-token", category: "credentials", name: "Telegram bot token",
-            status: "pass", summary: `@${username}`,
-          };
-        }
-        return {
-          id: "telegram-token", category: "credentials", name: "Telegram bot token",
-          status: "fail", summary: `API returned ${res.status}`,
-          details: ["Token may be invalid or revoked"],
-        };
-      } catch (err) {
-        return {
-          id: "telegram-token", category: "credentials", name: "Telegram bot token",
-          status: "warn", summary: "cannot reach Telegram API",
-          details: [(err as Error).message],
-        };
-      }
+      return { ...base, status: "pass", summary: "present, valid format" };
     },
   },
 ];

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

@@ -0,0 +1,115 @@
+/**
+ * Telegram connectivity checks — tests API access, config, and webhook status.
+ * Token resolution is shared with credentials.ts via resolveToken().
+ */
+
+import { readFile } from "node:fs/promises";
+import type { DoctorCheck, DoctorContext } from "../types";
+import { resolveToken } from "./credentials";
+
+/** Load and parse the gateway config, returning null on any error. */
+async function loadGatewayConfig(ctx: DoctorContext): Promise<any | null> {
+  try {
+    return JSON.parse(await readFile(ctx.configPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export const telegramChecks: DoctorCheck[] = [
+  {
+    id: "telegram-configured", category: "network", name: "Telegram adapter configured",
+    async run(ctx) {
+      const base = { id: "telegram-configured", category: "network" as const, name: "Telegram adapter configured" };
+      const cfg = await loadGatewayConfig(ctx);
+      if (!cfg) {
+        return { ...base, status: "info", summary: "skipped (no config file)" };
+      }
+      if (cfg.chat?.adapters?.telegram) {
+        const mode = cfg.chat.adapters.telegram.mode ?? "polling";
+        return { ...base, status: "pass", summary: `mode: ${mode}` };
+      }
+      return { ...base, status: "info", summary: "not configured (no telegram adapter in config)" };
+    },
+  },
+
+  {
+    id: "telegram-api", category: "network", name: "Telegram API reachable",
+    async run(ctx) {
+      const base = { id: "telegram-api", category: "network" as const, name: "Telegram API reachable" };
+      const token = await resolveToken(ctx);
+      if (!token) {
+        return { ...base, status: "info", summary: "skipped (no token)" };
+      }
+
+      try {
+        const res = await fetch(`https://api.telegram.org/bot${token}/getMe`, {
+          signal: AbortSignal.timeout(10000),
+        });
+        if (res.ok) {
+          const data = await res.json() as any;
+          return { ...base, status: "pass", summary: `@${data.result?.username ?? "unknown"}` };
+        }
+        if (res.status === 401) {
+          return { ...base, status: "fail", summary: "401 Unauthorized — token is invalid or revoked" };
+        }
+        return { ...base, status: "fail", summary: `API returned ${res.status}` };
+      } catch (err) {
+        return {
+          ...base, status: "fail", summary: "cannot reach api.telegram.org",
+          details: [(err as Error).message],
+        };
+      }
+    },
+  },
+
+  {
+    id: "telegram-webhook", category: "network", name: "Telegram webhook status",
+    async run(ctx) {
+      const base = { id: "telegram-webhook", category: "network" as const, name: "Telegram webhook status" };
+      const token = await resolveToken(ctx);
+      if (!token) {
+        return { ...base, status: "info", summary: "skipped (no token)" };
+      }
+
+      const cfg = await loadGatewayConfig(ctx);
+      const configuredMode = cfg?.chat?.adapters?.telegram?.mode ?? "polling";
+
+      try {
+        const res = await fetch(`https://api.telegram.org/bot${token}/getWebhookInfo`, {
+          signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok) {
+          return { ...base, status: "warn", summary: `getWebhookInfo returned ${res.status}` };
+        }
+        const data = await res.json() as any;
+        const webhookUrl = data.result?.url;
+        const pendingUpdates = data.result?.pending_update_count ?? 0;
+
+        if (configuredMode === "polling") {
+          if (webhookUrl) {
+            return {
+              ...base, status: "warn", summary: "webhook set but mode is polling",
+              details: [
+                `Webhook URL: ${webhookUrl}`,
+                "Polling won't receive updates while a webhook is active.",
+                "The gateway will clear this on startup, but if it fails to start, messages are lost.",
+              ],
+            };
+          }
+          return { ...base, status: "pass", summary: `no webhook (polling mode), ${pendingUpdates} pending updates` };
+        } else {
+          if (!webhookUrl) {
+            return { ...base, status: "warn", summary: "webhook mode configured but no webhook set" };
+          }
+          return { ...base, status: "pass", summary: `webhook: ${webhookUrl}, ${pendingUpdates} pending` };
+        }
+      } catch (err) {
+        return {
+          ...base, status: "warn", summary: "cannot check webhook status",
+          details: [(err as Error).message],
+        };
+      }
+    },
+  },
+];

package/src/cli/doctor/runner.ts

@@ -13,6 +13,7 @@ import { agentChecks } from "./checks/agent";
 import { systemdChecks } from "./checks/systemd";
 import { diskChecks } from "./checks/disk";
 import { sttChecks } from "./checks/stt";
+import { telegramChecks } from "./checks/telegram";
 
 /** Create a DoctorContext with sensible defaults */
 export async function createDoctorContext(overrides: Partial<DoctorContext> = {}): Promise<DoctorContext> {
@@ -34,6 +35,7 @@ const ALL_CHECKS: DoctorCheck[] = [
   ...configChecks,
   ...credentialChecks,
   ...agentChecks,
+  ...telegramChecks,
   ...sttChecks,
   ...diskChecks,
   ...systemdChecks,

package/src/cli/doctor.ts

@@ -7,7 +7,7 @@ import { formatResult, formatSummary, formatCategoryHeader } from "./doctor/outp
 import { runDoctor, createDoctorContext } from "./doctor/runner";
 
 const CATEGORY_ORDER: DoctorCategory[] = [
-  "system", "config", "credentials", "agent", "stt", "disk", "systemd",
+  "system", "config", "credentials", "network", "agent", "stt", "disk", "systemd",
 ];
 
 export async function cmdDoctor(args: string[]): Promise<void> {

package/src/cli/setup.ts

@@ -136,7 +136,7 @@ export function parseSetupArgs(argv: string[]): SetupOptions {
     notifyChatIds: [],
     systemd: platform() === "linux",
     voice: true,
-    psst: true,
+    psst: false,
     nonInteractive: false,
     force: false,
     dryRun: false,
@@ -159,7 +159,7 @@ export function parseSetupArgs(argv: string[]): SetupOptions {
       case "--notify-chat": opts.notifyChatIds.push(parseInt(next(), 10)); break;
       case "--no-systemd": opts.systemd = false; break;
       case "--no-voice": opts.voice = false; break;
-      case "--no-psst": opts.psst = false; break;
+      case "--with-psst": opts.psst = true; break;
       case "--non-interactive": opts.nonInteractive = true; break;
       case "--force": opts.force = true; break;
       case "--dry-run": opts.dryRun = true; break;
@@ -446,7 +446,7 @@ async function stepInstallPackages(opts: SetupOptions): Promise<void> {
 async function stepStoreSecrets(opts: SetupOptions, botInfo: BotInfo): Promise<void> {
   if (!opts.psst) {
     step("⑥", "Storing secrets...");
-    ok("Skipped (--no-psst)");
+    ok("Skipped (default — use --with-psst to enable)");
     return;
   }
 
@@ -963,7 +963,7 @@ Channel:
 Service:
   --no-systemd               Skip systemd install
   --no-voice                 Disable voice/STT
-  --no-psst                  Skip psst, use plaintext env file
+  --with-psst                Use psst vault for secrets (default: .env file)
 
 Behavior:
   --non-interactive          No pairing, no prompts