grok-telegram-bot 2.4.0 → 2.6.0

package/src/bot/handlers/message.ts

@@ -8,96 +8,316 @@
  * rapid consecutive text messages per chat within a short debounce window
  * (`MESSAGE_BATCH_MS`) into a single prompt — one submission, one confirmation.
  *
- * While a turn is running, the combined message is queued and runs
- * automatically when the current turn finishes.
- * (Wizard input and menu-button text are intercepted by earlier handlers.)
+ * Project topics: user messages are replaced by a bot-owned prompt anchor
+ * (`#prompt_<id>`) so the chat shows immediate life while CLI/ACP starts.
+ *
+ * General (manager): user messages are KEPT; AI replies thread to the user
+ * message. Each message is a NEW session (parallel), unless the user replies
+ * to a bot message — then that session continues.
  */
 import type { Bot } from "grammy";
 import { textPrompt } from "../../app/types.js";
 import { createLogger } from "../../logger.js";
+import {
+  batchKey,
+  forumThreadId,
+  isGeneralThread,
+  outboundThreadExtra,
+} from "../../forum/thread.js";
 import type { BotDeps } from "../deps.js";
+import { adoptUserPrompt, newPromptId } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
+import { resolveForumRuntime } from "./forum.js";
+import type { SessionRuntime } from "../session-runtime.js";
 
 const log = createLogger("message");
 
-/** A pending burst of text messages from one chat, awaiting coalescing. */
+/** A pending burst of text messages from one chat/topic, awaiting coalescing. */
 interface TextBatch {
   parts: string[];
   ids: number[];
+  /** Forum topic thread id (undefined for private chats / General without id). */
+  threadId?: number;
   /** Reference content if the burst began as a reply to another message. */
   quoted?: string;
+  /** Telegram message_id the user is replying to (for session follow-up). */
+  replyToMessageId?: number;
+  /** Text of the replied-to message (for #sess_ recovery). */
+  replyToText?: string;
   timer: NodeJS.Timeout;
 }
 
 export function registerMessages(bot: Bot, deps: BotDeps): void {
-  const batches = new Map<number, TextBatch>();
+  const batches = new Map<string, TextBatch>();
   const windowMs = deps.cfg.messageBatchMs;
 
-  const arm = (chatId: number): NodeJS.Timeout =>
-    setTimeout(() => void flush(deps, batches, chatId), windowMs);
+  const arm = (key: string): NodeJS.Timeout =>
+    setTimeout(() => void flush(deps, batches, key), windowMs);
 
   bot.on("message:text", async (ctx) => {
     const text = ctx.message.text;
     if (!text.trim()) return;
+    // Slash commands are handled by bot.command / menu — never batch as agent prompts.
+    if (!text.includes("\n") && text.startsWith("/")) return;
+
     const chatId = ctx.chat.id;
     const id = ctx.message.message_id;
+    const rawThreadId = ctx.message.message_thread_id;
+    const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+    const threadId = isForum ? forumThreadId(rawThreadId) : rawThreadId;
     const quoted = extractReplyContext(ctx);
+    const replyToMessageId = ctx.message.reply_to_message?.message_id;
+    const replyToText =
+      ctx.message.reply_to_message?.text ?? ctx.message.reply_to_message?.caption;
+    // General: do not coalesce independent messages (parallel sessions).
+    // Still coalesce multi-part 4096 splits when reply chain is empty and rapid.
+    const key = isGeneralThread(threadId) && isForum
+      ? `${chatId}:${threadId ?? 1}:m${id}`
+      : batchKey(chatId, rawThreadId, isForum);
 
-    const batch = batches.get(chatId);
+    const batch = batches.get(key);
     if (batch) {
       clearTimeout(batch.timer);
       batch.parts.push(text);
       batch.ids.push(id);
       if (quoted && !batch.quoted) batch.quoted = quoted;
-      batch.timer = arm(chatId);
+      if (replyToMessageId !== undefined && batch.replyToMessageId === undefined) {
+        batch.replyToMessageId = replyToMessageId;
+        batch.replyToText = replyToText;
+      }
+      batch.timer = arm(key);
       return;
     }
-    batches.set(chatId, { parts: [text], ids: [id], quoted, timer: arm(chatId) });
+    batches.set(key, {
+      parts: [text],
+      ids: [id],
+      threadId,
+      quoted,
+      replyToMessageId,
+      replyToText,
+      timer: arm(key),
+    });
   });
 }
 
 /** Coalesce a chat's buffered parts into one prompt and submit it once. */
-async function flush(deps: BotDeps, batches: Map<number, TextBatch>, chatId: number): Promise<void> {
-  const batch = batches.get(chatId);
+async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string): Promise<void> {
+  const batch = batches.get(key);
   if (!batch) return;
-  batches.delete(chatId);
+  batches.delete(key);
 
-  // Telegram splits at 4096 chars, almost always on a line boundary, so
-  // rejoining with a newline reconstructs the original text faithfully.
   const combined = batch.parts.join("\n").trim();
   if (!combined) return;
 
-  // A lone, single-line "/something" is an unknown-command typo — guide the
-  // user instead of forwarding it to the agent. Split content never trips
-  // this: it arrives as multiple parts, and multi-line text is never a command.
+  const [chatIdStr] = key.split(":");
+  const chatId = Number(chatIdStr);
+  const threadId = batch.threadId;
+
   if (batch.parts.length === 1 && !combined.includes("\n") && combined.startsWith("/")) {
-    await send(deps, chatId, "Unknown command. Type /help to see what I can do.");
     return;
   }
 
-  const rt = deps.registry.get(chatId);
+  const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
+  const isGeneral = isForum && isGeneralThread(threadId);
+
+  let rt: SessionRuntime = deps.registry.get(chatId);
+
+  if (isForum && deps.forum) {
+    const resolved = await resolveForumRuntime(
+      deps,
+      deps.forum,
+      chatId,
+      threadId,
+      combined,
+      batch.ids[0]!,
+    );
+    if (resolved === "handled" || resolved === "ignore") return;
+
+    if (isGeneral) {
+      // ── General manager path ─────────────────────────────────────────
+      const controller = deps.registry.forumController(
+        chatId,
+        forumThreadId(threadId),
+        resolved.rt.cwd,
+        resolved.rt.projectName ?? "General",
+      );
+
+      // Reply → continue same session (map, #sess_ on controlled runtimes, or disk).
+      // Fresh message → new parallel session (does not queue behind other General work).
+      const continueRt = await controller.resolveContinueFromReply({
+        replyToMessageId: batch.replyToMessageId,
+        replyToText: batch.replyToText,
+        cwd: resolved.rt.cwd,
+        projectName: resolved.rt.projectName ?? "General",
+      });
+
+      const userMsgId = batch.ids[0]!;
+      const replyTo = userMsgId;
+      // Keep user message; reply to it. No overwrite / adopt delete.
+
+      // New session: post "Starting…" FIRST (before ACP session/new) so the user
+      // sees life immediately. runTurn later edits it to Thinking… then streams.
+      // Follow-up on existing session: skip Starting (runTurn posts Thinking…).
+      let seedMessageId: number | undefined;
+      if (!continueRt) {
+        seedMessageId = await sendStatus(
+          deps,
+          chatId,
+          "Starting\u2026",
+          threadId,
+          replyTo,
+        );
+        rt = await controller.addParallel(
+          resolved.rt.cwd,
+          resolved.rt.projectName ?? "General",
+        );
+        if (seedMessageId !== undefined && rt.sessionId) {
+          controller.bindTelegramMessage(seedMessageId, rt.sessionId);
+        }
+      } else {
+        rt = continueRt;
+        // FG for status panel; manager setForeground keeps busy siblings streaming.
+        if (rt.sessionId) await controller.switchTo(rt.sessionId).catch(() => {});
+      }
+      if (rt.sessionId) controller.bindTelegramMessage(userMsgId, rt.sessionId);
+
+      try {
+        const outcome = await rt.submit(
+          textPrompt(combined, replyTo, batch.quoted, {
+            promptId: newPromptId(),
+            seedMessageId,
+          }),
+        );
+        if (rt.sessionId) {
+          controller.bindTelegramMessage(userMsgId, rt.sessionId);
+          if (seedMessageId !== undefined) {
+            controller.bindTelegramMessage(seedMessageId, rt.sessionId);
+          }
+        }
+        // Never show "queued" spam for new parallel sessions; only if continuing
+        // the same session that is already busy.
+        if (outcome === "queued" && continueRt) {
+          await send(
+            deps,
+            chatId,
+            `\u{1F4E5} Got it — queued as a follow-up on that thread.`,
+            threadId,
+            replyTo,
+          );
+        }
+      } catch (err) {
+        log.warn(`general submit failed chat ${chatId}: ${(err as Error).message}`);
+        if (seedMessageId !== undefined) {
+          await editStatus(deps, chatId, seedMessageId, `\u274C Couldn't start: ${(err as Error).message}`);
+        } else {
+          await send(
+            deps,
+            chatId,
+            `\u274C Couldn't start: ${(err as Error).message}`,
+            threadId,
+            replyTo,
+          );
+        }
+      }
+      return;
+    }
+
+    // ── Project / AI Chat topics (existing behavior) ─────────────────
+    rt = resolved.rt;
+    if (!rt.sessionId && !rt.isBusy) {
+      try {
+        await rt.startNewSession(rt.cwd, rt.projectName);
+      } catch {
+        /* ensureSession on submit will retry */
+      }
+    }
+  }
+
   const note = batch.parts.length > 1 ? ` (combined ${batch.parts.length} messages)` : "";
+  let replyTo: number | undefined = batch.ids[0];
   try {
-    // Thread the reply to the prompt message (the user's message is left intact;
-    // the agent's response + Done reply to it, and carry searchable hashtags).
-    const outcome = await rt.submit(textPrompt(combined, batch.ids[0], batch.quoted));
+    const anchor = await adoptUserPrompt(deps.api, {
+      chatId,
+      text: combined,
+      userMessageIds: batch.ids,
+      messageThreadId: threadId,
+      projectName: rt.projectName,
+      prefix: "\u{1F4DD} Prompt",
+    });
+    replyTo = anchor?.replyTo ?? batch.ids[0];
+    const outcome = await rt.submit(
+      textPrompt(combined, replyTo, batch.quoted, { promptId: anchor?.promptId }),
+    );
     if (outcome === "queued") {
       await send(
         deps,
         chatId,
         `\u{1F4E5} Queued (position ${rt.queueLength})${note} \u2014 I'm still working on the previous task. It'll run next.`,
+        threadId,
+        replyTo,
       );
     }
-    // "ran": turn started; complexity is steered silently by the agent.
   } catch (err) {
     log.warn(`submit failed for chat ${chatId}: ${(err as Error).message}`);
-    await send(deps, chatId, `\u274C Couldn't start your message: ${(err as Error).message}`);
+    await send(
+      deps,
+      chatId,
+      `\u274C Couldn't start your message: ${(err as Error).message}`,
+      threadId,
+      replyTo,
+    );
+  }
+}
+
+async function send(
+  deps: BotDeps,
+  chatId: number,
+  text: string,
+  threadId?: number,
+  replyTo?: number,
+): Promise<void> {
+  try {
+    const extra: Record<string, unknown> = { ...outboundThreadExtra(threadId) };
+    if (replyTo !== undefined) {
+      extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
+    }
+    await deps.api.sendMessage(chatId, text, extra);
+  } catch {
+    /* non-fatal */
+  }
+}
+
+/** Post status bubble; returns message_id for later edit (Starting… → Thinking…). */
+async function sendStatus(
+  deps: BotDeps,
+  chatId: number,
+  text: string,
+  threadId?: number,
+  replyTo?: number,
+): Promise<number | undefined> {
+  try {
+    const extra: Record<string, unknown> = {
+      disable_notification: true,
+      ...outboundThreadExtra(threadId),
+    };
+    if (replyTo !== undefined) {
+      extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
+    }
+    const msg = await deps.api.sendMessage(chatId, text, extra);
+    return msg.message_id;
+  } catch {
+    return undefined;
   }
 }
 
-async function send(deps: BotDeps, chatId: number, text: string): Promise<void> {
+async function editStatus(
+  deps: BotDeps,
+  chatId: number,
+  messageId: number,
+  text: string,
+): Promise<void> {
   try {
-    await deps.api.sendMessage(chatId, text);
+    await deps.api.editMessageText(chatId, messageId, text);
   } catch {
     /* non-fatal */
   }

package/src/bot/handlers/photo.ts

@@ -2,11 +2,15 @@
  * Photo & image-document handler. Downloads images (including multi-image
  * albums / media groups) and submits them to Grok as ACP image content blocks
  * alongside the caption text.
+ *
+ * User media messages are replaced by a bot prompt anchor (`#prompt_<id>`);
+ * the agent still receives the downloaded image bytes.
  */
 import type { Bot, Context } from "grammy";
 import type { PromptImage } from "../../app/types.js";
 import { createLogger } from "../../logger.js";
 import type { BotDeps } from "../deps.js";
+import { type AdoptMediaItem, adoptUserPrompt } from "../prompt-anchor.js";
 import { extractReplyContext } from "../reply-context.js";
 
 const log = createLogger("photo");
@@ -15,19 +19,31 @@ const GROUP_DEBOUNCE_MS = 900;
 interface GroupBuffer {
   chatId: number;
   caption: string;
+  /** Agent-bound image bytes (may be shorter than media if a download failed). */
   images: PromptImage[];
-  replyTo?: number;
+  /** Chat re-post descriptors (file_id + correct photo vs document kind). */
+  media: AdoptMediaItem[];
+  /** User Telegram message ids in this album (for delete after anchor). */
+  userMessageIds: number[];
   quoted?: string;
+  threadId?: number;
   timer: NodeJS.Timeout;
 }
 
 export function registerPhotos(bot: Bot, deps: BotDeps): void {
   const groups = new Map<string, GroupBuffer>();
 
-  const onMedia = async (ctx: Context, image: PromptImage | undefined, caption: string): Promise<void> => {
-    if (!image) return;
+  const onMedia = async (
+    ctx: Context,
+    image: PromptImage | undefined,
+    mediaItem: AdoptMediaItem | undefined,
+    caption: string,
+  ): Promise<void> => {
+    // Still re-post to chat when download fails — user must not lose the file.
+    if (!mediaItem?.fileId) return;
     const chatId = ctx.chat!.id;
-    const replyTo = ctx.message?.message_id;
+    const msgId = ctx.message?.message_id;
+    const threadId = ctx.message?.message_thread_id;
     const quoted = extractReplyContext(ctx);
 
     // Don't hijack the task wizard.
@@ -36,9 +52,21 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
       return;
     }
 
+    const images = image ? [image] : [];
+    const media = [mediaItem];
+
     const groupId = ctx.message?.media_group_id;
     if (!groupId) {
-      await submit(deps, chatId, caption, [image], replyTo, quoted);
+      await submit(
+        deps,
+        chatId,
+        caption,
+        images,
+        media,
+        msgId !== undefined ? [msgId] : [],
+        quoted,
+        threadId,
+      );
       return;
     }
 
@@ -46,17 +74,21 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
     const existing = groups.get(groupId);
     if (existing) {
       clearTimeout(existing.timer);
-      existing.images.push(image);
+      if (image) existing.images.push(image);
+      existing.media.push(mediaItem);
       if (caption) existing.caption = caption;
       if (quoted && !existing.quoted) existing.quoted = quoted;
+      if (msgId !== undefined) existing.userMessageIds.push(msgId);
       existing.timer = setTimeout(() => flush(groups, groupId, deps), GROUP_DEBOUNCE_MS);
     } else {
       groups.set(groupId, {
         chatId,
         caption,
-        images: [image],
-        replyTo,
+        images,
+        media,
+        userMessageIds: msgId !== undefined ? [msgId] : [],
         quoted,
+        threadId,
         timer: setTimeout(() => flush(groups, groupId, deps), GROUP_DEBOUNCE_MS),
       });
     }
@@ -65,15 +97,33 @@ export function registerPhotos(bot: Bot, deps: BotDeps): void {
   bot.on("message:photo", async (ctx) => {
     const photos = ctx.message.photo;
     const largest = photos[photos.length - 1];
-    const image = largest ? await download(ctx, largest.file_id, "image/jpeg", deps.cfg.token) : undefined;
-    await onMedia(ctx, image, ctx.message.caption ?? "");
+    const fileId = largest?.file_id;
+    const image = fileId
+      ? await download(ctx, fileId, "image/jpeg", deps.cfg.token)
+      : undefined;
+    await onMedia(
+      ctx,
+      image,
+      fileId ? { type: "photo", fileId } : undefined,
+      ctx.message.caption ?? "",
+    );
   });
 
   bot.on("message:document", async (ctx, next) => {
     const doc = ctx.message.document;
     if (!doc.mime_type?.startsWith("image/")) return next(); // let document-handler logic pass
     const image = await download(ctx, doc.file_id, doc.mime_type, deps.cfg.token);
-    await onMedia(ctx, image, ctx.message.caption ?? "");
+    // Image-as-document must re-post as document — photo file_ids are a different kind.
+    await onMedia(
+      ctx,
+      image,
+      {
+        type: "document",
+        fileId: doc.file_id,
+        fileName: doc.file_name ?? undefined,
+      },
+      ctx.message.caption ?? "",
+    );
   });
 }
 
@@ -81,7 +131,16 @@ async function flush(groups: Map<string, GroupBuffer>, groupId: string, deps: Bo
   const buf = groups.get(groupId);
   if (!buf) return;
   groups.delete(groupId);
-  await submit(deps, buf.chatId, buf.caption, buf.images, buf.replyTo, buf.quoted);
+  await submit(
+    deps,
+    buf.chatId,
+    buf.caption,
+    buf.images,
+    buf.media,
+    buf.userMessageIds,
+    buf.quoted,
+    buf.threadId,
+  );
 }
 
 async function submit(
@@ -89,15 +148,66 @@ async function submit(
   chatId: number,
   caption: string,
   images: PromptImage[],
-  replyTo?: number,
+  media: AdoptMediaItem[],
+  userMessageIds: number[],
   quoted?: string,
+  threadId?: number,
 ): Promise<void> {
-  const rt = deps.registry.get(chatId);
-  const outcome = await rt.submit({ text: caption, images, replyTo, quotedText: quoted });
+  let rt = deps.registry.get(chatId);
+  if (deps.forum?.isActiveForumChat(chatId) && threadId !== undefined) {
+    const { forumThreadId } = await import("../../forum/thread.js");
+    const tid = forumThreadId(threadId);
+    const resolved = deps.forum.resolveCwd(tid);
+    if (resolved) {
+      rt = deps.registry.getForumTopic(chatId, tid, resolved.cwd, resolved.projectName);
+    }
+  }
+
+  const n = Math.max(images.length, media.length);
+  const label =
+    n === 1
+      ? "\u{1F4F7} Image"
+      : `\u{1F4F7} ${n} images`;
+  const body = caption.trim()
+    ? caption
+    : n === 1
+      ? "(image attached)"
+      : `(${n} images attached)`;
+
+  const anchor = await adoptUserPrompt(deps.api, {
+    chatId,
+    text: body,
+    userMessageIds,
+    messageThreadId: threadId,
+    projectName: rt.projectName,
+    prefix: label,
+    media,
+  });
+
+  // Agent gets whatever bytes we could download (may be empty if download failed).
+  const outcome = await rt.submit({
+    text: caption,
+    images,
+    replyTo: anchor?.replyTo ?? userMessageIds[0],
+    promptId: anchor?.promptId,
+    quotedText: quoted,
+  });
   if (outcome === "queued") {
+    // Omit General (1) — Bot API rejects message_thread_id=1.
+    const extra: Record<string, unknown> =
+      threadId !== undefined && threadId !== 1
+        ? { message_thread_id: threadId }
+        : {};
+    if (anchor?.replyTo !== undefined) {
+      extra.reply_parameters = {
+        message_id: anchor.replyTo,
+        allow_sending_without_reply: true,
+      };
+    }
     await deps.api.sendMessage(
       chatId,
-      `\u{1F4E5} Queued ${images.length} image${images.length > 1 ? "s" : ""} \u2014 will run after the current task.`,
+      `\u{1F4E5} Queued ${n} image${n > 1 ? "s" : ""} \u2014 will run after the current task.`,
+      extra,
     );
   }
 }