grok-telegram-bot 2.3.1 → 2.5.0

package/src/bot/handlers/control.ts

@@ -1,28 +1,41 @@
 /**
- * Control commands: /start /help /status /new /cancel /btw /flush.
+ * Control commands: /start /help /status /new /cancel /stop /btw /flush /menu.
+ *
+ * Slash messages are deleted instantly by bot.ts middleware; handlers post
+ * bot status messages so the user always sees the bot is alive (CLI can be slow).
  */
-import type { Bot } from "grammy";
+import type { Bot, Context } from "grammy";
 import { basename } from "node:path";
 import { textPrompt } from "../../app/types.js";
 import type { BotDeps } from "../deps.js";
 import { HELP_TEXT } from "../commands.js";
 import { compactKeyboard } from "../menu/keyboard.js";
 import { refreshMenu } from "../menu/refresh.js";
+import { adoptUserPrompt } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
+import { resolveScope } from "../scope.js";
 import { openMainMenu } from "./menu.js";
 
 export function registerControl(bot: Bot, deps: BotDeps): void {
   bot.command("start", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
     const agent = deps.acp.agentInfo;
+    const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
     const lines = [
       "\u{1F44B} Welcome! I bridge Telegram to Grok Build over ACP.",
       agent?.name ? `Connected to ${agent.name} ${agent.version ?? ""}`.trim() : "",
       "",
-      "Tap \u2630 Menu for everything. A live status panel appears while I work",
-      "(\u2630 Menu \u2192 Status shows it anytime). Just send a message to start.",
+      isGroup || scope.isForum
+        ? "In groups / topics: /menu for controls, /cancel or /stop to halt a turn."
+        : "Bar: \u2630 Menu \u00B7 \u{1F195} New session \u00B7 \u{1F9ED} Running \u00B7 \u23F9 Stop. Live status panel while I work",
+      isGroup || scope.isForum
+        ? "Just send a message in this topic to start."
+        : "(\u2630 Menu \u2192 Status shows it anytime). Just send a message to start.",
     ].filter(Boolean);
-    await ctx.reply(lines.join("\n"), { reply_markup: compactKeyboard() });
+    await ctx.reply(lines.join("\n"), {
+      reply_markup: compactKeyboard(),
+      ...scope.threadExtra,
+    });
     await deps.statusPanel.refresh(ctx.chat.id);
   });
 
@@ -32,71 +45,111 @@ export function registerControl(bot: Bot, deps: BotDeps): void {
   });
 
   bot.command("help", async (ctx) => {
-    await ctx.reply(HELP_TEXT);
+    const scope = resolveScope(ctx, deps);
+    await ctx.reply(HELP_TEXT, scope.threadExtra);
   });
 
   bot.command("status", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
     const lines = [
       "\u{1F4CA} Status",
+      scope.isForum ? `Topic: ${scope.projectName ?? "topic"}` : "",
       `Project: ${rt.projectName ?? (basename(rt.cwd) || rt.cwd)}`,
       `Folder: ${rt.cwd}`,
       `Session: ${rt.sessionId ?? "(none yet)"}`,
+      `Model: ${rt.model || "default"}`,
+      `Reasoning: ${rt.reasoning}`,
       `State: ${rt.isBusy ? "\u23F3 working" : "\u2705 idle"}`,
       `Queued follow-ups: ${rt.queueLength}`,
-    ];
+    ].filter(Boolean);
     const subagents = deps.registry.subagentSummaryForChat(ctx.chat.id);
     if (subagents) lines.push(`Subagents: ${subagents}`);
-    await ctx.reply(lines.join("\n"));
+    await ctx.reply(lines.join("\n"), scope.threadExtra);
   });
 
   bot.command("new", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    // Instant feedback before ACP session/new (can be slow on cold CLI).
+    // Same copy as bar 🆕 New and inline m:new.
+    await ctx.reply("\u2728 Creating new session\u2026", scope.threadExtra).catch(() => {});
     try {
-      await deps.registry.controller(ctx.chat.id).addNew(rt.cwd, rt.projectName);
-      await refreshMenu(ctx, deps, `\u2728 New session started in ${rt.projectName ?? rt.cwd}`);
+      await scope.controller.addNew(scope.rt.cwd, scope.rt.projectName);
+      await refreshMenu(ctx, deps, `\u2728 New session in ${scope.rt.projectName ?? scope.rt.cwd}`);
     } catch (err) {
-      await ctx.reply(`\u274C Could not start session: ${(err as Error).message}`);
+      await ctx.reply(`\u274C ${(err as Error).message}`, scope.threadExtra);
     }
   });
 
-  bot.command("cancel", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
-    const cancelled = await rt.cancel();
-    await ctx.reply(cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.");
-  });
+  const cancelTurn = async (ctx: Context): Promise<void> => {
+    const scope = resolveScope(ctx, deps);
+    const cancelled = await scope.rt.cancel();
+    await ctx.reply(
+      cancelled ? "\u23F9 Cancelling current turn\u2026" : "Nothing is running.",
+      scope.threadExtra,
+    );
+  };
+
+  bot.command("cancel", cancelTurn);
+  bot.command("stop", cancelTurn);
 
   bot.command("btw", async (ctx) => {
     const text = (ctx.match || "").toString().trim();
     if (!text) {
-      await ctx.reply("Usage: /btw <something for the agent to do — now if idle, otherwise next>");
+      const scope = resolveScope(ctx, deps);
+      await ctx.reply(
+        "Usage: /btw <something for the agent to do — now if idle, otherwise next>",
+        scope.threadExtra,
+      );
       return;
     }
-    const rt = deps.registry.get(ctx.chat.id);
-    // Run it right away when idle; otherwise queue it to run automatically the
-    // moment the current turn finishes (can't interrupt an in-flight agent turn).
-    const outcome = await rt.submit(textPrompt(text, undefined, extractReplyContext(ctx)));
+    const scope = resolveScope(ctx, deps);
+    const userMsgId = ctx.message?.message_id;
+    const anchor = await adoptUserPrompt(deps.api, {
+      chatId: ctx.chat.id,
+      text,
+      // Command middleware already deleted the slash message; re-delete is a no-op.
+      userMessageIds: userMsgId !== undefined ? [userMsgId] : [],
+      messageThreadId: scope.threadExtra.message_thread_id,
+      projectName: scope.rt.projectName,
+      prefix: "\u{1F4DD} /btw",
+    });
+    // Fall back to userMsgId if anchor send failed (message may already be gone).
+    const outcome = await scope.rt.submit(
+      textPrompt(text, anchor?.replyTo ?? userMsgId, extractReplyContext(ctx), {
+        promptId: anchor?.promptId,
+      }),
+    );
     if (outcome === "queued") {
+      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 (position ${rt.queueLength}) \u2014 it'll run automatically as soon as the current task finishes.`,
+        `\u{1F4E5} Queued (position ${scope.rt.queueLength}) \u2014 it'll run automatically as soon as the current task finishes.`,
+        extra,
       );
-    } else {
-      await ctx.reply("\u25B6\uFE0F On it\u2026");
     }
   });
 
   bot.command("flush", async (ctx) => {
-    const rt = deps.registry.get(ctx.chat.id);
+    const scope = resolveScope(ctx, deps);
+    const rt = scope.rt;
     if (rt.queueLength === 0) {
-      await ctx.reply("Queue is empty.");
+      await ctx.reply("Queue is empty.", scope.threadExtra);
       return;
     }
     if (rt.isBusy) {
-      await ctx.reply(`\u23F3 ${rt.queueLength} queued \u2014 they'll run automatically when the current turn ends.`);
+      await ctx.reply(
+        `\u23F3 ${rt.queueLength} queued \u2014 they'll run automatically when the current turn ends.`,
+        scope.threadExtra,
+      );
       return;
     }
-    // Idle: drain the queue by submitting an empty trigger that flushes.
-    await ctx.reply("\u25B6\uFE0F Running queued follow-ups\u2026");
+    await ctx.reply("\u25B6\uFE0F Running queued follow-ups\u2026", scope.threadExtra);
     const drained = rt.drainQueueToPrompt();
     if (drained) await rt.submit(drained);
   });

package/src/bot/handlers/document.ts

@@ -57,7 +57,7 @@ export function registerDocuments(bot: Bot, deps: BotDeps): void {
 
     const caption = ctx.message.caption ?? "";
     const quoted = extractReplyContext(ctx);
-    const replyTo = ctx.message.message_id;
+    const userMsgId = ctx.message.message_id;
 
     let promptText: string;
     if (looksLikeText(buf, doc.mime_type, name)) {
@@ -75,10 +75,37 @@ export function registerDocuments(bot: Bot, deps: BotDeps): void {
     }
 
     try {
-      const rt = deps.registry.get(chatId);
-      const outcome = await rt.submit(textPrompt(promptText, replyTo, quoted));
+      const { resolveScope } = await import("../scope.js");
+      const { adoptUserPrompt } = await import("../prompt-anchor.js");
+      const scope = resolveScope(ctx, deps);
+      const anchorPreview = caption.trim() || `File: ${name}`;
+      const anchor = await adoptUserPrompt(deps.api, {
+        chatId,
+        text: anchorPreview,
+        userMessageIds: [userMsgId],
+        messageThreadId: scope.threadExtra.message_thread_id,
+        projectName: scope.rt.projectName,
+        prefix: `\u{1F4CE} ${name}`,
+        // Re-post the file so it stays in chat after the user message is deleted.
+        media: [{ type: "document", fileId: doc.file_id, fileName: name }],
+      });
+      const outcome = await scope.rt.submit(
+        textPrompt(promptText, anchor?.replyTo ?? userMsgId, quoted, {
+          promptId: anchor?.promptId,
+        }),
+      );
       if (outcome === "queued") {
-        await ctx.reply(`\u{1F4E5} Queued "${name}" \u2014 will run after the current task.`);
+        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 "${name}" \u2014 will run after the current task.`,
+          extra,
+        );
       }
     } catch (e) {
       log.warn(`submit failed for "${name}":`, (e as Error).message);

package/src/bot/handlers/forum.ts

@@ -0,0 +1,207 @@
+/**
+ * Forum topic group: auto-setup, user-created topic binding, and path prompts.
+ */
+import type { Bot } from "grammy";
+import { createLogger } from "../../logger.js";
+import type { ForumManager } from "../../forum/manager.js";
+import type { BotDeps } from "../deps.js";
+import { FORUM_GENERAL_THREAD_ID, forumThreadId } from "../../forum/thread.js";
+
+const log = createLogger("forum-handler");
+
+const BIND_HINT =
+  `Send the **absolute project path** or an **exact** catalog project name to bind this topic.\n` +
+  `Example: \`H:\\\\Lucru\\\\Domains\\\\MyApp\``;
+
+export function registerForum(bot: Bot, deps: BotDeps, forum: ForumManager): void {
+  const groupId = forum.groupId;
+
+  // Service message: user (or another admin) created a topic.
+  bot.on("message:forum_topic_created", async (ctx) => {
+    if (ctx.chat?.id !== groupId) return;
+    // Group ignored (not admin / no Topics / probe failed).
+    if (!forum.isReady) {
+      log.debug(`ignore forum_topic_created — forum not ready (${forum.getStatusText()})`);
+      return;
+    }
+    const created = ctx.message.forum_topic_created;
+    const threadId = ctx.message.message_thread_id;
+    if (!created || threadId === undefined) return;
+    // Skip General — always workspace-bound.
+    if (threadId === FORUM_GENERAL_THREAD_ID) return;
+
+    forum.noteUserTopic(threadId, created.name);
+    log.info(`user topic created: ${created.name} (#${threadId})`);
+
+    // Exact catalog name → bind immediately (no message required).
+    const auto = await forum.tryAutoBindByTopicName(threadId, created.name);
+    if (auto.status === "bound") {
+      await ctx
+        .reply(
+          `\u2705 Topic **${created.name}** auto-bound to project:\n\`${auto.binding.projectPath}\`\n\nYou can chat here now.`,
+          { parse_mode: "Markdown", message_thread_id: threadId },
+        )
+        .catch(() => {});
+      return;
+    }
+
+    if (auto.status === "already_bound") {
+      await ctx
+        .reply(
+          `\u{1F4CC} New topic **${created.name}**.\n\n` +
+            `Exact catalog match \`${auto.projectPath}\` is already bound to topic #${auto.otherThreadId}.\n` +
+            BIND_HINT,
+          { parse_mode: "Markdown", message_thread_id: threadId },
+        )
+        .catch(() => {});
+      return;
+    }
+
+    await ctx
+      .reply(
+        `\u{1F4CC} New topic **${created.name}**.\n\n` +
+          `No exact catalog project matched this name.\n` +
+          BIND_HINT,
+        { parse_mode: "Markdown", message_thread_id: threadId },
+      )
+      .catch(() => {});
+  });
+
+  // Re-probe when the bot is promoted/demoted in the configured group.
+  bot.on("my_chat_member", async (ctx) => {
+    if (ctx.chat?.id !== groupId) return;
+    const status = ctx.myChatMember.new_chat_member.status;
+    if (status === "administrator" || status === "creator") {
+      log.info(`bot became ${status} in topic group — re-running forum setup`);
+      void forum.ensureSetup().catch((e) => {
+        log.warn(`forum re-setup after promotion failed: ${(e as Error).message}`);
+      });
+      return;
+    }
+    if (status === "member" || status === "restricted" || status === "left" || status === "kicked") {
+      forum.markDisabled(
+        "not_admin",
+        `bot status is now "${status}" — forum topic management ignored until the bot is admin again`,
+      );
+    }
+  });
+
+  // Optional: re-run setup command for admins in the group.
+  bot.command("forum_setup", async (ctx) => {
+    const threadId = ctx.message?.message_thread_id;
+    const replyOpts =
+      threadId !== undefined ? { message_thread_id: threadId } : {};
+    if (ctx.chat?.id !== groupId) {
+      await ctx.reply("Use this command inside the configured forum group.", replyOpts).catch(() => {});
+      return;
+    }
+    await ctx
+      .reply(
+        "Setting up forum topics (this can take a while for large catalogs)…",
+        replyOpts,
+      )
+      .catch(() => {});
+    try {
+      await forum.ensureSetup();
+      if (!forum.isReady) {
+        await ctx
+          .reply(
+            `\u26A0\uFE0F Forum setup skipped / group ignored.\n${forum.getStatusText()}`,
+            replyOpts,
+          )
+          .catch(() => {});
+        return;
+      }
+      const n = forum.store.all().length;
+      await ctx
+        .reply(`\u2705 Forum setup done. ${n} topic(s) mapped.\n${forum.getStatusText()}`, replyOpts)
+        .catch(() => {});
+    } catch (e) {
+      await ctx.reply(`Setup failed: ${(e as Error).message}`, replyOpts).catch(() => {});
+    }
+  });
+
+  void deps;
+}
+
+/**
+ * Resolve a forum-group text message to a SessionRuntime, or handle bind flow.
+ * Returns "handled" when the message was consumed (bind ask / bind result).
+ */
+export async function resolveForumRuntime(
+  deps: BotDeps,
+  forum: ForumManager,
+  chatId: number,
+  threadId: number | undefined,
+  text: string,
+  messageId: number,
+): Promise<{ rt: import("../session-runtime.js").SessionRuntime } | "handled" | "ignore"> {
+  if (chatId !== forum.groupId) return "ignore";
+  // Not admin / Topics off / probe failed — do not steal group messages.
+  if (!forum.isReady) return "ignore";
+  const tid = forumThreadId(threadId);
+
+  // General topic → always workspace (no path prompt).
+  if (tid === FORUM_GENERAL_THREAD_ID) {
+    const cwd = deps.cfg.workspace;
+    if (!forum.store.get(tid)?.projectPath) {
+      forum.store.bindProject(tid, cwd, "General", "general");
+    }
+    const rt = deps.registry.getForumTopic(chatId, tid, cwd, "General");
+    return { rt };
+  }
+
+  // Ensure we know about this thread.
+  let binding = forum.store.get(tid);
+  if (!binding) {
+    binding = forum.noteUserTopic(tid, `Topic ${tid}`);
+  }
+
+  // Unbound only: try to interpret text as path / exact catalog name (do not
+  // steal normal prompts when already bound — even if pending flag is stale).
+  if (!binding.projectPath) {
+    const result = forum.tryBindPath(tid, text);
+    if (result.ok) {
+      const iconNote = result.binding.iconPath ? `\nIcon: ${result.binding.iconPath}` : "";
+      await deps.api
+        .sendMessage(
+          chatId,
+          `\u2705 Bound to project:\n\`${result.binding.projectPath}\`${iconNote}\n\nYou can chat here now.`,
+          { message_thread_id: tid, parse_mode: "Markdown", reply_parameters: { message_id: messageId } },
+        )
+        .catch(() => {});
+      // Warm runtime; path-only message is not submitted as an agent prompt.
+      const resolved = forum.resolveCwd(tid);
+      if (resolved) {
+        deps.registry.getForumTopic(chatId, tid, resolved.cwd, resolved.projectName);
+      }
+      return "handled";
+    }
+    await deps.api
+      .sendMessage(
+        chatId,
+        `\u2753 ${result.error}\n\n${BIND_HINT.replace(/\*\*/g, "")}`,
+        { message_thread_id: tid, reply_parameters: { message_id: messageId } },
+      )
+      .catch(() => {});
+    return "handled";
+  }
+
+  const resolved = forum.resolveCwd(tid);
+  if (!resolved) {
+    forum.store.markPending(tid);
+    await deps.api
+      .sendMessage(
+        chatId,
+        `\u2753 This topic is not linked to a project yet.\n${BIND_HINT.replace(/\*\*/g, "")}`,
+        { message_thread_id: tid },
+      )
+      .catch(() => {});
+    return "handled";
+  }
+
+  // Multi-session controller for this topic (own model/reasoning/running list).
+  // First message with no sessionId creates one via ensureSession on submit.
+  const controller = deps.registry.forumController(chatId, tid, resolved.cwd, resolved.projectName);
+  return { rt: controller.foreground() };
+}