grok-telegram-bot 2.5.0 → 2.7.0

package/src/bot/handlers/message.ts

@@ -8,22 +8,27 @@
  * rapid consecutive text messages per chat within a short debounce window
  * (`MESSAGE_BATCH_MS`) into a single prompt — one submission, one confirmation.
  *
- * User messages are replaced by a bot-owned prompt anchor (`#prompt_<id>`) so
- * the chat shows immediate life while CLI/ACP starts, and all AI replies thread
- * to that anchor with the same searchable tag.
+ * Project topics: user messages are replaced by a bot-owned prompt anchor
+ * (`#prompt_<id>`) so the chat shows immediate life while CLI/ACP starts.
  *
- * 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.)
+ * 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 } from "../../forum/thread.js";
+import {
+  batchKey,
+  forumThreadId,
+  isGeneralThread,
+  outboundThreadExtra,
+} from "../../forum/thread.js";
 import type { BotDeps } from "../deps.js";
-import { adoptUserPrompt } from "../prompt-anchor.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");
 
@@ -35,6 +40,10 @@ interface TextBatch {
   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;
 }
 
@@ -49,7 +58,6 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
     const text = ctx.message.text;
     if (!text.trim()) return;
     // Slash commands are handled by bot.command / menu — never batch as agent prompts.
-    // (Otherwise /forum_setup and /help would also hit the debounce → agent path.)
     if (!text.includes("\n") && text.startsWith("/")) return;
 
     const chatId = ctx.chat.id;
@@ -58,7 +66,14 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
     const isForum = Boolean(deps.forum?.isActiveForumChat(chatId));
     const threadId = isForum ? forumThreadId(rawThreadId) : rawThreadId;
     const quoted = extractReplyContext(ctx);
-    const key = batchKey(chatId, rawThreadId, isForum);
+    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(key);
     if (batch) {
@@ -66,6 +81,10 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
       batch.parts.push(text);
       batch.ids.push(id);
       if (quoted && !batch.quoted) batch.quoted = quoted;
+      if (replyToMessageId !== undefined && batch.replyToMessageId === undefined) {
+        batch.replyToMessageId = replyToMessageId;
+        batch.replyToText = replyToText;
+      }
       batch.timer = arm(key);
       return;
     }
@@ -74,6 +93,8 @@ export function registerMessages(bot: Bot, deps: BotDeps): void {
       ids: [id],
       threadId,
       quoted,
+      replyToMessageId,
+      replyToText,
       timer: arm(key),
     });
   });
@@ -85,8 +106,6 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   if (!batch) return;
   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;
 
@@ -94,14 +113,16 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   const chatId = Number(chatIdStr);
   const threadId = batch.threadId;
 
-  // Defense-in-depth: never submit slash-only lines as agent prompts.
   if (batch.parts.length === 1 && !combined.includes("\n") && combined.startsWith("/")) {
     return;
   }
 
-  let rt = deps.registry.get(chatId);
-  // Forum group: topic-scoped multi-session controller (model/reasoning/running).
-  if (deps.forum?.isActiveForumChat(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,
@@ -111,10 +132,98 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
       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 nothing is selected / no session yet, ensure a new session is created
-    // on first message (ensureSession inside submit). If FG has no sessionId
-    // after a closed session, start a fresh one for this topic.
     if (!rt.sessionId && !rt.isBusy) {
       try {
         await rt.startNewSession(rt.cwd, rt.projectName);
@@ -125,11 +234,8 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
   }
 
   const note = batch.parts.length > 1 ? ` (combined ${batch.parts.length} messages)` : "";
-  // Hoisted so a submit failure after a successful adopt can still thread the error.
   let replyTo: number | undefined = batch.ids[0];
   try {
-    // Instant bot anchor: user sees the prompt adopted immediately while CLI warms.
-    // All AI output + Done reply to this message and carry #prompt_<id>.
     const anchor = await adoptUserPrompt(deps.api, {
       chatId,
       text: combined,
@@ -151,7 +257,6 @@ async function flush(deps: BotDeps, batches: Map<string, TextBatch>, key: string
         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(
@@ -172,8 +277,7 @@ async function send(
   replyTo?: number,
 ): Promise<void> {
   try {
-    const extra: Record<string, unknown> = {};
-    if (threadId !== undefined) extra.message_thread_id = threadId;
+    const extra: Record<string, unknown> = { ...outboundThreadExtra(threadId) };
     if (replyTo !== undefined) {
       extra.reply_parameters = { message_id: replyTo, allow_sending_without_reply: true };
     }
@@ -182,3 +286,39 @@ async function send(
     /* 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 editStatus(
+  deps: BotDeps,
+  chatId: number,
+  messageId: number,
+  text: string,
+): Promise<void> {
+  try {
+    await deps.api.editMessageText(chatId, messageId, text);
+  } catch {
+    /* non-fatal */
+  }
+}

package/src/bot/handlers/photo.ts

@@ -193,8 +193,11 @@ async function submit(
     quotedText: quoted,
   });
   if (outcome === "queued") {
+    // Omit General (1) — Bot API rejects message_thread_id=1.
     const extra: Record<string, unknown> =
-      threadId !== undefined ? { message_thread_id: threadId } : {};
+      threadId !== undefined && threadId !== 1
+        ? { message_thread_id: threadId }
+        : {};
     if (anchor?.replyTo !== undefined) {
       extra.reply_parameters = {
         message_id: anchor.replyTo,

package/src/bot/handlers/system.ts

@@ -1,9 +1,14 @@
 /**
- * System commands: /queue /clearqueue /model /restart.
+ * System commands: /queue /clearqueue /model /restart /sandbox.
  */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import type { Bot } from "grammy";
+import { InlineKeyboard } from "grammy";
+import { ENV_PATH } from "../../config.js";
 import type { BotDeps } from "../deps.js";
 
+const SANDBOX_PROFILES = ["workspace-safe", "workspace", "strict", "read-only", "off"] as const;
+
 export function registerSystem(bot: Bot, deps: BotDeps): void {
   bot.command("queue", async (ctx) => {
     const rt = deps.registry.get(ctx.chat.id);
@@ -48,4 +53,61 @@ export function registerSystem(bot: Bot, deps: BotDeps): void {
       await ctx.reply(`\u274C Restart failed: ${(err as Error).message}`);
     }
   });
+
+  bot.command("sandbox", async (ctx) => {
+    const arg = (ctx.match || "").toString().trim();
+    const current = deps.cfg.sandboxProfile || process.env.GROK_SANDBOX || "(from ~/.grok/config.toml)";
+    if (!arg) {
+      const kb = new InlineKeyboard();
+      for (const p of SANDBOX_PROFILES) kb.text(p, `sbx:${p}`).row();
+      await ctx.reply(
+        `\u{1F6E1} Sandbox profile now: ${current}\n` +
+          `Grok reads GROK_SANDBOX. Pick one, then /restart.\n` +
+          `Or: /sandbox workspace-safe`,
+        { reply_markup: kb },
+      );
+      return;
+    }
+    if (!(SANDBOX_PROFILES as readonly string[]).includes(arg)) {
+      await ctx.reply(`Unknown profile. Use: ${SANDBOX_PROFILES.join(", ")}`);
+      return;
+    }
+    try {
+      upsertEnv("GROK_SANDBOX", arg);
+      deps.cfg.sandboxProfile = arg;
+      process.env.GROK_SANDBOX = arg;
+      deps.acp.setAgentOptions({ sandboxProfile: arg });
+      await ctx.reply(`\u2705 GROK_SANDBOX=${arg} written. Send /restart to apply.`);
+    } catch (e) {
+      await ctx.reply(`\u274C Could not write .env: ${(e as Error).message}`);
+    }
+  });
+
+  bot.callbackQuery(/^sbx:([\w-]+)$/, async (ctx) => {
+    const profile = ctx.match![1]!;
+    if (!(SANDBOX_PROFILES as readonly string[]).includes(profile)) {
+      await ctx.answerCallbackQuery({ text: "Unknown profile" });
+      return;
+    }
+    try {
+      upsertEnv("GROK_SANDBOX", profile);
+      deps.cfg.sandboxProfile = profile;
+      process.env.GROK_SANDBOX = profile;
+      deps.acp.setAgentOptions({ sandboxProfile: profile });
+      await ctx.answerCallbackQuery({ text: profile });
+      await ctx.editMessageText(`\u2705 GROK_SANDBOX=${profile}. Send /restart to apply.`).catch(() => {});
+    } catch (e) {
+      await ctx.answerCallbackQuery({ text: (e as Error).message.slice(0, 40) });
+    }
+  });
+}
+
+/** Set KEY=value in the instance .env without dumping secrets. */
+function upsertEnv(key: string, value: string): void {
+  if (!existsSync(ENV_PATH)) throw new Error(".env not found");
+  let body = readFileSync(ENV_PATH, "utf-8");
+  const re = new RegExp(`^${key}=.*$`, "m");
+  if (re.test(body)) body = body.replace(re, `${key}=${value}`);
+  else body = body.replace(/\s*$/, `\n${key}=${value}\n`);
+  writeFileSync(ENV_PATH, body, "utf-8");
 }

package/src/bot/image-return.ts

@@ -145,7 +145,10 @@ export async function sendImages(
   if (opts.replyTo !== undefined) {
     extra.reply_parameters = { message_id: opts.replyTo, allow_sending_without_reply: true };
   }
-  if (opts.messageThreadId !== undefined) extra.message_thread_id = opts.messageThreadId;
+  // Omit General (1) — Bot API rejects message_thread_id=1.
+  if (opts.messageThreadId !== undefined && opts.messageThreadId !== 1) {
+    extra.message_thread_id = opts.messageThreadId;
+  }
   for (const path of paths) {
     if (sent >= opts.max) break;
     if (opts.already.has(path)) continue;

package/src/bot/manager-context.ts

@@ -0,0 +1,208 @@
+/**
+ * Auto-injected context for General manager turns: topic catalog, memory hits,
+ * recent General chat history, and active dispatch jobs.
+ */
+import { join } from "node:path";
+import type { ForumManager } from "../forum/manager.js";
+import { readHistory } from "../sessions/history.js";
+import type { SessionStore } from "../sessions/store.js";
+import { searchGroupMemory } from "./group-memory.js";
+import { listActiveManagerJobs, listRecentManagerJobs, type ManagerJob } from "./manager-jobs.js";
+
+export const MANAGER_CONTEXT_MARKER = "MANAGER CONTEXT (auto — use before dispatching work):";
+
+const CONTEXT_MAX = 6500;
+
+export interface ManagerContextOpts {
+  userText: string;
+  sessionsDir: string;
+  store: SessionStore;
+  forum?: ForumManager;
+  /** Override jobs list (tests). */
+  jobs?: ManagerJob[];
+}
+
+/** Build a capped context block for manager prompts. */
+export function buildManagerContextBlock(opts: ManagerContextOpts): string {
+  const lines: string[] = [MANAGER_CONTEXT_MARKER, ""];
+
+  const topics = opts.forum?.isReady ? opts.forum.store.all() : [];
+  lines.push("## Topics");
+  if (topics.length === 0) {
+    lines.push("(no forum topics mapped)");
+  } else {
+    const topicCap = 40;
+    for (const t of topics.slice(0, topicCap)) {
+      const path = t.projectPath ?? "(unbound)";
+      lines.push(`- **${t.name}** #${t.threadId} [${t.kind}] \`${path}\``);
+    }
+    if (topics.length > topicCap) {
+      lines.push(`… +${topics.length - topicCap} more (use list_topics)`);
+    }
+  }
+
+  const workspace =
+    topics.find((t) => t.kind === "general")?.projectPath ||
+    topics.find((t) => t.kind === "ai_chat")?.projectPath ||
+    undefined;
+  const preferPaths = [
+    workspace,
+    ...topics
+      .filter((t) => t.kind === "project" && t.projectPath)
+      .map((t) => t.projectPath!)
+      .slice(0, 12),
+  ].filter(Boolean) as string[];
+
+  // Always surface recent General chat so the manager "remembers" this room.
+  lines.push("", "## Recent General chat (always available)");
+  const generalSnips = recentGeneralHistory(opts, workspace, 10);
+  if (generalSnips.length === 0) {
+    lines.push("(no prior General history on disk yet)");
+  } else {
+    for (const s of generalSnips) lines.push(`- ${s}`);
+  }
+
+  lines.push(
+    "",
+    "## Memory hits (ranked: relevance + recency — newest work first, not git)",
+  );
+  const hits = searchGroupMemory({
+    query: opts.userText,
+    limit: 14,
+    sessionsDir: opts.sessionsDir,
+    store: opts.store,
+    topics: topics.length ? topics : undefined,
+    preferPaths,
+    preferGeneral: true,
+    maxSessions: 32,
+  });
+  if (hits.length === 0) {
+    lines.push(
+      "(no hits — call search_memory; do NOT run git until memory is exhausted)",
+    );
+  } else {
+    for (const h of hits) {
+      const where =
+        h.threadId !== undefined
+          ? ` #${h.threadId}`
+          : h.sessionId
+            ? ` session=${h.sessionId.slice(0, 8)}`
+            : "";
+      lines.push(`- [${h.kind}] ${h.title}${where}: ${h.snippet}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "Rules: for \"last modifications / last work\" trust hits with [Xm/h/d ago] stamps — prefer the newest session for that project path.",
+    "Ignore older OmniRoute-style notes if a newer session for the same path exists.",
+    "Do not use git log/status as the first step unless the user asked for git.",
+  );
+
+  const jobs = opts.jobs ?? [...listActiveManagerJobs(8), ...listRecentManagerJobs(4)];
+  const seen = new Set<string>();
+  const uniq: ManagerJob[] = [];
+  for (const j of jobs) {
+    if (seen.has(j.id)) continue;
+    seen.add(j.id);
+    uniq.push(j);
+    if (uniq.length >= 10) break;
+  }
+  lines.push("", "## Manager jobs (this process)");
+  if (uniq.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const j of uniq) {
+      const ageMin = Math.max(0, Math.round((Date.now() - j.createdAt) / 60_000));
+      lines.push(
+        `- ${j.status} **${j.targetName}** #${j.targetThreadId} (${ageMin}m ago) job=${j.id}` +
+          (j.childSessionId ? ` session=${j.childSessionId.slice(0, 8)}` : ""),
+      );
+      if (j.userAskPreview) lines.push(`  ask: ${clamp(j.userAskPreview, 160)}`);
+    }
+  }
+
+  lines.push(
+    "",
+    "Use this context to pick the right topic and write a strong send_prompt.",
+    "When a hit shows session=XXXXXXXX and the user wants follow-up there, pass that exact",
+    "prefix as session_id on send_prompt (do NOT rely on the topic's currently open session).",
+    "Prefer search_memory again if you need deeper history before dispatching.",
+  );
+
+  let block = lines.join("\n");
+  if (block.length > CONTEXT_MAX) {
+    block = block.slice(0, CONTEXT_MAX - 1) + "\u2026";
+  }
+  return block;
+}
+
+/** Last user/assistant lines from General-named or workspace sessions. */
+function recentGeneralHistory(
+  opts: ManagerContextOpts,
+  workspace: string | undefined,
+  limit: number,
+): string[] {
+  const out: string[] = [];
+  let metas;
+  try {
+    metas = opts.store.list(40);
+  } catch {
+    return out;
+  }
+  const ws = workspace?.replace(/\\/g, "/").toLowerCase();
+  const ranked = metas
+    .map((m) => {
+      const title = (m.title || "").toLowerCase();
+      const cwd = (m.cwd || "").replace(/\\/g, "/").toLowerCase();
+      let rank = 0;
+      // Prefer sessions explicitly labeled General — never treat every project
+      // under the workspace root as "General chat" (path prefix trap).
+      if (title === "general") rank += 12;
+      else if (/\bgeneral\b/.test(title)) rank += 6;
+      // Exact workspace cwd only (General/AI Chat bind), not child project paths.
+      if (ws && cwd === ws) rank += 4;
+      return { m, rank };
+    })
+    .filter((x) => x.rank > 0)
+    .sort(
+      (a, b) =>
+        b.rank - a.rank ||
+        String(b.m.updatedAt || "").localeCompare(String(a.m.updatedAt || "")),
+    );
+
+  for (const { m } of ranked.slice(0, 4)) {
+    try {
+      const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
+      const entries = readHistory(path, 8);
+      for (const e of entries) {
+        if (!e.text?.trim()) continue;
+        // Skip huge manager context dumps in history.
+        if (e.text.includes(MANAGER_CONTEXT_MARKER)) continue;
+        if (e.text.startsWith("MANAGER MODE")) continue;
+        const role = e.role === "user" ? "user" : e.role === "assistant" ? "bot" : e.role;
+        out.push(
+          `${role} · ${m.sessionId.slice(0, 8)}: ${clamp(e.text.replace(/\s+/g, " "), 180)}`,
+        );
+        if (out.length >= limit) return out;
+      }
+    } catch {
+      /* skip */
+    }
+  }
+  return out;
+}
+
+/** Prepend context block to a user/manager prompt body (idempotent). */
+export function injectManagerContext(text: string, contextBlock: string): string {
+  const body = text.trim();
+  if (!contextBlock.trim()) return body;
+  if (body.includes(MANAGER_CONTEXT_MARKER)) return body;
+  return `${contextBlock}\n\n---\n\n${body}`;
+}
+
+function clamp(s: string, max: number): string {
+  const t = s.replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  return t.slice(0, max - 1) + "\u2026";
+}