grok-telegram-bot 2.4.0 → 2.5.0

package/src/app/settings-store.ts

@@ -1,6 +1,8 @@
 /**
- * Per-chat settings persistence (project, agent, model, reasoning, pinned
- * status message id). Backed by a single JSON file so state survives restarts.
+ * Per-chat / per-forum-topic settings persistence (project, agent, model,
+ * reasoning, pinned status message id, controlled sessions).
+ * Keys: `"12345"` for private chats, `"12345:t7"` for forum topic thread 7.
+ * Backed by a single JSON file so state survives restarts.
  */
 import { join } from "node:path";
 import { JsonStore } from "./json-store.js";
@@ -15,24 +17,61 @@ export class SettingsStore {
     this.store = new JsonStore<SettingsMap>(join(dataDir, "settings.json"), {});
   }
 
+  /** Settings for a private chat (or legacy callers). */
   get(chatId: number): ChatSettings {
-    const existing = this.store.get()[String(chatId)];
+    return this.getKey(String(chatId));
+  }
+
+  /** Settings by storage key (`chatId` or `chatId:t{threadId}`). */
+  getKey(key: string): ChatSettings {
+    const existing = this.store.get()[key];
     return existing ?? defaultSettings();
   }
 
   update(chatId: number, patch: Partial<ChatSettings>): ChatSettings {
-    const key = String(chatId);
-    const next = { ...this.get(chatId), ...patch };
+    return this.updateKey(String(chatId), patch);
+  }
+
+  updateKey(key: string, patch: Partial<ChatSettings>): ChatSettings {
+    const next = { ...this.getKey(key), ...patch };
     this.store.update((m) => {
       m[key] = next;
     });
     return next;
   }
 
+  /**
+   * All settings entries whose projectPath matches (for bidirectional
+   * bot ↔ forum session discovery).
+   */
+  entriesForProject(projectPath: string): Array<{ key: string; settings: ChatSettings }> {
+    const want = normPath(projectPath);
+    const out: Array<{ key: string; settings: ChatSettings }> = [];
+    for (const [key, s] of Object.entries(this.store.get())) {
+      if (s.projectPath && normPath(s.projectPath) === want) {
+        out.push({ key, settings: s });
+      }
+      for (const cs of s.controlledSessions ?? []) {
+        if (cs.projectPath && normPath(cs.projectPath) === want) {
+          out.push({ key, settings: s });
+          break;
+        }
+      }
+    }
+    return out;
+  }
+
   /** All chat ids that have interacted (for broadcast announcements). */
   chatIds(): number[] {
-    return Object.keys(this.store.get())
-      .map(Number)
-      .filter((n) => Number.isFinite(n));
+    const ids = new Set<number>();
+    for (const key of Object.keys(this.store.get())) {
+      const n = Number(key.split(":")[0]);
+      if (Number.isFinite(n)) ids.add(n);
+    }
+    return [...ids];
   }
 }
+
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}

package/src/app/types.ts

@@ -13,6 +13,11 @@ export interface ChatSettings {
   agent?: string;
   model?: string;
   reasoning: ReasoningEffort;
+  /**
+   * Preferred saved Grok account login id for this chat/topic (optional).
+   * Applied when starting turns if different from the process-active account.
+   */
+  preferredAccountId?: string;
   /** Telegram message id of the pinned status panel, if any. */
   statusMessageId?: number;
   /** Sessions this chat controls (for multi-session switching). */
@@ -57,6 +62,11 @@ export interface PromptInput {
   resourceLinks?: PromptResourceLink[];
   /** Telegram message id of the prompt, so the reply threads to it. */
   replyTo?: number;
+  /**
+   * Short id for the bot-owned prompt anchor (`#prompt_<id>`). All AI messages
+   * for this turn carry the same tag so the user can search related replies.
+   */
+  promptId?: string;
   /**
    * Content of the message the user was replying to (or the portion they
    * quoted). Injected as context so the agent sees what the user is responding
@@ -74,13 +84,14 @@ export function textPrompt(
   text: string,
   replyTo?: number,
   quotedText?: string,
-  opts?: { skipSelfRecheck?: boolean },
+  opts?: { skipSelfRecheck?: boolean; promptId?: string },
 ): PromptInput {
   return {
     text,
     images: [],
     resourceLinks: [],
     replyTo,
+    promptId: opts?.promptId,
     quotedText,
     skipSelfRecheck: opts?.skipSelfRecheck,
   };

package/src/app/updater.ts

@@ -17,6 +17,7 @@ import { get } from "node:https";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { JsonStore } from "./json-store.js";
+import { markIntentionalShutdown } from "./lifetime-flag.js";
 import { createLogger } from "../logger.js";
 import { extractChangelog, isNewer, isSafeVersion } from "./version.js";
 
@@ -145,27 +146,47 @@ export class Updater {
   }
 
   private async restart(): Promise<void> {
+    // Signal main/beforeExit that this exit is intentional (avoid keep-alive race).
+    markIntentionalShutdown("updater-reexec");
     await this.opts.shutdown().catch(() => {});
     // Under systemd/launchd, a clean exit triggers a managed relaunch (no double
     // instance). On Windows / foreground there is no supervisor, so re-exec.
     if (process.env.GROK_TG_SUPERVISED === "1") {
       log.info("exiting for supervisor to relaunch the updated bot");
+      try {
+        process.stderr.write("[updater] supervised exit for relaunch\n");
+      } catch {
+        /* ignore */
+      }
       setTimeout(() => process.exit(0), 250);
       return;
     }
     log.info("re-executing the updated bot");
     try {
+      // TTY: inherit stdio so `npm start` doesn't look like a silent death.
+      // Non-TTY (service): detach and ignore stdio.
+      const inherit = Boolean(process.stdout.isTTY);
       const child = spawn(
         process.execPath,
         ["--import", "tsx", join(this.opts.projectRoot, "src", "index.ts"), "--instance", this.opts.instanceDir],
-        { detached: true, stdio: "ignore", cwd: this.opts.projectRoot, env: process.env },
+        {
+          detached: !inherit,
+          stdio: inherit ? "inherit" : "ignore",
+          cwd: this.opts.projectRoot,
+          env: process.env,
+        },
       );
-      child.unref();
+      if (!inherit) child.unref();
       if (!child.pid) {
         log.error("re-exec spawn produced no pid — staying alive");
         return;
       }
-      log.info(`re-exec child pid ${child.pid}`);
+      log.info(`re-exec child pid ${child.pid} (stdio=${inherit ? "inherit" : "ignore"})`);
+      try {
+        process.stderr.write(`[updater] re-exec child pid ${child.pid}; parent exiting\n`);
+      } catch {
+        /* ignore */
+      }
     } catch (e) {
       // Never exit if replacement failed — silent death is worse than stale code.
       log.error(`re-exec failed: ${(e as Error).message} — staying alive`);

package/src/bot/auth.ts

@@ -1,5 +1,12 @@
 /**
  * Authorization middleware: restricts the bot to ALLOWED_USERS when configured.
+ *
+ * Applies to **private chats and groups/forum topics alike**. User IDs are
+ * comma-separated in env (`ALLOWED_USERS=111,222,333`). Empty set = allow all
+ * (unsafe — especially with TOPIC_GROUP_ID).
+ *
+ * Unauthorized users in groups are ignored silently (no ⛔ spam). Private chats
+ * get one clear denial. Callback taps get a toast.
  */
 import type { Context, NextFunction } from "grammy";
 import type { AppConfig } from "../config.js";
@@ -8,31 +15,105 @@ import { createLogger } from "../logger.js";
 const log = createLogger("auth");
 
 export function createAuthMiddleware(cfg: AppConfig) {
-  const allowAll = cfg.allowedUsers.size === 0;
-  if (allowAll) {
+  if (cfg.allowAllUsers) {
     log.warn("ALLOWED_USERS is empty — the bot will respond to ANY Telegram user.");
+    if (cfg.topicGroupId !== undefined) {
+      log.warn(
+        "TOPIC_GROUP_ID is set with empty ALLOWED_USERS — any group member can drive sessions.",
+      );
+    }
+  } else {
+    log.info(`ALLOWED_USERS: ${cfg.allowedUsers.size} id(s) (private + groups)`);
+    if (cfg.allowedUsers.size === 0) {
+      log.warn(
+        "ALLOWED_USERS was set but no valid numeric ids remain — denying everyone (fail closed).",
+      );
+    }
   }
 
   return async (ctx: Context, next: NextFunction): Promise<void> => {
+    // Bot membership changes (promote/demote) must always reach handlers so
+    // forum readiness can re-probe — not gated on ALLOWED_USERS or from.is_bot.
+    if (ctx.myChatMember) {
+      await next();
+      return;
+    }
+
     const from = ctx.from;
-    // Only a genuine USER action is subject to (and worth replying to) the auth
-    // gate. Ignore everything else silently — most importantly the bot's OWN
-    // updates: the status panel being pinned/unpinned emits a service message
-    // whose `from` is THIS bot (is_bot), and replying "⛔ Not authorized" to
-    // that (or to any service/no-`from` update) spammed the chat with false
-    // rejections. Real unauthorized users still get one clear reply below.
+    // Only a genuine USER action is subject to the auth gate. Ignore bot-authored
+    // updates and missing `from` (service noise) so we never ⛔-spam ourselves.
     if (!from || from.is_bot) return;
     const m = ctx.message ?? ctx.editedMessage;
-    if (m && (m.pinned_message || m.new_chat_members || m.left_chat_member)) return;
+    if (
+      m &&
+      (m.pinned_message ||
+        m.new_chat_members ||
+        m.left_chat_member ||
+        m.forum_topic_closed ||
+        m.forum_topic_reopened ||
+        m.forum_topic_edited ||
+        m.general_forum_topic_hidden ||
+        m.general_forum_topic_unhidden)
+    ) {
+      return;
+    }
 
-    const userId = String(from.id);
-    if (allowAll || cfg.allowedUsers.has(userId)) {
-      await next();
+    // forum_topic_created: only allowed users get the path-bind prompt.
+    if (m?.forum_topic_created) {
+      if (isAllowed(cfg, from.id)) {
+        await next();
+        return;
+      }
+      log.debug(`blocked unauthorized forum_topic_created from ${from.id}`);
       return;
     }
-    log.warn(`blocked unauthorized user ${userId}`);
-    if (ctx.chat) {
-      await ctx.reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID.");
+
+    if (isAllowed(cfg, from.id)) {
+      await next();
+      return;
     }
+
+    log.warn(
+      `blocked unauthorized user ${from.id}` +
+        (ctx.chat ? ` in chat ${ctx.chat.id} (${ctx.chat.type})` : ""),
+    );
+    await denyUnauthorized(ctx, m);
   };
 }
+
+/**
+ * True when ALLOWED_USERS was blank (open) or `userId` is listed.
+ * When allowAllUsers is false and the set is empty, nobody is allowed.
+ */
+export function isAllowed(cfg: AppConfig, userId: number | string): boolean {
+  if (cfg.allowAllUsers) return true;
+  return cfg.allowedUsers.has(String(userId));
+}
+
+/** Groups, supergroups, and channels: never ⛔-reply (silent deny). */
+function isGroupChat(ctx: Context): boolean {
+  const t = ctx.chat?.type;
+  return t === "group" || t === "supergroup" || t === "channel";
+}
+
+/** Private: one ⛔ reply. Group: silent (or callback toast). Never spam topics. */
+async function denyUnauthorized(
+  ctx: Context,
+  m: { message_thread_id?: number } | undefined,
+): Promise<void> {
+  if (ctx.callbackQuery) {
+    await ctx
+      .answerCallbackQuery({
+        text: "\u26D4 Not authorized",
+        show_alert: true,
+      })
+      .catch(() => {});
+    return;
+  }
+  if (!ctx.chat || isGroupChat(ctx)) return; // groups: ignore quietly
+  const threadId = m && "message_thread_id" in m ? m.message_thread_id : undefined;
+  const extra = threadId !== undefined ? { message_thread_id: threadId as number } : {};
+  await ctx
+    .reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID to ALLOWED_USERS.", extra)
+    .catch(() => {});
+}

package/src/bot/bot.ts

@@ -22,7 +22,7 @@ import { Scheduler } from "../tasks/scheduler.js";
 import { TaskStore } from "../tasks/store.js";
 import { createAuthMiddleware } from "./auth.js";
 import { isStaleCallbackError, safeCallbackMiddleware } from "./callback.js";
-import { COMMANDS } from "./commands.js";
+import { COMMANDS, GROUP_COMMANDS } from "./commands.js";
 import { type BotDeps, MenuCache } from "./deps.js";
 import { registerControl } from "./handlers/control.js";
 import { registerDocuments } from "./handlers/document.js";
@@ -43,6 +43,7 @@ import { registerSystem } from "./handlers/system.js";
 import { registerTasks, registerWizardInput } from "./handlers/tasks.js";
 import { registerUsage } from "./handlers/usage.js";
 import { registerVoice } from "./handlers/voice.js";
+import { registerForum } from "./handlers/forum.js";
 import { StatusPanel } from "./menu/status-panel.js";
 import { sendMarkdownDoc } from "./telegram-io.js";
 import { Ephemeral } from "./menu/ephemeral.js";
@@ -50,6 +51,8 @@ import { BAR_LABELS } from "./menu/keyboard.js";
 import { PermissionService } from "./permission-service.js";
 import { RuntimeRegistry } from "./registry.js";
 import { TaskWizard } from "./wizard/task-wizard.js";
+import { ForumManager } from "../forum/manager.js";
+import { TelegramBotService } from "./telegram-bots.js";
 
 const log = createLogger("bot");
 
@@ -99,13 +102,44 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   const statusPanel = new StatusPanel(bot.api, settings, registry);
   registry.setRefresher((chatId) => void statusPanel.refresh(chatId));
 
+  const projects = new ProjectManager(cfg.projectRoots);
+  const forum =
+    cfg.topicGroupId !== undefined
+      ? new ForumManager(bot.api, cfg, projects)
+      : undefined;
+
+  // Sibling bots + memory/topic actions for the agent telegram JSON bridge.
+  const telegramBots = new TelegramBotService(bot.api, cfg);
+  telegramBots.attachToBot(bot);
+  registry.setBridge({
+    store,
+    forum,
+    bots: telegramBots,
+    // Cross-topic orchestration: General can create a topic and send_prompt there.
+    submitTopicPrompt: async ({ threadId, cwd, projectName, prompt, newSession }) => {
+      if (cfg.topicGroupId === undefined) {
+        throw new Error("TOPIC_GROUP_ID unset");
+      }
+      const groupId = cfg.topicGroupId;
+      const controller = registry.forumController(groupId, threadId, cwd, projectName);
+      if (newSession) {
+        const rt = await controller.addNew(cwd, projectName);
+        const outcome = await rt.submit(textPrompt(prompt));
+        return { outcome, sessionId: rt.sessionId };
+      }
+      const rt = controller.foreground();
+      const outcome = await rt.submit(textPrompt(prompt));
+      return { outcome, sessionId: rt.sessionId };
+    },
+  });
+
   const deps: BotDeps = {
     api: bot.api,
     cfg,
     acp,
     registry,
     store,
-    projects: new ProjectManager(cfg.projectRoots),
+    projects,
     menuCache: new MenuCache(),
     settings,
     statusPanel,
@@ -121,6 +155,7 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     }),
     usage: new UsageService(cfg.grokCliPath),
     accounts: new AccountManager(cfg.dataDir),
+    forum,
   };
 
   // Auto-rotate-on-give-up: let a stuck turn cycle through other saved logins.
@@ -135,6 +170,11 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     onUnpinned: (chatId) => statusPanel.ensurePinned(chatId),
   });
   acp.permissionHandler = (p) => permissions.handle(p);
+  // /stop and /cancel must cancel pending interactive permissions for that
+  // session only (ACP requires cancelled outcomes) — never kill the agent.
+  acp.onSessionCancel = (sessionId) => {
+    permissions.cancelForSession(sessionId);
+  };
 
   // The bot pins/unpins the status panel, and Telegram emits a "pinned a
   // message" service message for each pin. Delete those so the chat stays clean
@@ -146,14 +186,16 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   // handler forgets (prevents the loading spinner + unhandled 400 noise).
   bot.use(safeCallbackMiddleware());
 
-  // Keep history clean: after handling, delete the user's command (/…) and
-  // persistent-bar button taps. Plain prompts and wizard input are kept.
+  // Keep history clean: delete the user's command (/…) and persistent-bar
+  // button taps INSTANTLY (before handlers) so slow ACP/CLI work never leaves
+  // the raw slash sitting in chat. Handlers post bot status messages instead.
+  // Plain prompts are adopted separately (see prompt-anchor.ts).
   bot.on("message:text", async (ctx, next) => {
-    await next();
     const text = ctx.message?.text ?? "";
     if (text.startsWith("/") || BAR_LABELS.includes(text)) {
-      await ctx.deleteMessage().catch(() => {});
+      void ctx.deleteMessage().catch(() => {});
     }
+    await next();
   });
 
   bot.callbackQuery(/^perm:(\d+):(\d+)$/, async (ctx) => {
@@ -187,7 +229,10 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   bot.callbackQuery(/^sug:(\d+):(\d+)$/, async (ctx) => {
     const batchId = Number(ctx.match![1]);
     const index = Number(ctx.match![2]);
-    const rt = deps.registry.get(ctx.chat!.id);
+    const { resolveScope } = await import("./scope.js");
+    const { adoptUserPrompt } = await import("./prompt-anchor.js");
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
     const text = rt.takeSuggestion(batchId, index);
     if (!text) {
       await ctx.answerCallbackQuery({ text: "Suggestion expired", show_alert: true });
@@ -197,17 +242,45 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
     // Dim the keyboard so double-taps don't re-fire.
     await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } }).catch(() => {});
     try {
-      const outcome = await rt.submit(textPrompt(text, ctx.callbackQuery.message?.message_id));
+      const chatId = ctx.chat?.id;
+      const anchor =
+        chatId !== undefined
+          ? await adoptUserPrompt(deps.api, {
+              chatId,
+              text,
+              userMessageIds: [],
+              messageThreadId: scope.threadExtra.message_thread_id,
+              projectName: rt.projectName,
+              prefix: "\u{1F4A1} Suggestion",
+            })
+          : undefined;
+      const outcome = await rt.submit(
+        textPrompt(text, anchor?.replyTo ?? ctx.callbackQuery.message?.message_id, undefined, {
+          promptId: anchor?.promptId,
+        }),
+      );
       if (outcome === "queued") {
-        await ctx.reply(`\u{1F4E5} Queued suggestion (position ${rt.queueLength}).`).catch(() => {});
+        const extra: Record<string, unknown> = { ...scope.threadExtra };
+        if (anchor?.replyTo !== undefined) {
+          extra.reply_parameters = {
+            message_id: anchor.replyTo,
+            allow_sending_without_reply: true,
+          };
+        }
+        await ctx
+          .reply(`\u{1F4E5} Queued suggestion (position ${rt.queueLength}).`, extra)
+          .catch(() => {});
       }
     } catch (e) {
-      await ctx.reply(`\u274C Couldn't run suggestion: ${(e as Error).message}`).catch(() => {});
+      await ctx
+        .reply(`\u274C Couldn't run suggestion: ${(e as Error).message}`, scope.threadExtra)
+        .catch(() => {});
     }
   });
 
   registerMenu(bot, deps); // persistent-keyboard buttons (hears)
   registerWizardInput(bot, deps); // wizard text input (before commands)
+  if (forum) registerForum(bot, deps, forum);
   registerControl(bot, deps);
   registerProjects(bot, deps);
   registerSessions(bot, deps);
@@ -234,13 +307,40 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
       log.debug("stale callback query:", err.error instanceof Error ? err.error.message : err.error);
       return;
     }
-    log.error("unhandled bot error:", err.error instanceof Error ? err.error.message : err.error);
+    const e = err.error;
+    if (e instanceof Error) {
+      // Include Grammy error_code when present (429 / 403 / 409, etc.) for diagnosis.
+      const codeNum = (e as unknown as { error_code?: number }).error_code;
+      const code = typeof codeNum === "number" ? ` (code ${codeNum})` : "";
+      log.error(`unhandled bot error${code}:`, e.stack || e.message);
+    } else {
+      log.error("unhandled bot error:", e);
+    }
+    // Never rethrow — a middleware failure must not take down long polling.
   });
 
-  try {
-    await bot.api.setMyCommands(COMMANDS);
-  } catch (e) {
-    log.warn("setMyCommands failed:", (e as Error).message);
+  // Scoped command menus: private = full sorted list; groups = short list with
+  // cancel/menu first (reply keyboard is unreliable in forum topics).
+  const registerCommands = async (
+    commands: typeof COMMANDS,
+    scope?: { type: string; chat_id?: number },
+    label = "default",
+  ): Promise<void> => {
+    try {
+      await bot.api.setMyCommands(commands, scope ? { scope: scope as never } : undefined);
+    } catch (e) {
+      log.warn(`setMyCommands (${label}) failed:`, (e as Error).message);
+    }
+  };
+  await registerCommands(COMMANDS, undefined, "default");
+  await registerCommands(COMMANDS, { type: "all_private_chats" }, "private");
+  await registerCommands(GROUP_COMMANDS, { type: "all_group_chats" }, "groups");
+  if (cfg.topicGroupId !== undefined) {
+    await registerCommands(
+      GROUP_COMMANDS,
+      { type: "chat", chat_id: cfg.topicGroupId },
+      `chat:${cfg.topicGroupId}`,
+    );
   }
 
   const updater = new Updater({
@@ -278,5 +378,12 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   // Remove any navigation surface left over from before a restart.
   void deps.ephemeral.cleanupAll().catch(() => {});
 
+  // Forum project topics: ensure AI Chat + optional catalog topics (best-effort).
+  if (forum) {
+    void forum.ensureSetup().catch((e) => {
+      log.warn(`forum setup failed: ${(e as Error).message}`);
+    });
+  }
+
   return { bot, registry, scheduler: new Scheduler(tasks, taskRunner), updater };
 }