grok-telegram-bot 2.4.0 → 2.6.0

package/src/config.ts

@@ -72,16 +72,51 @@ function nonNegNum(v: string | undefined, def: number): number {
   return Number.isFinite(n) && n >= 0 ? n : def;
 }
 
+/** Comma-separated list (spaces around commas ok). Used for ALLOWED_USERS, PROJECT_ROOTS, etc. */
 function list(v: string | undefined): string[] {
   return (v || "")
     .split(",")
-    .map((s) => s.trim())
+    .map((s) => s.trim().replace(/^["']|["']$/g, ""))
     .filter(Boolean);
 }
 
+/**
+ * Parse ALLOWED_USERS. Blank/unset → allow everyone. Non-blank → only numeric
+ * Telegram user ids (invalid tokens dropped). If every token is invalid, deny
+ * everyone (fail closed) rather than treating as open.
+ */
+export function parseAllowedUsers(raw: string | undefined): {
+  ids: Set<string>;
+  allowAll: boolean;
+  dropped: string[];
+} {
+  if (raw === undefined || raw.trim() === "") {
+    return { ids: new Set(), allowAll: true, dropped: [] };
+  }
+  const tokens = list(raw);
+  const dropped: string[] = [];
+  const ids = new Set<string>();
+  for (const t of tokens) {
+    // Telegram user ids are positive integers (string form).
+    if (/^\d+$/.test(t)) ids.add(t);
+    else dropped.push(t);
+  }
+  return { ids, allowAll: false, dropped };
+}
+
 export interface AppConfig {
   token: string;
+  /**
+   * Telegram user ids allowed to use the bot (private + groups). Populated from
+   * comma-separated ALLOWED_USERS. See {@link allowAllUsers}.
+   */
   allowedUsers: Set<string>;
+  /**
+   * True only when ALLOWED_USERS was blank/unset. When false, only ids in
+   * {@link allowedUsers} may use the bot (even if the set is empty after
+   * filtering invalid tokens — fail closed).
+   */
+  allowAllUsers: boolean;
   grokCliPath: string;
   workspace: string;
   /** Optional xAI API key for headless hosts. When set, exported to the agent
@@ -167,6 +202,45 @@ export interface AppConfig {
    * the AI-written recheck prompt (or built-in default if the AI left it blank).
    */
   selfRecheckPrompt: string;
+  /**
+   * Max wait for quiet meta ACP prompts (self-recheck decision, suggestions).
+   * On timeout the session prompt is cancelled so Done is not blocked forever.
+   * QUIET_PROMPT_TIMEOUT_MS, default 90s.
+   */
+  quietPromptTimeoutMs: number;
+  /**
+   * Telegram forum supergroup id for project topics (TOPIC_GROUP_ID). When set
+   * and the bot is admin, the bot manages topics: AI Chat + optional one topic
+   * per catalog project. Empty/undefined disables forum management.
+   */
+  topicGroupId?: number;
+  /**
+   * Auto-create a forum topic for each catalog project (TOPIC_AUTO_CREATE).
+   * Default true when TOPIC_GROUP_ID is set.
+   */
+  topicAutoCreateProjects: boolean;
+  /** Display name for the default AI chat topic (TOPIC_AI_CHAT_NAME). */
+  topicAiChatName: string;
+  /**
+   * Sibling Telegram bot usernames the agent may call via telegram bridge
+   * `bot_command` / `list_bots` (ALLOWED_TELEGRAM_BOTS, comma-separated, with
+   * or without @). Empty = feature off.
+   */
+  allowedTelegramBots: string[];
+  /**
+   * Optional command catalogs per bot (TELEGRAM_BOT_COMMANDS). Keys are
+   * usernames (no @); values are command names without slash + optional
+   * description. Shown by list_bots / first-prompt directive.
+   */
+  telegramBotCommands: Record<string, Array<{ command: string; description?: string }>>;
+  /** Hard timeout waiting for a sibling bot's reply (TELEGRAM_BOT_REPLY_TIMEOUT_MS). */
+  telegramBotReplyTimeoutMs: number;
+  /**
+   * After the last message/edit from the triggered bot, wait this many ms of
+   * silence before treating the reply as finished (TELEGRAM_BOT_SETTLE_MS).
+   * Streaming bots that edit one message need this "typing done" equivalent.
+   */
+  telegramBotSettleMs: number;
 }
 
 export function loadConfig(): AppConfig {
@@ -205,9 +279,17 @@ export function loadConfig(): AppConfig {
     ? resolve(expandHome(process.env.LOG_FILE.trim()))
     : join(logsDir, "grok-telegram-bot.log");
 
+  const allowedParsed = parseAllowedUsers(process.env.ALLOWED_USERS);
+  if (allowedParsed.dropped.length > 0) {
+    // Avoid importing logger at top (config loads early); stderr is fine at boot.
+    console.warn(
+      `[config] ALLOWED_USERS ignored non-numeric token(s): ${allowedParsed.dropped.join(", ")}`,
+    );
+  }
   const cfg: AppConfig = {
     token,
-    allowedUsers: new Set(list(process.env.ALLOWED_USERS)),
+    allowedUsers: allowedParsed.ids,
+    allowAllUsers: allowedParsed.allowAll,
     grokCliPath: resolveGrokPath(process.env.GROK_CLI_PATH?.trim()),
     workspace,
     grokApiKey: process.env.XAI_API_KEY?.trim() || process.env.GROK_API_KEY?.trim() || undefined,
@@ -264,11 +346,128 @@ export function loadConfig(): AppConfig {
       true,
     ),
     selfRecheckPrompt: (process.env.SELF_RECHECK_PROMPT ?? "").trim(),
+    quietPromptTimeoutMs: num(process.env.QUIET_PROMPT_TIMEOUT_MS, 90_000),
+    topicGroupId: parseTopicGroupId(
+      process.env.TOPIC_GROUP_ID ?? process.env.FORUM_GROUP_ID,
+    ),
+    topicAutoCreateProjects: bool(process.env.TOPIC_AUTO_CREATE, true),
+    topicAiChatName: (process.env.TOPIC_AI_CHAT_NAME ?? "AI Chat").trim() || "AI Chat",
+    allowedTelegramBots: parseTelegramBotUsernames(process.env.ALLOWED_TELEGRAM_BOTS),
+    telegramBotCommands: parseTelegramBotCommands(process.env.TELEGRAM_BOT_COMMANDS),
+    telegramBotReplyTimeoutMs: num(process.env.TELEGRAM_BOT_REPLY_TIMEOUT_MS, 45_000),
+    telegramBotSettleMs: num(process.env.TELEGRAM_BOT_SETTLE_MS, 2_000),
   };
 
   return cfg;
 }
 
+/** Normalize comma-separated bot usernames (strip @, lowercase, unique). */
+export function parseTelegramBotUsernames(raw: string | undefined): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const t of list(raw)) {
+    const u = t.replace(/^@/, "").toLowerCase();
+    if (!u || seen.has(u)) continue;
+    // Telegram usernames: 5–32 characters (letter first, then alnum/underscore).
+    if (!/^[a-z][a-z0-9_]{4,31}$/i.test(u)) continue;
+    seen.add(u);
+    out.push(u);
+  }
+  return out;
+}
+
+/**
+ * Parse optional command catalogs.
+ *
+ * Formats (both supported):
+ *  1) Compact: `helperbot:status,help,ping;otherbot:start|Start the bot,info`
+ *     - `;` separates bots, `:` separates username from commands
+ *     - `,` separates commands; optional `cmd|description`
+ *  2) JSON object: `{"helperbot":["status","help"],"otherbot":[{"command":"start","description":"…"}]}`
+ */
+export function parseTelegramBotCommands(
+  raw: string | undefined,
+): Record<string, Array<{ command: string; description?: string }>> {
+  const out: Record<string, Array<{ command: string; description?: string }>> = {};
+  if (raw === undefined || raw.trim() === "") return out;
+  const trimmed = raw.trim();
+
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed) as unknown;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        for (const [key, val] of Object.entries(parsed as Record<string, unknown>)) {
+          const u = key.replace(/^@/, "").toLowerCase();
+          if (!u) continue;
+          const cmds = normalizeCommandList(val);
+          if (cmds.length) out[u] = cmds;
+        }
+      }
+    } catch {
+      /* fall through to compact parser */
+    }
+    if (Object.keys(out).length > 0) return out;
+  }
+
+  for (const botPart of trimmed.split(";")) {
+    const piece = botPart.trim();
+    if (!piece) continue;
+    const colon = piece.indexOf(":");
+    if (colon <= 0) continue;
+    const u = piece.slice(0, colon).replace(/^@/, "").toLowerCase().trim();
+    if (!u) continue;
+    const rest = piece.slice(colon + 1).trim();
+    if (!rest) continue;
+    const cmds = normalizeCommandList(rest.split(",").map((s) => s.trim()).filter(Boolean));
+    if (cmds.length) out[u] = cmds;
+  }
+  return out;
+}
+
+function normalizeCommandList(
+  val: unknown,
+): Array<{ command: string; description?: string }> {
+  const items: unknown[] = Array.isArray(val)
+    ? val
+    : typeof val === "string"
+      ? val.split(",").map((s) => s.trim()).filter(Boolean)
+      : [];
+  const seen = new Set<string>();
+  const out: Array<{ command: string; description?: string }> = [];
+  for (const item of items) {
+    let command = "";
+    let description: string | undefined;
+    if (typeof item === "string") {
+      const pipe = item.indexOf("|");
+      if (pipe >= 0) {
+        command = item.slice(0, pipe).trim();
+        description = item.slice(pipe + 1).trim() || undefined;
+      } else {
+        command = item.trim();
+      }
+    } else if (item && typeof item === "object") {
+      const rec = item as Record<string, unknown>;
+      command = String(rec.command ?? rec.cmd ?? rec.name ?? "").trim();
+      const d = String(rec.description ?? rec.desc ?? rec.help ?? "").trim();
+      if (d) description = d;
+    }
+    command = command.replace(/^\//, "").toLowerCase();
+    if (!command || !/^[a-z0-9_]{1,32}$/.test(command) || seen.has(command)) continue;
+    seen.add(command);
+    out.push(description ? { command, description: description.slice(0, 120) } : { command });
+    if (out.length >= 40) break;
+  }
+  return out;
+}
+
+/** Parse a Telegram chat/group id (may be negative for supergroups). */
+function parseTopicGroupId(v: string | undefined): number | undefined {
+  if (v === undefined || v.trim() === "") return undefined;
+  const n = Number(v.trim());
+  if (!Number.isFinite(n) || n === 0) return undefined;
+  return Math.trunc(n);
+}
+
 /** Parse 0–100 percentage; blank → default. */
 function clampPct(v: string | undefined, def: number): number {
   if (v === undefined || v === "") return def;

package/src/forum/bind-path.ts

@@ -0,0 +1,146 @@
+/**
+ * Pure resolution of unbound-topic bind text: absolute directory path or
+ * exact catalog project name only (no fuzzy/partial matches).
+ */
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+
+export type BindProjectLookup = {
+  name: string;
+  path: string;
+};
+
+export type ResolveBindTargetResult =
+  | { ok: true; path: string; created?: boolean }
+  | { ok: false; error: string };
+
+/** Strip quotes/backticks and expand leading ~. */
+export function normalizeBindInput(text: string): string {
+  let raw = text.trim().replace(/^["'`]+|["'`]+$/g, "").trim();
+  if (!raw) return "";
+  // Expand ~ / ~/foo
+  if (raw === "~") raw = homedir();
+  else if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    raw = join(homedir(), raw.slice(2));
+  }
+  return raw;
+}
+
+/** Safe single-segment project folder name (no path separators / drive). */
+export function isSafeProjectFolderName(name: string): boolean {
+  const t = name.trim();
+  if (!t || t.length > 80) return false;
+  if (/[\\/]/.test(t)) return false;
+  if (/^[a-zA-Z]:/.test(t)) return false; // drive letter
+  if (/[<>:"|?*\x00-\x1f]/.test(t)) return false;
+  if (t === "." || t === "..") return false;
+  return true;
+}
+
+/**
+ * Resolve user text to a project directory.
+ * - Existing filesystem path (absolute or resolvable) that is a directory
+ * - Exact catalog project name (case-insensitive)
+ * - Optional: create missing **absolute** directories (agent new-project flow)
+ * - Optional: create `defaultRoot/<safeName>` for a simple name when missing
+ * Never uses substring / partial name matching for catalog lookup.
+ */
+export function resolveBindTarget(
+  text: string,
+  opts: {
+    existsSync: (p: string) => boolean;
+    isDirectory: (p: string) => boolean;
+    findExactByName: (name: string) => BindProjectLookup | undefined;
+    /**
+     * When true, if path is absolute and missing, create the directory.
+     * Also creates `defaultRoot/<name>` for a safe single-segment name.
+     */
+    createIfMissing?: boolean;
+    mkdirSync?: (p: string) => void;
+    /** First PROJECT_ROOTS entry — used to create new projects by short name. */
+    defaultRoot?: string;
+  },
+): ResolveBindTargetResult {
+  const raw = normalizeBindInput(text);
+  if (!raw) return { ok: false, error: "Empty path." };
+
+  if (opts.existsSync(raw)) {
+    const path = resolve(raw);
+    if (!opts.isDirectory(path)) {
+      return { ok: false, error: `Not a directory: ${path}` };
+    }
+    return { ok: true, path };
+  }
+
+  // Absolute path that does not exist yet — agent "create project + topic" flow.
+  // Only isAbsolute(raw) so relative names never mkdir under process cwd.
+  if (opts.createIfMissing && isAbsolute(raw)) {
+    const absCandidate = resolve(raw);
+    if (!opts.existsSync(absCandidate)) {
+      const made = tryMkdir(absCandidate, opts);
+      if (!made.ok) return made;
+      return { ok: true, path: absCandidate, created: true };
+    }
+  }
+
+  const hit = opts.findExactByName(raw);
+  if (hit) {
+    if (!opts.isDirectory(hit.path)) {
+      return { ok: false, error: `Not a directory: ${hit.path}` };
+    }
+    return { ok: true, path: hit.path };
+  }
+
+  // Short project name → create under first PROJECT_ROOTS (agent new project).
+  if (
+    opts.createIfMissing &&
+    opts.defaultRoot &&
+    opts.mkdirSync &&
+    isSafeProjectFolderName(raw)
+  ) {
+    const full = resolve(opts.defaultRoot, raw.trim().replace(/[<>:"/\\|?*]/g, "_"));
+    if (opts.existsSync(full)) {
+      if (!opts.isDirectory(full)) {
+        return { ok: false, error: `Not a directory: ${full}` };
+      }
+      return { ok: true, path: full };
+    }
+    const made = tryMkdir(full, opts);
+    if (!made.ok) return made;
+    return { ok: true, path: full, created: true };
+  }
+
+  return {
+    ok: false,
+    error:
+      `Path not found: "${raw}". Use an absolute folder path (missing folders are created), ` +
+      `a simple project name under PROJECT_ROOTS, or an **exact** catalog name.`,
+  };
+}
+
+function tryMkdir(
+  absCandidate: string,
+  opts: {
+    mkdirSync?: (p: string) => void;
+    isDirectory: (p: string) => boolean;
+  },
+): { ok: true } | { ok: false; error: string } {
+  if (!opts.mkdirSync) {
+    return {
+      ok: false,
+      error: `Path does not exist and cannot create: ${absCandidate}`,
+    };
+  }
+  try {
+    opts.mkdirSync(absCandidate);
+  } catch (e) {
+    return {
+      ok: false,
+      error: `Could not create directory ${absCandidate}: ${(e as Error).message}`,
+    };
+  }
+  if (!opts.isDirectory(absCandidate)) {
+    return { ok: false, error: `Not a directory after create: ${absCandidate}` };
+  }
+  return { ok: true };
+}