grok-telegram-bot 2.3.1 → 2.5.0

package/src/bot/commands.ts

@@ -1,30 +1,61 @@
 /**
  * Bot command definitions (for the Telegram command menu) and help text.
+ *
+ * Private chats get the full list (sorted by workflow). Groups/forum topics get
+ * a shorter list with cancel/menu first — reply keyboards are unreliable there.
  */
+
+/** Full command menu (private chats + default). Order = Telegram "/" menu order. */
 export const COMMANDS: { command: string; description: string }[] = [
+  // Core control
   { command: "start", description: "Welcome, menu & status panel" },
-  { command: "menu", description: "Show the menu keyboard" },
-  { command: "projects", description: "Projects: list / search <q> / open <path> / new <name>" },
-  { command: "sessions", description: "List/resume sessions (active first) \u00b7 /sessions <q>" },
+  { command: "menu", description: "Open the menu" },
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn (alias of /cancel)" },
+  { command: "status", description: "Current session, project & queue" },
+  { command: "new", description: "New session in current project" },
+  // Sessions
+  { command: "running", description: "Sessions this chat controls" },
+  { command: "sessions", description: "List/resume sessions · /sessions <q>" },
   { command: "active", description: "Sessions running now on the PC" },
-  { command: "running", description: "Sessions this chat controls \u2014 switch between them" },
-  { command: "killall", description: "Kill all active sessions on the PC" },
-  { command: "mcp", description: "Inspect & toggle MCP servers \u00b7 health-check" },
-  { command: "tasks", description: "Manage scheduled tasks" },
-  { command: "newtask", description: "Create a scheduled task" },
   { command: "history", description: "Show recent conversation history" },
-  { command: "new", description: "Start a fresh session here" },
-  { command: "status", description: "Current session, project & queue" },
-  { command: "usage", description: "Account & context usage" },
-  { command: "btw", description: "Run ASAP (now if idle, else next): /btw <text>" },
+  { command: "import", description: "Import Kiro/OpenCode/Claude/Codex session" },
+  // Project
+  { command: "projects", description: "Projects: list / search / open / new" },
+  // Queue
+  { command: "btw", description: "Run ASAP: /btw <text>" },
   { command: "flush", description: "Send queued follow-ups now" },
   { command: "queue", description: "Show queued follow-ups" },
-  { command: "cancel", description: "Stop the current turn" },
-  { command: "unwatch", description: "Stop following a live session" },
+  // Account
+  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "reauth", description: "Sign in to Grok (login or import)" },
+  { command: "usage", description: "Account & context usage" },
+  // System / tools
+  { command: "mcp", description: "Inspect & toggle MCP servers" },
+  { command: "tasks", description: "Manage scheduled tasks" },
+  { command: "newtask", description: "Create a scheduled task" },
+  { command: "killall", description: "Kill all active sessions on the PC" },
   { command: "model", description: "Switch model: /model <id>" },
   { command: "restart", description: "Restart the Grok agent" },
-  { command: "reauth", description: "Sign in to Grok (login or import)" },
-  { command: "accounts", description: "Switch between saved Grok accounts" },
+  { command: "unwatch", description: "Stop following a live session" },
+  { command: "help", description: "Show help" },
+];
+
+/**
+ * Group / forum command menu — keep short; cancel & menu first so topics can
+ * stop a turn without the private reply-keyboard bar.
+ */
+export const GROUP_COMMANDS: { command: string; description: string }[] = [
+  { command: "cancel", description: "Stop the current turn" },
+  { command: "stop", description: "Stop the current turn" },
+  { command: "menu", description: "Open topic / group menu" },
+  { command: "status", description: "Session, project & queue" },
+  { command: "new", description: "New session in this topic/project" },
+  { command: "running", description: "Sessions this topic controls" },
+  { command: "sessions", description: "List / resume sessions" },
+  { command: "btw", description: "Queue or run: /btw <text>" },
+  { command: "flush", description: "Run queued follow-ups now" },
+  { command: "model", description: "Switch model: /model <id>" },
   { command: "help", description: "Show help" },
 ];
 
@@ -36,17 +67,28 @@ export const HELP_TEXT = [
   "\u2022 Just send a message to chat with Grok in the current project.",
   "\u2022 While Grok is working, anything you send is queued and runs",
   "  automatically when the current turn finishes.",
+  "\u2022 Persistent bar (private): \u2630 Menu \u00B7 \u{1F195} New session \u00B7 \u{1F9ED} Running \u00B7 \u23F9 Stop.",
+  "\u2022 New session: /new or the bar button (not the inline Menu message).",
+  "\u2022 In groups / forum topics: use /cancel or Menu \u2192 \u23F9 Stop",
+  "  (the persistent bar is unreliable in topics; use /new or topic menu).",
+  "",
+  "COMMANDS (core)",
+  "/menu \u2014 open the menu",
+  "/cancel or /stop \u2014 stop the current turn",
+  "/status \u2014 session, project and queue",
+  "/new \u2014 new session in the current project (also bar: \u{1F195} New session)",
+  "",
+  "COMMANDS (sessions)",
+  "/running \u2014 sessions this chat/topic controls",
+  "/sessions \u2014 resume a recent Grok session",
+  "/active \u2014 attach to a session running on the PC",
+  "/history \u2014 latest messages of the current session",
+  "/import \u2014 import a /running session from another agent",
   "",
-  "COMMANDS",
-  "/projects \u2014 choose which folder Grok works in",
-  "/sessions \u2014 resume one of your recent Grok sessions",
-  "/active \u2014 attach to a session currently running on the PC",
-  "/history \u2014 show the latest messages of the current session",
-  "/new \u2014 start a brand-new session in the current project",
-  "/btw <text> \u2014 run it now if idle, otherwise right after the current task",
+  "COMMANDS (more)",
+  "/projects \u2014 choose which folder Grok works in (private chats)",
+  "/btw <text> \u2014 run now if idle, else right after the current task",
   "/flush \u2014 run queued follow-ups immediately",
-  "/cancel \u2014 stop the current turn",
-  "/status \u2014 show session, project and queue size",
-  "/reauth \u2014 sign in to Grok (grok login, or import an existing login)",
-  "/accounts \u2014 switch between saved Grok accounts",
+  "/reauth \u2014 sign in to Grok",
+  "/accounts \u2014 switch saved Grok accounts",
 ].join("\n");

package/src/bot/complexity-gate.ts

@@ -0,0 +1,69 @@
+/**
+ * First-prompt complexity steering (fully automatic — never asks the user).
+ *
+ * On the first user message of a fresh session the bot prepends a directive so
+ * Grok itself decides Simple vs Complex:
+ *   • Simple  — implement directly.
+ *   • Complex — enter plan mode, investigate carefully, write a plan,
+ *               exit_plan_mode (auto-approved by this bridge), implement,
+ *               then re-review the result.
+ *
+ * No Telegram buttons, no user choice, no waiting.
+ */
+import type { PromptInput } from "../app/types.js";
+
+/**
+ * Agent-only directive. Must stay free of real `{progress: N%}` digit markers
+ * (history cleaner strips those). Uses the letter N only if mentioning format.
+ */
+export const AUTO_COMPLEXITY_DIRECTIVE = [
+  "COMPLEXITY (decide yourself — never ask the user):",
+  "Silently classify this task as Simple or Complex. Do NOT ask the user which it is. Do NOT show Simple/Complex buttons or questions.",
+  "",
+  "If SIMPLE (clear path, small change, obvious fix, short answer):",
+  "  implement or answer directly with normal care.",
+  "",
+  "If COMPLEX (ambiguity, multi-file architecture, high rework risk, unclear approach):",
+  "  1. Enter plan mode (enter_plan_mode) when available.",
+  "  2. Investigate carefully: explore the codebase, map patterns, edge cases, and risks before coding.",
+  "  3. Write a solid plan to the plan file; prefer investigation over speed.",
+  "  4. Call exit_plan_mode when ready. This Telegram bridge auto-approves plan exit",
+  "     (there is no TUI plan popup). After exit_plan_mode succeeds, implement fully.",
+  "     Do NOT wait for the user to \"approve a popup\" — just call exit_plan_mode and proceed.",
+  "  5. After implementation, re-review your work (verify correctness, edge cases, and that the plan was followed) before finishing.",
+  "",
+  "User task:",
+].join("\n");
+
+/** Optional mode ids Grok may advertise for plan mode (best-effort only). */
+export const PLAN_MODE_CANDIDATES = ["plan", "planning", "architect", "design"] as const;
+
+/**
+ * Prepend the auto-complexity directive so the agent decides Simple vs Complex
+ * without any user interaction.
+ */
+export function wrapAutoComplexityPrompt(input: PromptInput): PromptInput {
+  const body = input.text.trim() || "(see attached media / files)";
+  // Avoid double-wrapping if a retry/queue path already applied it.
+  if (body.startsWith("COMPLEXITY (decide yourself")) return input;
+  return {
+    ...input,
+    text: `${AUTO_COMPLEXITY_DIRECTIVE}\n${body}`,
+  };
+}
+
+/** Pick a plan-mode id from the agent's advertised modes, if any. */
+export function pickPlanModeId(
+  modes: Array<{ id: string; name: string }>,
+  hasMode: (id: string) => boolean,
+): string | undefined {
+  for (const id of PLAN_MODE_CANDIDATES) {
+    if (hasMode(id)) return id;
+  }
+  for (const m of modes) {
+    if (/plan|architect|design/i.test(m.id) || /plan|architect|design/i.test(m.name)) {
+      return m.id;
+    }
+  }
+  return undefined;
+}

package/src/bot/deps.ts

@@ -10,12 +10,15 @@ import type { AppConfig } from "../config.js";
 import type { SttService } from "../app/stt.js";
 import type { UsageService } from "../app/usage.js";
 import type { ProjectEntry, ProjectManager } from "../projects/manager.js";
+import type { ImportableSession } from "../import/list-running.js";
+import type { ImportSourceId } from "../import/sources.js";
 import type { SessionMeta } from "../sessions/types.js";
 import type { SessionStore } from "../sessions/store.js";
 import type { TaskRunner } from "../tasks/runner.js";
 import type { TaskStore } from "../tasks/store.js";
 import type { StatusPanel } from "./menu/status-panel.js";
 import type { Ephemeral } from "./menu/ephemeral.js";
+import type { ForumManager } from "../forum/manager.js";
 import type { RuntimeRegistry } from "./registry.js";
 import type { TaskWizard } from "./wizard/task-wizard.js";
 
@@ -36,12 +39,18 @@ export interface BotDeps {
   stt: SttService;
   usage: UsageService;
   accounts: AccountManager;
+  /** Present when TOPIC_GROUP_ID is configured. */
+  forum?: ForumManager;
 }
 
 /** Caches the last project list shown per chat for callback resolution. */
 export class MenuCache {
   private readonly projectLists = new Map<number, ProjectEntry[]>();
   private readonly sessionLists = new Map<number, { metas: SessionMeta[]; heading: string }>();
+  private readonly importLists = new Map<
+    number,
+    { sourceId: ImportSourceId; sessions: ImportableSession[] }
+  >();
 
   setProjects(chatId: number, list: ProjectEntry[]): void {
     this.projectLists.set(chatId, list);
@@ -64,4 +73,17 @@ export class MenuCache {
   getSessions(chatId: number): { metas: SessionMeta[]; heading: string } | undefined {
     return this.sessionLists.get(chatId);
   }
+
+  /** Cache foreign sessions shown by Import session (callback index → session). */
+  setImportSessions(chatId: number, sourceId: ImportSourceId, sessions: ImportableSession[]): void {
+    this.importLists.set(chatId, { sourceId, sessions });
+  }
+
+  getImportSessions(chatId: number): { sourceId: ImportSourceId; sessions: ImportableSession[] } | undefined {
+    return this.importLists.get(chatId);
+  }
+
+  getImportSession(chatId: number, index: number): ImportableSession | undefined {
+    return this.importLists.get(chatId)?.sessions[index];
+  }
 }

package/src/bot/group-memory.ts

@@ -0,0 +1,159 @@
+/**
+ * Local "group memory" search across forum topics, session metadata, and
+ * recent session history. Telegram bots have no general message-search API,
+ * so this indexes what the bridge already stores on disk.
+ */
+import { join } from "node:path";
+import { readHistory } from "../sessions/history.js";
+import type { SessionMeta } from "../sessions/types.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { ForumTopicBinding } from "../forum/types.js";
+
+export type MemoryHitKind = "topic" | "session" | "history";
+
+export interface MemoryHit {
+  kind: MemoryHitKind;
+  title: string;
+  snippet: string;
+  score: number;
+  path?: string;
+  sessionId?: string;
+  threadId?: number;
+}
+
+export interface GroupMemorySearchOpts {
+  query: string;
+  limit?: number;
+  sessionsDir: string;
+  store: SessionStore;
+  topics?: ForumTopicBinding[];
+  /** Max sessions whose JSONL tails are scanned. */
+  maxSessions?: number;
+}
+
+/** Tokenize a query into lowercase alphanumeric tokens (min length 2). */
+export function tokenizeQuery(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9_./\\-]+/i)
+    .map((t) => t.trim())
+    .filter((t) => t.length >= 2)
+    .slice(0, 12);
+}
+
+/** Score how well `haystack` matches tokens (0 if no token hits). */
+export function scoreTokens(haystack: string, tokens: string[]): number {
+  if (!tokens.length || !haystack) return 0;
+  const h = haystack.toLowerCase();
+  let score = 0;
+  let hits = 0;
+  for (const t of tokens) {
+    if (!h.includes(t)) continue;
+    hits++;
+    // Prefer whole-word-ish hits slightly.
+    const re = new RegExp(`(?:^|[^a-z0-9])${escapeReg(t)}(?:[^a-z0-9]|$)`, "i");
+    score += re.test(h) ? 3 : 1;
+    // Density bonus for short fields.
+    if (h.length < 120) score += 1;
+  }
+  if (hits === 0) return 0;
+  // All-token bonus.
+  if (hits === tokens.length) score += 4;
+  return score;
+}
+
+/**
+ * Search topics + session store + recent history. Pure ranking over provided
+ * store; safe to call on the main bot thread (capped I/O).
+ */
+export function searchGroupMemory(opts: GroupMemorySearchOpts): MemoryHit[] {
+  const tokens = tokenizeQuery(opts.query);
+  if (tokens.length === 0) return [];
+  const limit = Math.max(1, Math.min(20, opts.limit ?? 8));
+  const maxSessions = opts.maxSessions ?? 40;
+  const hits: MemoryHit[] = [];
+
+  for (const t of opts.topics ?? []) {
+    const hay = [t.name, t.projectPath ?? "", t.kind, t.sessionId ?? ""].join("\n");
+    const score = scoreTokens(hay, tokens);
+    if (score <= 0) continue;
+    hits.push({
+      kind: "topic",
+      title: t.name,
+      snippet: t.projectPath ? `path: ${t.projectPath}` : `kind: ${t.kind}`,
+      score: score + 2, // slight boost for topic map
+      path: t.projectPath ?? undefined,
+      threadId: t.threadId,
+      sessionId: t.sessionId,
+    });
+  }
+
+  let metas: SessionMeta[] = [];
+  try {
+    metas = opts.store.list(maxSessions);
+  } catch {
+    metas = [];
+  }
+
+  for (const m of metas) {
+    const hay = [m.title, m.comment ?? "", m.cwd, m.sessionId].join("\n");
+    const score = scoreTokens(hay, tokens);
+    if (score > 0) {
+      hits.push({
+        kind: "session",
+        title: m.title || m.sessionId.slice(0, 8),
+        snippet: clamp(
+          [m.comment, m.cwd].filter(Boolean).join(" · ") || m.sessionId,
+          220,
+        ),
+        score,
+        path: m.cwd || undefined,
+        sessionId: m.sessionId,
+      });
+    }
+
+    // History tail (cheap): few entries, short text.
+    if (m.historyBytes <= 0) continue;
+    try {
+      const path = join(opts.sessionsDir, `${m.sessionId}.jsonl`);
+      const entries = readHistory(path, 12);
+      for (const e of entries) {
+        if (!e.text?.trim()) continue;
+        const s = scoreTokens(e.text, tokens);
+        if (s <= 0) continue;
+        hits.push({
+          kind: "history",
+          title: `${e.role} · ${(m.title || m.sessionId.slice(0, 8)).slice(0, 40)}`,
+          snippet: clamp(e.text.replace(/\s+/g, " ").trim(), 220),
+          score: s,
+          path: m.cwd || undefined,
+          sessionId: m.sessionId,
+        });
+      }
+    } catch {
+      /* ignore unreadable logs */
+    }
+  }
+
+  hits.sort((a, b) => b.score - a.score || a.kind.localeCompare(b.kind));
+  // Dedupe near-identical snippets.
+  const seen = new Set<string>();
+  const out: MemoryHit[] = [];
+  for (const h of hits) {
+    const key = `${h.kind}|${h.sessionId ?? h.threadId ?? ""}|${h.snippet.slice(0, 80)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(h);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function clamp(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+
+function escapeReg(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/bot/handlers/accounts.ts

@@ -11,6 +11,7 @@ import { type Bot, type Context, InlineKeyboard } from "grammy";
 import { AuthService } from "../../app/auth-service.js";
 import type { StoredAccount } from "../../app/accounts.js";
 import { UNSUPPORTED_LOGIN_HELP } from "../../app/grok-credentials.js";
+import { formatCliBillingLines } from "../../app/usage.js";
 import { createLogger } from "../../logger.js";
 import type { BotDeps } from "../deps.js";
 
@@ -48,12 +49,35 @@ async function view(deps: BotDeps, note?: string): Promise<{ text: string; keybo
   } else {
     lines.push("\u{1F7E2} Signed in (identity unknown).", "");
   }
+  // Live Grok CLI monthly quota for the host login (same source as OmniRoute-style clients).
+  if (loggedIn) {
+    const { billing, error } = await deps.usage.cliBilling().catch((e) => ({
+      billing: undefined,
+      error: (e as Error).message,
+    }));
+    if (billing) {
+      lines.push(...formatCliBillingLines(billing), "");
+    } else if (error) {
+      lines.push(`\u{1F4B3} Grok CLI quota: unavailable (${error})`, "");
+    }
+  }
   if (list.length === 0) {
     lines.push("No saved accounts yet.", "", "Save the current login below, or sign in via /reauth.");
   } else {
     for (const a of list) {
       lines.push(accountLine(a, a.id === active));
-      if (a.warning) lines.push("  \u2514 Skipped by auto-rotate after an account access or quota error.");
+      const usage = deps.accounts.formatUsageLine(a);
+      if (usage) lines.push(`  \u2514 \u{1F4CA} ${usage}`);
+      else lines.push("  \u2514 \u{1F4CA} No recorded usage yet");
+      if (a.warning) {
+        lines.push(
+          `  \u2514 \u26A0\uFE0F Skipped by auto-rotate: ${a.warning.reason.slice(0, 80)}${a.warning.reason.length > 80 ? "\u2026" : ""}`,
+        );
+      }
+    }
+    const totals = summarizeUsage(list);
+    if (totals) {
+      lines.push("", `\u{1F4CA} All saved accounts: ${totals}`);
     }
   }
   const rotate = deps.accounts.autoRotateEnabled();
@@ -86,6 +110,32 @@ function trim(s: string, n = 22): string {
   return s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 }
 
+/** Aggregate usage across saved accounts for the footer line. */
+function summarizeUsage(list: StoredAccount[]): string {
+  let turns = 0;
+  let credits = 0;
+  let used = 0;
+  for (const a of list) {
+    const u = a.usage;
+    if (!u) continue;
+    if (u.turns > 0 || u.credits > 0) used++;
+    turns += u.turns || 0;
+    credits += u.credits || 0;
+  }
+  if (used === 0 && turns === 0 && credits === 0) return "";
+  const parts: string[] = [];
+  if (turns > 0) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (credits > 0) parts.push(`${fmtNum(credits)} credits total`);
+  parts.push(`${used}/${list.length} accounts used`);
+  return parts.join(" \u00B7 ");
+}
+
+function fmtNum(n: number): string {
+  if (!Number.isFinite(n)) return String(n);
+  if (Number.isInteger(n)) return n.toLocaleString("en-US");
+  return n.toFixed(2);
+}
+
 export async function showAccounts(ctx: Context, deps: BotDeps): Promise<void> {
   const { text, keyboard } = await view(deps);
   await deps.ephemeral.open(ctx);
@@ -244,6 +294,13 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
         await deps.acp.start(true).catch(() => {});
         throw e;
       }
+      // Remember preferred account for this chat/topic scope (model/reasoning peers).
+      try {
+        const { resolveScope } = await import("../scope.js");
+        resolveScope(ctx, deps).rt.setPreferredAccountId(id);
+      } catch {
+        /* non-fatal */
+      }
       const note = (await deps.usage.isLoggedIn())
         ? `\u2705 Now signed in as ${meta.label}. Your next message runs on this account.`
         : `\u26A0\uFE0F Switched to ${meta.label}, but no usable login is active. ${UNSUPPORTED_LOGIN_HELP}`;