grok-telegram-bot 2.0.0

package/src/bot/reauth-controller.ts

@@ -0,0 +1,297 @@
+/**
+ * ReauthController — signs in to Grok from chat. `/reauth` offers "Sign in"
+ * (runs `grok login`, streaming any verification URL/code to the chat) or
+ * "Import existing" (adopt a login already on the host). The agent is taken
+ * down before sign-in and restarted after, so it re-binds under the new
+ * identity. State is per chat so button callbacks work across updates.
+ */
+import { type Api, InlineKeyboard } from "grammy";
+import type { GrokClient } from "../grok/client.js";
+import { AuthService } from "../app/auth-service.js";
+import type { AccountInfo } from "../app/usage.js";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("reauth");
+
+const LOADER = ["▰▱▱▱▱▱▱", "▰▰▱▱▱▱▱", "▰▰▰▱▱▱▱", "▰▰▰▰▱▱▱", "▰▰▰▰▰▱▱", "▰▰▰▰▰▰▱", "▰▰▰▰▰▰▰"];
+const ANIM_MS = 2500;
+const LOGIN_TIMEOUT_MS = 300_000;
+
+type Phase = "choosing" | "login" | "restarting" | "done" | "failed" | "cancelled";
+const ACTIVE: ReadonlySet<Phase> = new Set<Phase>(["login", "restarting"]);
+
+interface ReauthSession {
+  chatId: number;
+  messageId: number;
+  phase: Phase;
+  abort?: AbortController;
+  anim?: NodeJS.Timeout;
+  frame: number;
+  url?: string;
+  code?: string;
+  errorMsg?: string;
+  accountLabel?: string;
+  lastText?: string;
+}
+
+/** Pull a verification URL and short code out of streaming login output. */
+function parseLoginOutput(raw: string): { url?: string; code?: string } {
+  const text = raw.replace(/\r/g, "");
+  const url = text.match(/https?:\/\/[^\s'"<>)\]]+/i)?.[0];
+  const code = text.match(/\b[A-Z0-9]{4}-[A-Z0-9]{4}\b/)?.[0] ?? text.match(/code[:\s]+([A-Z0-9][A-Z0-9-]{3,})/i)?.[1];
+  return { url, code };
+}
+
+export class ReauthController {
+  private readonly auth: AuthService;
+  private readonly sessions = new Map<number, ReauthSession>();
+
+  constructor(
+    private readonly api: Api,
+    private readonly grok: GrokClient,
+    grokCliPath: string,
+    private readonly getAccount?: () => Promise<AccountInfo | undefined>,
+    private readonly verifyLogin?: () => Promise<boolean>,
+  ) {
+    this.auth = new AuthService(grokCliPath);
+  }
+
+  isBusy(chatId: number): boolean {
+    const s = this.sessions.get(chatId);
+    return !!s && ACTIVE.has(s.phase);
+  }
+
+  private anyActive(): boolean {
+    for (const s of this.sessions.values()) if (ACTIVE.has(s.phase)) return true;
+    return false;
+  }
+
+  /** Show the sign-in entry screen. */
+  async chooseMethod(chatId: number, existingMessageId?: number): Promise<void> {
+    if (this.isBusy(chatId)) return;
+    let messageId = existingMessageId;
+    if (messageId === undefined) {
+      const m = await this.api.sendMessage(chatId, "\u{1F510} Sign in to Grok\u2026").catch(() => undefined);
+      if (!m) return;
+      messageId = m.message_id;
+    }
+    const s: ReauthSession = { chatId, messageId, phase: "choosing", frame: 0 };
+    this.sessions.set(chatId, s);
+    await this.render(s);
+  }
+
+  /** Run `grok logout` + `grok login`, then restart the agent. */
+  async beginLogin(chatId: number, messageId: number): Promise<void> {
+    if (this.isBusy(chatId) || this.anyActive()) return;
+    if (this.grok.hasInflightPrompt()) {
+      await this.api.sendMessage(chatId, "\u23F3 Grok is busy running a turn — try /reauth when idle (or /cancel first).").catch(() => {});
+      return;
+    }
+    const s: ReauthSession = this.sessions.get(chatId) ?? { chatId, messageId, phase: "login", frame: 0 };
+    s.messageId = messageId;
+    s.phase = "login";
+    s.errorMsg = undefined;
+    s.url = undefined;
+    s.code = undefined;
+    this.sessions.set(chatId, s);
+    void this.run(s);
+  }
+
+  /** Adopt an existing on-host login, then restart the agent. */
+  async importExisting(chatId: number, messageId: number): Promise<void> {
+    if (this.isBusy(chatId) || this.anyActive()) return;
+    const s: ReauthSession = this.sessions.get(chatId) ?? { chatId, messageId, phase: "restarting", frame: 0 };
+    s.messageId = messageId;
+    const res = await this.auth.importExisting();
+    if (!res.ok) {
+      s.phase = "failed";
+      s.errorMsg = res.error;
+      this.sessions.set(chatId, s);
+      return void this.render(s);
+    }
+    s.phase = "restarting";
+    s.errorMsg = undefined;
+    this.sessions.set(chatId, s);
+    this.startAnim(s);
+    await this.render(s);
+    await this.finishRestart(s);
+  }
+
+  cancel(chatId: number): boolean {
+    const s = this.sessions.get(chatId);
+    if (!s || !ACTIVE.has(s.phase)) return false;
+    s.abort?.abort();
+    return true;
+  }
+
+  async cancelChoice(chatId: number, messageId: number): Promise<void> {
+    const s = this.sessions.get(chatId);
+    if (s && s.phase === "choosing") this.sessions.delete(chatId);
+    await this.api.editMessageText(chatId, messageId, "\u{1F510} Sign-in cancelled.").catch(() => {});
+  }
+
+  async retry(chatId: number, messageId: number): Promise<void> {
+    await this.chooseMethod(chatId, messageId);
+  }
+
+  // ── flow ───────────────────────────────────────────────────────────────────
+
+  private async run(s: ReauthSession): Promise<void> {
+    s.abort = new AbortController();
+    s.accountLabel = undefined;
+    let agentDown = false;
+    try {
+      this.startAnim(s);
+      await this.render(s);
+      await this.grok.stopAndWait(); // release the agent before sign-in
+      agentDown = true;
+      await this.auth.logout();
+      if (s.abort.signal.aborted) {
+        s.phase = "cancelled";
+        return;
+      }
+      let raw = "";
+      const result = await this.auth.login({
+        timeoutMs: LOGIN_TIMEOUT_MS,
+        signal: s.abort.signal,
+        onOutput: (t) => {
+          raw += t;
+          const p = parseLoginOutput(raw);
+          let changed = false;
+          if (p.url && p.url !== s.url) {
+            s.url = p.url;
+            changed = true;
+          }
+          if (p.code && p.code !== s.code) {
+            s.code = p.code;
+            changed = true;
+          }
+          if (changed) void this.render(s);
+        },
+      });
+      if (result.cancelled || s.abort.signal.aborted) {
+        s.phase = "cancelled";
+        return;
+      }
+      if (!result.ok) {
+        s.phase = "failed";
+        s.errorMsg = result.error ?? `Sign-in did not complete (exit ${result.code ?? "?"}).`;
+        return;
+      }
+      s.phase = "restarting";
+      await this.render(s);
+      await this.grok.start();
+      agentDown = false;
+      s.accountLabel = accountLabel(await this.getAccount?.().catch(() => undefined));
+      s.phase = "done";
+    } catch (e) {
+      log.warn("reauth flow failed:", (e as Error).message);
+      s.phase = "failed";
+      s.errorMsg = (e as Error).message;
+    } 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));
+      await this.render(s);
+    }
+  }
+
+  private async finishRestart(s: ReauthSession): Promise<void> {
+    try {
+      await this.grok.restart();
+      s.accountLabel = accountLabel(await this.getAccount?.().catch(() => undefined));
+      s.phase = "done";
+    } catch (e) {
+      s.phase = "failed";
+      s.errorMsg = (e as Error).message;
+    }
+    this.stopAnim(s);
+    await this.render(s);
+  }
+
+  private startAnim(s: ReauthSession): void {
+    if (s.anim) return;
+    s.anim = setInterval(() => {
+      s.frame++;
+      void this.render(s);
+    }, ANIM_MS);
+  }
+
+  private stopAnim(s: ReauthSession): void {
+    if (s.anim) {
+      clearInterval(s.anim);
+      s.anim = undefined;
+    }
+  }
+
+  // ── rendering ────────────────────────────────────────────────────────────────
+
+  private text(s: ReauthSession): string {
+    const loader = LOADER[s.frame % LOADER.length] ?? "";
+    switch (s.phase) {
+      case "choosing":
+        return (
+          "\u{1F510} Sign in to Grok\n\n" +
+          "Grok signs in with your xAI account (SuperGrok / X Premium+).\n\n" +
+          "\u2022 \u{1F511} Sign in \u2014 runs `grok login`; if a link/code appears, open it to approve.\n" +
+          "\u2022 \u{1F4E5} Import existing \u2014 use a `grok login` already done on this machine."
+        );
+      case "login": {
+        const lines = ["\u{1F511} Signing in to Grok\u2026", ""];
+        if (s.url) lines.push(`\u{1F517} Open this link to approve:\n${s.url}`, "");
+        if (s.code) lines.push(`\u{1F522} Verification code: ${s.code}`, "");
+        if (!s.url && !s.code) lines.push("Starting sign-in (a browser may open on the host)\u2026", "");
+        lines.push(`${loader} Waiting\u2026`);
+        return lines.join("\n");
+      }
+      case "restarting":
+        return `\u2705 Signed in.\n\u{1F504} Restarting the Grok agent\u2026  ${loader}`;
+      case "done":
+        return (
+          `\u2705 Signed in${s.accountLabel ? ` as ${s.accountLabel}` : ""} and agent restarted.\n` +
+          "Your next message runs on this account."
+        );
+      case "cancelled":
+        return "\u{1F6D1} Sign-in cancelled. Tap Retry to try again.";
+      case "failed":
+        return `\u274C ${s.errorMsg ?? "Sign-in failed."}\nTap Retry to try again.`;
+      default:
+        return "";
+    }
+  }
+
+  private keyboard(s: ReauthSession): InlineKeyboard | undefined {
+    switch (s.phase) {
+      case "choosing":
+        return new InlineKeyboard()
+          .text("\u{1F511} Sign in", "reauth:login")
+          .text("\u{1F4E5} Import existing", "reauth:import")
+          .row()
+          .text("\u274C Cancel", "reauth:choose-cancel");
+      case "login":
+      case "restarting":
+        return new InlineKeyboard().text("\u274C Cancel", "reauth:cancel");
+      case "cancelled":
+      case "failed":
+        return new InlineKeyboard().text("\u{1F501} Retry", "reauth:retry");
+      default:
+        return undefined;
+    }
+  }
+
+  private async render(s: ReauthSession): Promise<void> {
+    const text = this.text(s);
+    if (text === s.lastText) return;
+    s.lastText = text;
+    await this.api
+      .editMessageText(s.chatId, s.messageId, text, {
+        reply_markup: this.keyboard(s),
+        link_preview_options: { is_disabled: true },
+      })
+      .catch(() => {});
+  }
+}
+
+function accountLabel(a: AccountInfo | undefined): string | undefined {
+  return a?.email || a?.startUrl || a?.accountType;
+}

package/src/bot/registry.ts

@@ -0,0 +1,186 @@
+/**
+ * Tracks one ChatController per Telegram chat (each controlling one or more
+ * sessions). `get(chatId)` returns the chat's foreground SessionRuntime so the
+ * existing handlers keep operating on "the current session".
+ *
+ * It also owns **subagent attribution**: Grok reports a single, process-global
+ * subagent list (with no parent session id on the wire), so we attribute new
+ * subagents to the chat whose turn is currently running (most-recent first).
+ * That mapping drives both subagent *visibility* (routed to the owner's
+ * foreground runtime) and *permission* routing (a subagent's permission request
+ * is asked of its parent chat).
+ */
+import type { Api } from "grammy";
+import type { GrokClient } from "../grok/client.js";
+import type { PendingStage, SubagentInfo } from "../grok/types.js";
+import type { SettingsStore } from "../app/settings-store.js";
+import type { AppConfig } from "../config.js";
+import { subagentSummary } from "../render/subagent.js";
+import type { SessionStore } from "../sessions/store.js";
+import type { AccountRotator } from "./account-rotator.js";
+import { ChatController } from "./chat-controller.js";
+import type { SessionRuntime } from "./session-runtime.js";
+
+export interface SessionDescription {
+  /** Chat that owns the session (controlled session or subagent parent). */
+  chatId?: number;
+  /** True when this is a session the chat directly controls. */
+  controlled: boolean;
+  /** True when this is a subagent of a controlled turn. */
+  subagent: boolean;
+  projectName?: string;
+  subagentName?: string;
+}
+
+export class RuntimeRegistry {
+  private readonly controllers = new Map<number, ChatController>();
+  private refresher: ((chatId: number) => void) | undefined;
+  private rotator: AccountRotator | undefined;
+  /** Chat ids with a running turn, most-recently-started last. */
+  private readonly activeChats: number[] = [];
+  /** Subagent sessionId -> owner chat id. */
+  private readonly subagentParents = new Map<string, number>();
+
+  constructor(
+    private readonly api: Api,
+    private readonly acp: GrokClient,
+    private readonly cfg: AppConfig,
+    private readonly settings: SettingsStore,
+    private readonly store: SessionStore,
+  ) {
+    this.acp.on("subagents", (subagents, pending) => this.onSubagents(subagents, pending));
+  }
+
+  setRefresher(fn: (chatId: number) => void): void {
+    this.refresher = fn;
+  }
+
+  /** Provide the account rotator used for auto-rotate-on-give-up. */
+  setAccountRotator(rotator: AccountRotator): void {
+    this.rotator = rotator;
+  }
+
+  controller(chatId: number): ChatController {
+    let c = this.controllers.get(chatId);
+    if (!c) {
+      c = new ChatController(
+        this.api,
+        chatId,
+        this.acp,
+        this.cfg,
+        this.settings,
+        this.store,
+        (id) => this.refresher?.(id),
+        (busy) => this.noteActivity(chatId, busy),
+        () => this.rotator,
+      );
+      this.controllers.set(chatId, c);
+    }
+    return c;
+  }
+
+  /** The chat's foreground runtime (backward-compatible with existing handlers). */
+  get(chatId: number): SessionRuntime {
+    return this.controller(chatId).foreground();
+  }
+
+  disposeAll(): void {
+    for (const c of this.controllers.values()) c.dispose();
+    this.controllers.clear();
+  }
+
+  /** Find the chat that currently controls a given session id. */
+  findChatBySession(sessionId: string): number | undefined {
+    for (const [chatId, c] of this.controllers) {
+      if (c.findBySession(sessionId)) return chatId;
+    }
+    return undefined;
+  }
+
+  isControlledSession(sessionId: string): boolean {
+    return this.findChatBySession(sessionId) !== undefined;
+  }
+
+  /**
+   * The chat a session belongs to for permission/routing purposes: a directly
+   * controlled session, otherwise the parent chat of a subagent.
+   */
+  ownerChatForSession(sessionId: string): number | undefined {
+    return this.findChatBySession(sessionId) ?? this.subagentParents.get(sessionId);
+  }
+
+  /** Describe a session so a permission prompt can label it correctly. */
+  describeSession(sessionId: string): SessionDescription {
+    const controlledChat = this.findChatBySession(sessionId);
+    if (controlledChat !== undefined) {
+      const project = this.controller(controlledChat)
+        .list()
+        .find((s) => s.sessionId === sessionId)?.projectName;
+      return { chatId: controlledChat, controlled: true, subagent: false, projectName: project };
+    }
+    const parent = this.subagentParents.get(sessionId);
+    const info = this.acp.subagentById(sessionId);
+    if (parent !== undefined || info) {
+      return {
+        chatId: parent,
+        controlled: false,
+        subagent: true,
+        subagentName: info?.sessionName || info?.agentName || sessionId.slice(0, 8),
+      };
+    }
+    return { controlled: false, subagent: false };
+  }
+
+  /** Subagent summary line for a chat's status panel, or undefined. */
+  subagentSummaryForChat(chatId: number): string | undefined {
+    const mine = this.acp.currentSubagents().filter((s) => this.subagentParents.get(s.sessionId) === chatId);
+    if (mine.length === 0) return undefined;
+    return subagentSummary(mine, this.acp.currentPendingStages());
+  }
+
+  // ── subagent attribution ─────────────────────────────────────────────────
+
+  private noteActivity(chatId: number, busy: boolean): void {
+    const i = this.activeChats.indexOf(chatId);
+    if (i !== -1) this.activeChats.splice(i, 1);
+    if (busy) this.activeChats.push(chatId);
+  }
+
+  /** The chat most likely to own freshly-spawned subagents. */
+  private currentOwner(): number | undefined {
+    return this.activeChats.at(-1);
+  }
+
+  private onSubagents(subagents: SubagentInfo[], pending: PendingStage[]): void {
+    const owner = this.currentOwner();
+    // Record parents for any subagent we haven't attributed yet.
+    if (owner !== undefined) {
+      for (const s of subagents) {
+        if (!this.subagentParents.has(s.sessionId)) this.subagentParents.set(s.sessionId, owner);
+      }
+    }
+    // Group by attributed chat and route visibility to each owner's foreground.
+    const byChat = new Map<number, SubagentInfo[]>();
+    for (const s of subagents) {
+      const chatId = this.subagentParents.get(s.sessionId);
+      if (chatId === undefined) continue;
+      const arr = byChat.get(chatId);
+      if (arr) arr.push(s);
+      else byChat.set(chatId, [s]);
+    }
+    for (const [chatId, list] of byChat) {
+      try {
+        this.controller(chatId).foreground().renderSubagents(list, pending);
+      } catch {
+        /* non-fatal */
+      }
+      this.refresher?.(chatId);
+    }
+    // Prune mappings for subagents no longer present (they're terminated and
+    // won't issue further permission requests) so the map stays bounded.
+    const live = new Set(subagents.map((s) => s.sessionId));
+    for (const sid of this.subagentParents.keys()) {
+      if (!live.has(sid)) this.subagentParents.delete(sid);
+    }
+  }
+}

package/src/bot/reply-context.ts

@@ -0,0 +1,77 @@
+/**
+ * Reply context extraction.
+ *
+ * When a user's Telegram message is a *reply* to another message, the agent
+ * should also receive what the user is responding to — otherwise a terse reply
+ * like "fix this" or "why?" loses all meaning. This module pulls that reference
+ * content out of an incoming message:
+ *   1. an explicitly highlighted quote (Bot API 6.9+ `message.quote`), which is
+ *      the most precise signal of what the user is pointing at, then
+ *   2. the full replied-to message's text / caption / media descriptor, then
+ *   3. a reply to a message from another chat (`external_reply`).
+ *
+ * The result is capped so a reply to a huge agent answer can't blow the prompt.
+ */
+import type { Context } from "grammy";
+
+/** Max characters of quoted context forwarded to the agent. */
+const MAX_QUOTE_CHARS = 4000;
+
+/** Structural subset of a Telegram message we can summarize. */
+interface QuotableMessage {
+  text?: string;
+  caption?: string;
+  document?: { file_name?: string };
+  photo?: unknown;
+  voice?: unknown;
+  audio?: { file_name?: string };
+  video?: unknown;
+  video_note?: unknown;
+  sticker?: { emoji?: string };
+  location?: unknown;
+  contact?: unknown;
+}
+
+/**
+ * Build the reference-content string for a reply, or `undefined` when the
+ * message isn't a reply / carries nothing quotable.
+ */
+export function extractReplyContext(ctx: Context): string | undefined {
+  const msg = ctx.message;
+  if (!msg) return undefined;
+
+  const quote = msg.quote?.text?.trim() || undefined;
+  const reply = msg.reply_to_message ? describeMessage(msg.reply_to_message) : undefined;
+  const external = msg.external_reply ? describeMessage(msg.external_reply as QuotableMessage) : undefined;
+
+  let context: string | undefined;
+  if (quote && reply && reply !== quote) {
+    // The user highlighted a specific part of a larger message — surface the
+    // excerpt first (so it survives clipping) plus the fuller message context.
+    context = `Quoted excerpt: "${quote}"\nFrom the message: ${reply}`;
+  } else {
+    context = quote ?? reply ?? external;
+  }
+
+  if (!context) return undefined;
+  return clip(context, MAX_QUOTE_CHARS);
+}
+
+/** Human-readable content of a message: its text/caption or a media label. */
+function describeMessage(m: QuotableMessage): string | undefined {
+  const body = (m.text ?? m.caption)?.trim();
+  if (body) return body;
+  if (m.document) return `[file: ${m.document.file_name ?? "document"}]`;
+  if (m.photo) return "[photo]";
+  if (m.voice) return "[voice message]";
+  if (m.audio) return `[audio: ${m.audio.file_name ?? "audio"}]`;
+  if (m.video || m.video_note) return "[video]";
+  if (m.sticker) return `[sticker${m.sticker.emoji ? ` ${m.sticker.emoji}` : ""}]`;
+  if (m.location) return "[location]";
+  if (m.contact) return "[contact]";
+  return undefined;
+}
+
+function clip(s: string, max: number): string {
+  return s.length <= max ? s : `${s.slice(0, max)}\n…(truncated)`;
+}

package/src/bot/session-fork.ts

@@ -0,0 +1,35 @@
+/**
+ * Session forking helpers — "logical fork" of a Grok session.
+ *
+ * A fork is a fresh session in the same project, *primed* with the recent
+ * transcript of the session it continues, so the conversation survives when the
+ * original can't be used: its exclusive lock is held by another window, or it
+ * got throttled / exhausted / stuck mid-turn. Used by:
+ *   • lost-session recovery (a persisted session we can't reload), and
+ *   • auto-fork-on-error (a transient prompt failure with no streamed output).
+ */
+import { join } from "node:path";
+import { buildTranscript, readHistory } from "../sessions/history.js";
+
+/** Read a compact transcript of a session's recent history from disk, or "". */
+export function recentTranscript(sessionsDir: string, sessionId: string, entries = 24): string {
+  try {
+    const hist = readHistory(join(sessionsDir, `${sessionId}.jsonl`), entries);
+    return hist.length > 0 ? buildTranscript(hist) : "";
+  } catch {
+    return "";
+  }
+}
+
+/** Priming preamble injected as context into a forked (linked) continuation. */
+export function buildPriming(transcript: string): string {
+  return [
+    "You are resuming a conversation that is currently still running in another",
+    "window on this machine, so this is a linked continuation. Below is the recent",
+    "transcript for context — use it to continue seamlessly.",
+    "",
+    "=== RECENT TRANSCRIPT ===",
+    transcript,
+    "=== END TRANSCRIPT ===",
+  ].join("\n");
+}