grok-telegram-bot 2.4.0 → 2.5.0

package/src/bot/registry.ts

@@ -18,7 +18,7 @@ import type { AppConfig } from "../config.js";
 import { subagentSummary } from "../render/subagent.js";
 import type { SessionStore } from "../sessions/store.js";
 import type { AccountRotator } from "./account-rotator.js";
-import { ChatController } from "./chat-controller.js";
+import { ChatController, type ChatBridgeServices } from "./chat-controller.js";
 import type { SessionRuntime } from "./session-runtime.js";
 
 export interface SessionDescription {
@@ -34,8 +34,14 @@ export interface SessionDescription {
 
 export class RuntimeRegistry {
   private readonly controllers = new Map<number, ChatController>();
+  /**
+   * Forum topic controllers keyed by `chatId:threadId`.
+   * Each topic has its own multi-session controller + settings (model/reasoning).
+   */
+  private readonly forumControllers = new Map<string, ChatController>();
   private refresher: ((chatId: number) => void) | undefined;
   private rotator: AccountRotator | undefined;
+  private bridge: ChatBridgeServices | undefined;
   /** Chat ids with a running turn, most-recently-started last. */
   private readonly activeChats: number[] = [];
   /** Subagent sessionId -> owner chat id. */
@@ -60,6 +66,13 @@ export class RuntimeRegistry {
     this.rotator = rotator;
   }
 
+  /** Telegram bridge services (forum, session store, sibling bots). */
+  setBridge(bridge: ChatBridgeServices): void {
+    this.bridge = bridge;
+    for (const c of this.controllers.values()) c.bridge = bridge;
+    for (const c of this.forumControllers.values()) c.bridge = bridge;
+  }
+
   controller(chatId: number): ChatController {
     let c = this.controllers.get(chatId);
     if (!c) {
@@ -74,6 +87,7 @@ export class RuntimeRegistry {
         (busy) => this.noteActivity(chatId, busy),
         () => this.rotator,
       );
+      c.bridge = this.bridge;
       this.controllers.set(chatId, c);
     }
     return c;
@@ -84,9 +98,78 @@ export class RuntimeRegistry {
     return this.controller(chatId).foreground();
   }
 
+  /**
+   * Multi-session controller for a forum topic (fixed project path).
+   * Settings key: `{chatId}:t{threadId}` — own model / reasoning / sessions.
+   */
+  forumController(
+    chatId: number,
+    threadId: number,
+    cwd: string,
+    projectName?: string,
+  ): ChatController {
+    const key = `${chatId}:${threadId}`;
+    let c = this.forumControllers.get(key);
+    if (c && c.fixedCwd && normPath(c.fixedCwd) !== normPath(cwd)) {
+      // Path re-bind — dispose and recreate.
+      c.dispose();
+      this.forumControllers.delete(key);
+      c = undefined;
+    }
+    if (!c) {
+      c = new ChatController(
+        this.api,
+        chatId,
+        this.acp,
+        this.cfg,
+        this.settings,
+        this.store,
+        (id) => this.refresher?.(id),
+        (busy) => this.noteActivity(chatId, busy),
+        () => this.rotator,
+        {
+          messageThreadId: threadId,
+          settingsKey: `${chatId}:t${threadId}`,
+          fixedCwd: cwd,
+          fixedProjectName: projectName,
+        },
+      );
+      c.bridge = this.bridge;
+      this.forumControllers.set(key, c);
+    }
+    return c;
+  }
+
+  /**
+   * Foreground runtime for a forum topic. Creates the topic controller lazily.
+   */
+  getForumTopic(
+    chatId: number,
+    threadId: number,
+    cwd: string,
+    projectName?: string,
+  ): SessionRuntime {
+    return this.forumController(chatId, threadId, cwd, projectName).foreground();
+  }
+
+  /** All forum topic controllers (for bidirectional session listing). */
+  allForumControllers(): ChatController[] {
+    return [...this.forumControllers.values()];
+  }
+
+  /** Forum controller that currently owns a session id, if any. */
+  forumControllerForSession(sessionId: string): ChatController | undefined {
+    for (const c of this.forumControllers.values()) {
+      if (c.findBySession(sessionId)) return c;
+    }
+    return undefined;
+  }
+
   disposeAll(): void {
     for (const c of this.controllers.values()) c.dispose();
     this.controllers.clear();
+    for (const c of this.forumControllers.values()) c.dispose();
+    this.forumControllers.clear();
   }
 
   /** Find the chat that currently controls a given session id. */
@@ -94,6 +177,12 @@ export class RuntimeRegistry {
     for (const [chatId, c] of this.controllers) {
       if (c.findBySession(sessionId)) return chatId;
     }
+    for (const [key, c] of this.forumControllers) {
+      if (c.findBySession(sessionId)) {
+        const chatId = Number(key.split(":")[0]);
+        return Number.isFinite(chatId) ? chatId : undefined;
+      }
+    }
     return undefined;
   }
 
@@ -184,3 +273,7 @@ export class RuntimeRegistry {
     }
   }
 }
+
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}

package/src/bot/scope.ts

@@ -0,0 +1,94 @@
+/**
+ * Resolve private-chat vs forum-topic scope for handlers (menu, running, sessions).
+ * Forum topics use a dedicated ChatController with per-topic settings + sessions.
+ */
+import type { Context } from "grammy";
+import type { BotDeps } from "./deps.js";
+import type { ChatController } from "./chat-controller.js";
+import type { SessionRuntime } from "./session-runtime.js";
+import { forumThreadId } from "../forum/thread.js";
+import { FORUM_GENERAL_THREAD_ID } from "../forum/thread.js";
+
+export interface HandlerScope {
+  chatId: number;
+  /** Forum message_thread_id when in the configured topic group. */
+  threadId?: number;
+  isForum: boolean;
+  /** Settings key for this scope (chat or chat:t{thread}). */
+  settingsKey: string;
+  controller: ChatController;
+  /** Foreground runtime for this scope. */
+  rt: SessionRuntime;
+  /** Extra fields so replies land in the same topic. */
+  threadExtra: { message_thread_id?: number };
+  /** Project path when forum topic is bound. */
+  projectPath?: string;
+  projectName?: string;
+}
+
+/** Build settings storage key. */
+export function settingsKeyFor(chatId: number, threadId?: number): string {
+  if (threadId === undefined) return String(chatId);
+  return `${chatId}:t${threadId}`;
+}
+
+/** Extract thread id from message or callback message. */
+export function threadIdFromContext(ctx: Context): number | undefined {
+  const msg = ctx.message ?? ctx.callbackQuery?.message;
+  if (!msg || !("message_thread_id" in msg)) return undefined;
+  const tid = (msg as { message_thread_id?: number }).message_thread_id;
+  return typeof tid === "number" ? tid : undefined;
+}
+
+/**
+ * Resolve handler scope. For the forum group, ensures topic binding (General →
+ * workspace) and returns the topic's ChatController + foreground runtime.
+ */
+export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
+  const chatId = ctx.chat!.id;
+  const rawThread = threadIdFromContext(ctx);
+  const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+  const threadExtra =
+    isForum || rawThread !== undefined
+      ? { message_thread_id: isForum ? forumThreadId(rawThread) : rawThread }
+      : {};
+
+  if (!isForum || !deps.forum) {
+    const controller = deps.registry.controller(chatId);
+    return {
+      chatId,
+      isForum: false,
+      settingsKey: settingsKeyFor(chatId),
+      controller,
+      rt: controller.foreground(),
+      threadExtra: rawThread !== undefined ? { message_thread_id: rawThread } : {},
+    };
+  }
+
+  const tid = forumThreadId(rawThread);
+  // Ensure General / AI paths are bound before opening menus.
+  if (tid === FORUM_GENERAL_THREAD_ID) {
+    if (!deps.forum.store.get(tid)?.projectPath) {
+      deps.forum.store.bindProject(tid, deps.cfg.workspace, "General", "general");
+    }
+  }
+  const resolved = deps.forum.resolveCwd(tid);
+  const cwd = resolved?.cwd ?? deps.cfg.workspace;
+  const projectName = resolved?.projectName ?? (tid === FORUM_GENERAL_THREAD_ID ? "General" : `Topic ${tid}`);
+  if (!resolved && tid !== FORUM_GENERAL_THREAD_ID) {
+    // Unbound topic — still allow menu with workspace fallback for prefs; path
+    // bind happens on next text message via resolveForumRuntime.
+  }
+  const controller = deps.registry.forumController(chatId, tid, cwd, projectName);
+  return {
+    chatId,
+    threadId: tid,
+    isForum: true,
+    settingsKey: settingsKeyFor(chatId, tid),
+    controller,
+    rt: controller.foreground(),
+    threadExtra: { message_thread_id: tid },
+    projectPath: cwd,
+    projectName,
+  };
+}