grok-telegram-bot 2.2.4 → 2.3.1

package/src/bot/handlers/menu.ts

@@ -56,8 +56,10 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
   bot.callbackQuery(/^agent:set:(\d+)$/, async (ctx) => {
     const mode = deps.acp.availableModes[Number(ctx.match![1])];
     if (!mode) return void ctx.answerCallbackQuery({ text: "Expired, tap Agent again." });
+    // Answer before ACP so a slow setMode never expires the callback query.
+    await ctx.answerCallbackQuery({ text: `\u{1F916} Agent: ${mode.name}` });
     await deps.registry.get(ctx.chat!.id).setAgentPref(mode.id);
-    await confirm(ctx, deps, `\u{1F916} Agent: ${mode.name}`);
+    await confirmUi(ctx, deps);
   });
 
   // ── Reasoning ──────────────────────────────────────────────────────────────
@@ -71,12 +73,17 @@ export function registerMenu(bot: Bot, deps: BotDeps): void {
   bot.callbackQuery(/^model:set:(\d+)$/, async (ctx) => {
     const entry = deps.acp.availableModels[Number(ctx.match![1])];
     if (!entry) return void ctx.answerCallbackQuery({ text: "Expired, tap Model again." });
+    await ctx.answerCallbackQuery({ text: `\u{1F9E9} Model: ${entry.name}` });
     const res = await deps.registry.get(ctx.chat!.id).setModelPref(entry.modelId);
-    await confirm(ctx, deps, res.ok ? `\u{1F9E9} Model: ${entry.name}` : `\u26A0\uFE0F Model set failed: ${res.error}`);
+    if (!res.ok) {
+      await ctx.reply(`\u26A0\uFE0F Model set failed: ${res.error}`).catch(() => {});
+    }
+    await confirmUi(ctx, deps);
   });
   bot.callbackQuery("model:clear", async (ctx) => {
+    await ctx.answerCallbackQuery({ text: "\u{1F9E9} Model: default" });
     await deps.registry.get(ctx.chat!.id).setModelPref("");
-    await confirm(ctx, deps, "\u{1F9E9} Model: default");
+    await confirmUi(ctx, deps);
   });
 }
 
@@ -143,15 +150,25 @@ async function dispatchMenu(ctx: Context, deps: BotDeps, action: string): Promis
       } catch (e) {
         return void ctx.reply(`\u274C ${(e as Error).message}`);
       }
-    case "stop":
-      return void ctx.answerCallbackQuery({ text: (await rt.cancel()) ? "Cancelling\u2026" : "Nothing is running" });
+    case "stop": {
+      // Answer first so a slow cancel never times out the callback query.
+      await ctx.answerCallbackQuery({ text: rt.isBusy ? "Cancelling\u2026" : "Nothing is running" });
+      if (rt.isBusy) await rt.cancel();
+      return;
+    }
     default:
       return void ctx.answerCallbackQuery();
   }
 }
 
 async function confirm(ctx: Context, deps: BotDeps, text: string): Promise<void> {
+  // Toast first (callback must be answered within ~seconds), then UI updates.
   await ctx.answerCallbackQuery({ text });
+  await confirmUi(ctx, deps);
+}
+
+/** Refresh status + reopen the main menu after a preference change. */
+async function confirmUi(ctx: Context, deps: BotDeps): Promise<void> {
   try {
     await ctx.deleteMessage();
   } catch {

package/src/bot/handlers/projects.ts

@@ -60,8 +60,11 @@ export async function sendProjectMenu(
  *  "last used" is the latest of its directory mtime and the newest session
  *  opened in it, so the project you worked in most recently floats to the top. */
 function sortByRecency(entries: ProjectEntry[], deps: BotDeps): ProjectEntry[] {
+  if (entries.length === 0) return entries;
+  // Cap the session scan — full directory walks get expensive as history grows,
+  // and only the freshest sessions matter for ranking.
   const recencyByCwd = new Map<string, number>();
-  for (const s of deps.store.list(300)) {
+  for (const s of deps.store.list(80)) {
     const key = normCwd(s.cwd);
     if (!key) continue;
     const ms = Date.parse(s.updatedAt);
@@ -87,7 +90,8 @@ export async function showProjects(ctx: Context, deps: BotDeps, query?: string):
   if (create) {
     try {
       const entry = deps.projects.create(create[1]!);
-      await deps.registry.controller(ctx.chat!.id).addNew(entry.path, entry.name);
+      // Instant switch — ACP session is created on the first message.
+      await deps.registry.controller(ctx.chat!.id).switchProject(entry.path, entry.name);
       await refreshMenu(ctx, deps, `\u2705 Created and opened ${entry.name}\n${entry.path} \u2014 send a message.`);
     } catch (e) {
       await deps.ephemeral.open(ctx);
@@ -132,7 +136,7 @@ async function openProjectPath(ctx: Context, deps: BotDeps, raw: string): Promis
   await deps.ephemeral.open(ctx);
   const name = basename(dir) || dir;
   try {
-    await deps.registry.controller(ctx.chat!.id).addNew(dir, name);
+    await deps.registry.controller(ctx.chat!.id).switchProject(dir, name);
     await refreshMenu(ctx, deps, `\u{1F4C1} Now working in ${name}\n${dir} \u2014 send a message.`);
   } catch (e) {
     await deps.ephemeral.reply(ctx, `\u274C Could not open ${dir}: ${(e as Error).message}`);
@@ -171,10 +175,12 @@ export function registerProjects(bot: Bot, deps: BotDeps): void {
       await ctx.answerCallbackQuery({ text: "Selection expired, run /projects again." });
       return;
     }
-    await ctx.answerCallbackQuery();
+    // Answer immediately (before any work) so Telegram never times out the query.
+    await ctx.answerCallbackQuery({ text: `Opening ${entry.name}\u2026` });
     await deps.ephemeral.clear(ctx.chat!.id); // remove the project picker
     try {
-      await deps.registry.controller(ctx.chat!.id).addNew(entry.path, entry.name);
+      // Instant: no ACP session/new — live session is created on first message.
+      await deps.registry.controller(ctx.chat!.id).switchProject(entry.path, entry.name);
       await refreshMenu(ctx, deps, `\u{1F4C1} Now working in ${entry.name} \u2014 send a message.`);
     } catch (err) {
       await ctx.reply(`\u274C Could not open ${entry.name}: ${(err as Error).message}`);

package/src/bot/handlers/voice.ts

@@ -1,6 +1,10 @@
 /**
  * Voice & audio handler — transcribes Telegram voice notes / audio files to
  * text (any language) and submits them as prompts.
+ *
+ * Requires STT_API_URL (and optionally STT_API_KEY). Grok Build CLI over ACP
+ * does not accept audio content blocks, so without an STT endpoint voice is
+ * disabled rather than attaching raw audio the agent cannot hear.
  */
 import type { Bot, Context } from "grammy";
 import { textPrompt } from "../../app/types.js";
@@ -18,7 +22,9 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
       return;
     }
     if (!deps.stt.enabled) {
-      await ctx.reply("\u{1F399} Voice isn't configured. Set STT_API_URL (and STT_API_KEY) in .env.");
+      await ctx.reply(
+        "\u{1F399} Voice isn't configured. Set STT_API_URL (and STT_API_KEY if needed) in .env.",
+      );
       return;
     }
     await ctx.replyWithChatAction("typing").catch(() => {});
@@ -41,9 +47,20 @@ export function registerVoice(bot: Bot, deps: BotDeps): void {
     }
   };
 
-  bot.on("message:voice", (ctx) => handle(ctx, ctx.message.voice.file_id, ctx.message.voice.mime_type || "audio/ogg", "voice.ogg"));
-  bot.on("message:audio", (ctx) => handle(ctx, ctx.message.audio.file_id, ctx.message.audio.mime_type || "audio/mpeg", ctx.message.audio.file_name || "audio.mp3"));
-  bot.on("message:video_note", (ctx) => handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4"));
+  bot.on("message:voice", (ctx) =>
+    handle(ctx, ctx.message.voice.file_id, ctx.message.voice.mime_type || "audio/ogg", "voice.ogg"),
+  );
+  bot.on("message:audio", (ctx) =>
+    handle(
+      ctx,
+      ctx.message.audio.file_id,
+      ctx.message.audio.mime_type || "audio/mpeg",
+      ctx.message.audio.file_name || "audio.mp3",
+    ),
+  );
+  bot.on("message:video_note", (ctx) =>
+    handle(ctx, ctx.message.video_note.file_id, "video/mp4", "note.mp4"),
+  );
 }
 
 async function download(ctx: Context, fileId: string, token: string): Promise<Buffer | undefined> {

package/src/bot/image-return.ts

@@ -1,30 +1,125 @@
 /**
- * Agent image return — detects image files the agent produced this turn
- * (screenshots, diagrams…) from its output and tool inputs, and sends them
- * back to Telegram. Only fresh files (modified during the turn) are sent.
+ * Agent image return — finds image files the agent produced this turn
+ * (Imagine `image_gen` / `image_edit`, screenshots, diagrams…) and sends them
+ * back to Telegram as **downloadable files** (`sendDocument`).
+ *
+ * Discovery sources:
+ *   1. Paths mentioned in agent text / tool inputs (project-relative or absolute)
+ *   2. Fresh files under the Grok session media dirs
+ *      (`~/.grok/sessions/<encoded-cwd>/<sessionId>/images/` and `…/assets/`)
+ *   3. Fresh files under `<cwd>/images/` (common short path reported by tools)
  */
 import { type Api, InputFile } from "grammy";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
 import { createLogger } from "../logger.js";
 
+// Re-export so existing import paths (`./image-return.js`) keep working.
+export { IMAGE_OUTPUT_DIRECTIVE } from "../render/image-output.js";
+
 const log = createLogger("image-return");
 
-const PATH_RE = /[^\s"'`<>|()*\[\]]+\.(?:png|jpe?g|gif|webp|bmp)/gi;
-const PHOTO_EXT = new Set(["png", "jpg", "jpeg", "webp"]);
-const MAX_PHOTO_BYTES = 10 * 1024 * 1024;
+/** Absolute / relative image path tokens in free text (Unix + Windows). */
+const PATH_RE =
+  /(?:[A-Za-z]:[\\/]|\/|~[\\/]|\.{1,2}[\\/])?[^\s"'`<>|()*\[\]{}]+\.(?:png|jpe?g|gif|webp|bmp)/gi;
+const IMAGE_EXT = new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
 const MAX_FILE_BYTES = 45 * 1024 * 1024;
 
 /** Pull candidate image paths out of arbitrary text, resolved against cwd. */
 export function extractImagePaths(text: string, cwd: string): string[] {
   const out = new Set<string>();
   for (const m of text.matchAll(PATH_RE)) {
-    const raw = m[0].replace(/[).,;:]+$/, "");
+    let raw = m[0].replace(/[).,;:]+$/, "");
+    if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+      raw = join(homedir(), raw.slice(2));
+    }
     out.add(isAbsolute(raw) ? raw : join(cwd, raw));
   }
   return [...out];
 }
 
+/**
+ * Grok stores per-session media under:
+ *   ~/.grok/sessions/<encodeURIComponent(cwd)>/<sessionId>/{images,assets}/
+ * Imagine `image_gen` currently prefers `images/`; older runs used `assets/`.
+ */
+export function grokSessionMediaRoot(cwd: string, sessionId: string): string {
+  return join(homedir(), ".grok", "sessions", encodeURIComponent(cwd), sessionId);
+}
+
+/** @deprecated Prefer grokSessionMediaDirs — kept for callers/tests that used assets. */
+export function grokSessionAssetsDir(cwd: string, sessionId: string): string {
+  return join(grokSessionMediaRoot(cwd, sessionId), "assets");
+}
+
+/** Session folders where Imagine / tools drop generated images. */
+export function grokSessionMediaDirs(cwd: string, sessionId: string): string[] {
+  const root = grokSessionMediaRoot(cwd, sessionId);
+  return [join(root, "images"), join(root, "assets")];
+}
+
+/** List image files under `dir` modified at/after `since` (non-recursive). */
+export function listFreshImagesInDir(dir: string, since: number): string[] {
+  if (!existsSync(dir)) return [];
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out: string[] = [];
+  for (const name of names) {
+    const path = join(dir, name);
+    const ext = name.toLowerCase().split(".").pop() ?? "";
+    if (!IMAGE_EXT.has(ext)) continue;
+    try {
+      const st = statSync(path);
+      if (!st.isFile() || st.size === 0 || st.size > MAX_FILE_BYTES) continue;
+      // 2s slack for clock skew / write completion.
+      if (st.mtimeMs < since - 2000) continue;
+      out.push(path);
+    } catch {
+      /* skip */
+    }
+  }
+  // Newest first so max-cap still keeps the latest gens.
+  return out.sort((a, b) => {
+    try {
+      return statSync(b).mtimeMs - statSync(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+}
+
+/** Collect all image candidates for a turn from text + known asset locations. */
+export function collectTurnImagePaths(opts: {
+  scanText: string;
+  cwd: string;
+  sessionId?: string;
+  since: number;
+}): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  const add = (paths: string[]) => {
+    for (const p of paths) {
+      if (seen.has(p)) continue;
+      seen.add(p);
+      out.push(p);
+    }
+  };
+
+  add(extractImagePaths(opts.scanText, opts.cwd));
+  add(listFreshImagesInDir(join(opts.cwd, "images"), opts.since));
+  if (opts.sessionId) {
+    for (const dir of grokSessionMediaDirs(opts.cwd, opts.sessionId)) {
+      add(listFreshImagesInDir(dir, opts.since));
+    }
+  }
+  return out;
+}
+
 export interface SendImagesOptions {
   /** Only send files modified at/after this epoch ms (fresh this turn). */
   since: number;
@@ -32,9 +127,11 @@ export interface SendImagesOptions {
   already: Set<string>;
   /** Max images to send in this call. */
   max: number;
+  /** Optional Telegram message id to thread replies under. */
+  replyTo?: number;
 }
 
-/** Send the valid, fresh, not-yet-sent images. Returns how many were sent. */
+/** Send the valid, fresh, not-yet-sent images as documents. Returns how many were sent. */
 export async function sendImages(
   api: Api,
   chatId: number,
@@ -42,6 +139,10 @@ export async function sendImages(
   opts: SendImagesOptions,
 ): Promise<number> {
   let sent = 0;
+  const replyExtra =
+    opts.replyTo !== undefined
+      ? { reply_parameters: { message_id: opts.replyTo, allow_sending_without_reply: true } }
+      : {};
   for (const path of paths) {
     if (sent >= opts.max) break;
     if (opts.already.has(path)) continue;
@@ -55,12 +156,15 @@ export async function sendImages(
     if (st.mtimeMs < opts.since - 2000) continue; // skip pre-existing files
     opts.already.add(path);
     try {
-      const ext = path.toLowerCase().split(".").pop() ?? "";
-      const asPhoto = PHOTO_EXT.has(ext) && st.size <= MAX_PHOTO_BYTES;
-      const file = new InputFile(path);
-      if (asPhoto) await api.sendPhoto(chatId, file, { caption: basename(path) });
-      else await api.sendDocument(chatId, file, { caption: basename(path) });
+      // Always send as a document so Telegram delivers a downloadable file
+      // (not a compressed photo bubble).
+      const file = new InputFile(path, basename(path));
+      await api.sendDocument(chatId, file, {
+        caption: basename(path),
+        ...replyExtra,
+      });
       sent++;
+      log.debug(`sent document ${path}`);
     } catch (e) {
       log.debug(`failed to send ${path}:`, (e as Error).message);
     }

package/src/bot/prompt-content.ts

@@ -1,7 +1,7 @@
 /**
- * Build ACP prompt content blocks from a PromptInput (text + images), applying
- * the reasoning directive and any fork-priming context. Also merges multiple
- * queued inputs into one.
+ * Build ACP prompt content blocks from a PromptInput (text + images + optional
+ * resource links), applying the reasoning directive and any fork-priming
+ * context. Also merges multiple queued inputs into one.
  */
 import type { ContentBlock } from "../grok/types.js";
 import type { PromptInput } from "../app/types.js";
@@ -9,8 +9,10 @@ import type { PromptInput } from "../app/types.js";
 export interface ContentOptions {
   reasoning?: string;
   priming?: string;
-  /** Appended at the very bottom so the agent emits a `{progress: N%}` marker. */
+  /** Appended so the agent emits a `{progress: N%}` marker. */
   progress?: string;
+  /** Appended so the agent keeps generated images in the session media folder. */
+  imageOutput?: string;
 }
 
 export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}): ContentBlock[] {
@@ -19,11 +21,23 @@ export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}
   for (const img of input.images) {
     blocks.push({ type: "image", data: img.data, mimeType: img.mimeType });
   }
+  for (const link of input.resourceLinks ?? []) {
+    blocks.push({
+      type: "resource_link",
+      uri: link.uri,
+      name: link.name,
+      mimeType: link.mimeType,
+      size: link.size,
+    });
+  }
 
   let text = input.text.trim();
   if (!text && input.images.length > 0) {
     text = input.images.length === 1 ? "Please analyze the attached image." : "Please analyze the attached images.";
   }
+  if (!text && (input.resourceLinks?.length ?? 0) > 0) {
+    text = "Please process the attached file(s).";
+  }
   if (input.quotedText?.trim()) {
     const quoted = input.quotedText.trim();
     const body = text || "(the user's reply carried no additional text)";
@@ -35,7 +49,11 @@ export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}
   if (opts.reasoning) {
     text = `(${opts.reasoning})\n\n${text}`;
   }
+  if (opts.imageOutput) {
+    text = `${text}\n\n${opts.imageOutput}`;
+  }
   if (opts.progress) {
+    // Progress last so its "marker is the final line" rule stays true.
     text = `${text}\n\n${opts.progress}`;
   }
 
@@ -43,7 +61,7 @@ export function buildContentBlocks(input: PromptInput, opts: ContentOptions = {}
   return blocks;
 }
 
-/** Merge queued inputs into a single prompt (concatenated text, all images). */
+/** Merge queued inputs into a single prompt (concatenated text, all images/links). */
 export function mergeInputs(inputs: PromptInput[]): PromptInput {
   const quotes = inputs
     .map((i) => i.quotedText?.trim())
@@ -54,6 +72,7 @@ export function mergeInputs(inputs: PromptInput[]): PromptInput {
       .filter((t) => t.trim().length > 0)
       .join("\n\n"),
     images: inputs.flatMap((i) => i.images),
+    resourceLinks: inputs.flatMap((i) => i.resourceLinks ?? []),
     replyTo: inputs.find((i) => i.replyTo !== undefined)?.replyTo,
     quotedText: quotes.length > 0 ? [...new Set(quotes)].join("\n\n---\n\n") : undefined,
   };

package/src/bot/reauth-controller.ts

@@ -180,7 +180,7 @@ export class ReauthController {
       }
       s.phase = "restarting";
       await this.render(s);
-      await this.grok.start();
+      await this.grok.start(true);
       agentDown = false;
       s.accountLabel = accountLabel(await this.getAccount?.().catch(() => undefined));
       s.phase = "done";
@@ -191,7 +191,7 @@ export class ReauthController {
     } finally {
       s.abort = undefined;
       this.stopAnim(s);
-      if (agentDown) await this.grok.start().catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
+      if (agentDown) await this.grok.start(true).catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
       await this.render(s);
     }
   }