grok-telegram-bot 2.5.0 → 2.7.0

package/src/bot/manager-jobs.ts

@@ -0,0 +1,142 @@
+/**
+ * In-memory tracking of work dispatched from General (manager) into project topics.
+ * Used for status, context inject, and report-back when a child turn finishes.
+ */
+
+export type ManagerJobStatus = "dispatched" | "running" | "done" | "failed" | "cancelled";
+
+export interface ManagerJob {
+  id: string;
+  originChatId: number;
+  originThreadId: number;
+  targetThreadId: number;
+  targetName: string;
+  targetPath: string;
+  childSessionId?: string;
+  dispatchPrompt: string;
+  userAskPreview: string;
+  createdAt: number;
+  updatedAt: number;
+  status: ManagerJobStatus;
+  resultSummary?: string;
+}
+
+export interface ReportBackMeta {
+  jobId: string;
+  originChatId: number;
+  originThreadId: number;
+  userAskPreview: string;
+  targetName: string;
+  targetPath: string;
+  dispatchPrompt: string;
+}
+
+const MAX_JOBS = 100;
+
+const jobsById = new Map<string, ManagerJob>();
+const jobIdBySession = new Map<string, string>();
+
+let seq = 0;
+
+export function newManagerJobId(): string {
+  seq = (seq + 1) % 1_000_000;
+  return `mj_${Date.now().toString(36)}_${seq.toString(36)}`;
+}
+
+export function registerManagerJob(input: {
+  originChatId: number;
+  originThreadId: number;
+  targetThreadId: number;
+  targetName: string;
+  targetPath: string;
+  dispatchPrompt: string;
+  userAskPreview: string;
+  childSessionId?: string;
+}): ManagerJob {
+  const now = Date.now();
+  const job: ManagerJob = {
+    id: newManagerJobId(),
+    originChatId: input.originChatId,
+    originThreadId: input.originThreadId,
+    targetThreadId: input.targetThreadId,
+    targetName: input.targetName,
+    targetPath: input.targetPath,
+    childSessionId: input.childSessionId,
+    dispatchPrompt: input.dispatchPrompt,
+    userAskPreview: input.userAskPreview,
+    createdAt: now,
+    updatedAt: now,
+    status: "dispatched",
+  };
+  jobsById.set(job.id, job);
+  if (job.childSessionId) jobIdBySession.set(job.childSessionId, job.id);
+  trimJobs();
+  return job;
+}
+
+export function bindJobSession(jobId: string, sessionId: string): void {
+  const job = jobsById.get(jobId);
+  if (!job) return;
+  job.childSessionId = sessionId;
+  job.updatedAt = Date.now();
+  if (job.status === "dispatched") job.status = "running";
+  jobIdBySession.set(sessionId, jobId);
+}
+
+export function updateManagerJob(
+  jobId: string,
+  patch: Partial<Pick<ManagerJob, "status" | "resultSummary" | "childSessionId">>,
+): ManagerJob | undefined {
+  const job = jobsById.get(jobId);
+  if (!job) return undefined;
+  if (patch.status !== undefined) job.status = patch.status;
+  if (patch.resultSummary !== undefined) job.resultSummary = patch.resultSummary;
+  if (patch.childSessionId !== undefined) {
+    job.childSessionId = patch.childSessionId;
+    jobIdBySession.set(patch.childSessionId, jobId);
+  }
+  job.updatedAt = Date.now();
+  return job;
+}
+
+export function getManagerJob(jobId: string): ManagerJob | undefined {
+  return jobsById.get(jobId);
+}
+
+export function getJobBySession(sessionId: string): ManagerJob | undefined {
+  const id = jobIdBySession.get(sessionId);
+  return id ? jobsById.get(id) : undefined;
+}
+
+/** Active (not terminal) jobs, newest first. */
+export function listActiveManagerJobs(limit = 12): ManagerJob[] {
+  return [...jobsById.values()]
+    .filter((j) => j.status === "dispatched" || j.status === "running")
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, limit);
+}
+
+/** Recent jobs including finished, newest first. */
+export function listRecentManagerJobs(limit = 12): ManagerJob[] {
+  return [...jobsById.values()]
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, Math.max(1, Math.min(50, limit)));
+}
+
+function trimJobs(): void {
+  if (jobsById.size <= MAX_JOBS) return;
+  const ordered = [...jobsById.values()].sort((a, b) => a.updatedAt - b.updatedAt);
+  const drop = ordered.length - MAX_JOBS;
+  for (let i = 0; i < drop; i++) {
+    const j = ordered[i]!;
+    jobsById.delete(j.id);
+    if (j.childSessionId) jobIdBySession.delete(j.childSessionId);
+  }
+}
+
+/** Test helper: wipe job state. */
+export function clearManagerJobsForTests(): void {
+  jobsById.clear();
+  jobIdBySession.clear();
+  seq = 0;
+}

package/src/bot/menu/ephemeral.ts

@@ -101,8 +101,11 @@ export class Ephemeral {
       msg && "message_thread_id" in msg
         ? (msg as { message_thread_id?: number }).message_thread_id
         : undefined;
+    // Omit General (1) — Bot API rejects message_thread_id=1.
     const merged =
-      threadId !== undefined && extra.message_thread_id === undefined
+      threadId !== undefined &&
+      threadId !== 1 &&
+      extra.message_thread_id === undefined
         ? { ...extra, message_thread_id: threadId }
         : extra;
     return this.serialize(chatId, async () => {

package/src/bot/plan-exit-service.ts

@@ -0,0 +1,169 @@
+/**
+ * Interactive plan-mode approval. Grok's exit_plan_mode reverse request
+ * becomes Approve / Request changes / Abandon buttons (same idea as
+ * PermissionService). Auto-approve is used when configured, or when the
+ * session has no owning chat (scheduled / orphan).
+ */
+import type { Api } from "grammy";
+import { InlineKeyboard } from "grammy";
+import type { PlanExitDecision, PlanExitOutcome } from "../grok/plan-approval.js";
+import { outboundThreadExtra } from "../forum/thread.js";
+import { createLogger } from "../logger.js";
+import type { RuntimeRegistry } from "./registry.js";
+
+const log = createLogger("plan-exit");
+const TIMEOUT_MS = 30 * 60 * 1000;
+const PREVIEW = 900;
+
+interface Pending {
+  resolve: (d: PlanExitDecision) => void;
+  chatId: number;
+  messageId?: number;
+  timer: NodeJS.Timeout;
+  pinned: boolean;
+  waitingFeedback: boolean;
+}
+
+export class PlanExitService {
+  private readonly pending = new Map<string, Pending>();
+  /** chatId → reqId while we wait for revision notes after "Request changes". */
+  private readonly feedbackFor = new Map<number, string>();
+  private seq = 0;
+
+  constructor(
+    private readonly api: Api,
+    private readonly registry: RuntimeRegistry,
+    public autoApprove = false,
+    private readonly onUnpinned?: (chatId: number) => void | Promise<void>,
+  ) {}
+
+  async handle(params: Record<string, unknown>): Promise<PlanExitDecision> {
+    const sessionId = str(params.sessionId) || str(params.session_id) || "";
+    const planText = extractPlanText(params);
+    if (this.autoApprove) {
+      log.info(`auto-approved plan exit for ${sessionId.slice(0, 8) || "?"}`);
+      return { outcome: "approved", feedback: "" };
+    }
+
+    const desc = sessionId ? this.registry.describeSession(sessionId) : { chatId: undefined };
+    const chatId = desc.chatId;
+    if (chatId === undefined) return { outcome: "approved", feedback: "" };
+    const threadExtra = outboundThreadExtra(desc.threadId);
+
+    const reqId = String(++this.seq);
+    const preview = planText.replace(/\s+/g, " ").trim().slice(0, PREVIEW);
+    const body = [
+      "\u{1F4CB} Plan ready \u2014 review before Grok implements.",
+      preview ? `\n${preview}${planText.length > PREVIEW ? "\u2026" : ""}` : "\n(No plan text in the request.)",
+      "\nApprove to build, request changes (then send notes), or abandon.",
+    ].join("\n");
+
+    const kb = new InlineKeyboard()
+      .text("\u2705 Approve", `planx:${reqId}:ok`)
+      .text("\u270F\uFE0F Changes", `planx:${reqId}:chg`)
+      .row()
+      .text("\u26D4 Abandon", `planx:${reqId}:no`);
+
+    let messageId: number | undefined;
+    let pinned = false;
+    try {
+      const msg = await this.api.sendMessage(chatId, body, {
+        reply_markup: kb,
+        disable_notification: false,
+        ...threadExtra,
+      });
+      messageId = msg.message_id;
+      try {
+        await this.api.pinChatMessage(chatId, messageId, { disable_notification: true });
+        pinned = true;
+      } catch (e) {
+        log.warn("pin plan prompt failed:", (e as Error).message);
+      }
+    } catch (e) {
+      log.warn("send plan prompt failed:", (e as Error).message);
+      return { outcome: "approved", feedback: "" };
+    }
+
+    return new Promise<PlanExitDecision>((resolve) => {
+      const timer = setTimeout(() => {
+        const p = this.pending.get(reqId);
+        if (!p) return;
+        this.pending.delete(reqId);
+        this.feedbackFor.delete(p.chatId);
+        void this.finish(p, "\u231B Plan approval timed out \u2014 abandoned.");
+        resolve({ outcome: "abandoned", feedback: "timed out waiting for review" });
+      }, TIMEOUT_MS);
+      this.pending.set(reqId, { resolve, chatId, messageId, timer, pinned, waitingFeedback: false });
+    });
+  }
+
+  /** Button tap. Returns a short toast; "chg" waits for the next text message. */
+  resolveChoice(reqId: string, action: string): string | undefined {
+    const p = this.pending.get(reqId);
+    if (!p) return undefined;
+    if (action === "chg") {
+      p.waitingFeedback = true;
+      this.feedbackFor.set(p.chatId, reqId);
+      void this.api
+        .editMessageText(p.chatId, p.messageId ?? 0, "\u270F\uFE0F Send revision notes as your next message.", {
+          reply_markup: { inline_keyboard: [] },
+        })
+        .catch(() => {});
+      return "Send change notes";
+    }
+    clearTimeout(p.timer);
+    this.pending.delete(reqId);
+    this.feedbackFor.delete(p.chatId);
+    const outcome: PlanExitOutcome = action === "ok" ? "approved" : "abandoned";
+    const label = outcome === "approved" ? "\u2705 Plan approved \u2014 implementing." : "\u26D4 Plan abandoned.";
+    void this.finish(p, label);
+    p.resolve({ outcome, feedback: "" });
+    return outcome === "approved" ? "Approved" : "Abandoned";
+  }
+
+  /** If this chat is waiting for revision notes, consume the text. */
+  takeFeedback(chatId: number, text: string): boolean {
+    const reqId = this.feedbackFor.get(chatId);
+    if (!reqId) return false;
+    const p = this.pending.get(reqId);
+    this.feedbackFor.delete(chatId);
+    if (!p) return false;
+    clearTimeout(p.timer);
+    this.pending.delete(reqId);
+    const notes = text.trim().slice(0, 4000);
+    void this.finish(p, `\u270F\uFE0F Requested changes:\n${notes.slice(0, 400)}`);
+    p.resolve({ outcome: "request_changes", feedback: notes || "Please revise the plan." });
+    return true;
+  }
+
+  private async finish(p: Pending, text: string): Promise<void> {
+    if (p.messageId !== undefined) {
+      await this.api
+        .editMessageText(p.chatId, p.messageId, text, { reply_markup: { inline_keyboard: [] } })
+        .catch(() => {});
+    }
+    if (p.pinned && p.messageId !== undefined) {
+      p.pinned = false;
+      await this.api.unpinChatMessage(p.chatId, p.messageId).catch(() => {});
+    }
+    if (this.onUnpinned) {
+      try {
+        await this.onUnpinned(p.chatId);
+      } catch {
+        /* non-fatal */
+      }
+    }
+  }
+}
+
+export function extractPlanText(params: Record<string, unknown>): string {
+  for (const k of ["plan_content", "planContent", "content", "plan", "text"]) {
+    const v = params[k];
+    if (typeof v === "string" && v.trim()) return v;
+  }
+  return "";
+}
+
+function str(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}

package/src/bot/prompt-anchor.ts

@@ -15,6 +15,7 @@ import type { Api, Context } from "grammy";
 import { InputMediaBuilder } from "grammy";
 import { createLogger } from "../logger.js";
 import { tagSafe } from "../render/hashtags.js";
+import { outboundThreadExtra } from "../forum/thread.js";
 
 const log = createLogger("prompt-anchor");
 
@@ -123,10 +124,8 @@ export async function adoptUserPrompt(
   });
   const threadExtra: Record<string, unknown> = {
     disable_notification: true,
+    ...outboundThreadExtra(opts.messageThreadId),
   };
-  if (opts.messageThreadId !== undefined) {
-    threadExtra.message_thread_id = opts.messageThreadId;
-  }
 
   let replyTo: number;
   try {

package/src/bot/prompt-content.ts

@@ -69,6 +69,9 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
   // Preserve meta flags: auto-suggestion batches / self-recheck must not re-arm
   // another recheck after merge (dropping this caused infinite recheck loops).
   const skipSelfRecheck = inputs.some((i) => i.skipSelfRecheck);
+  // First reportBack wins (oldest queued manager dispatch in this merge batch).
+  const reportBack = inputs.find((i) => i.reportBack)?.reportBack;
+  const seedMessageId = inputs.find((i) => i.seedMessageId !== undefined)?.seedMessageId;
   return {
     text: inputs
       .map((i) => i.text)
@@ -82,6 +85,8 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
     promptId: inputs.find((i) => i.promptId)?.promptId,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
     skipSelfRecheck: skipSelfRecheck || undefined,
+    reportBack,
+    seedMessageId,
   };
 }
 

package/src/bot/registry.ts

@@ -24,6 +24,8 @@ import type { SessionRuntime } from "./session-runtime.js";
 export interface SessionDescription {
   /** Chat that owns the session (controlled session or subagent parent). */
   chatId?: number;
+  /** Forum topic thread id when the session lives in a project topic. */
+  threadId?: number;
   /** True when this is a session the chat directly controls. */
   controlled: boolean;
   /** True when this is a subagent of a controlled turn. */
@@ -202,10 +204,17 @@ export class RuntimeRegistry {
   describeSession(sessionId: string): SessionDescription {
     const controlledChat = this.findChatBySession(sessionId);
     if (controlledChat !== undefined) {
-      const project = this.controller(controlledChat)
+      const forum = this.forumControllerForSession(sessionId);
+      const project = (forum ?? this.controller(controlledChat))
         .list()
         .find((s) => s.sessionId === sessionId)?.projectName;
-      return { chatId: controlledChat, controlled: true, subagent: false, projectName: project };
+      return {
+        chatId: controlledChat,
+        threadId: forum?.messageThreadId,
+        controlled: true,
+        subagent: false,
+        projectName: project,
+      };
     }
     const parent = this.subagentParents.get(sessionId);
     const info = this.acp.subagentById(sessionId);

package/src/bot/scope.ts

@@ -6,8 +6,11 @@ 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";
+import {
+  forumThreadId,
+  FORUM_GENERAL_THREAD_ID,
+  outboundThreadExtra,
+} from "../forum/thread.js";
 
 export interface HandlerScope {
   chatId: number;
@@ -48,10 +51,6 @@ 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);
@@ -61,7 +60,8 @@ export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
       settingsKey: settingsKeyFor(chatId),
       controller,
       rt: controller.foreground(),
-      threadExtra: rawThread !== undefined ? { message_thread_id: rawThread } : {},
+      // Private chats rarely have threads; still omit General-style id 1.
+      threadExtra: outboundThreadExtra(rawThread),
     };
   }
 
@@ -87,7 +87,8 @@ export function resolveScope(ctx: Context, deps: BotDeps): HandlerScope {
     settingsKey: settingsKeyFor(chatId, tid),
     controller,
     rt: controller.foreground(),
-    threadExtra: { message_thread_id: tid },
+    // Outbound: never pass message_thread_id=1 (General) — Telegram rejects it.
+    threadExtra: outboundThreadExtra(tid),
     projectPath: cwd,
     projectName,
   };