grok-telegram-bot 2.0.0 → 2.2.0

package/src/bot/permission-service.ts

@@ -1,9 +1,10 @@
 /**
- * PermissionService — turns Grok's ACP `session/request_permission` into inline
- * Approve/Deny buttons. It names the session that needs approval, sends the
- * prompt WITH sound (it requires interaction), and — when the request belongs to
- * a *background* session — adds a "🔀 Switch to it" button. The Allow/Deny
- * buttons resolve the request in place, without switching.
+ * PermissionService — turns Grok's ACP `session/request_permission` into either
+ * an automatic session-level approval (default) or inline Approve/Deny buttons.
+ *
+ * Auto-approve prefers "allow for this session" / "always allow" options so the
+ * agent stops re-prompting mid-turn. Interactive mode is only used when
+ * auto-approve is off (GROK_TRUST_ALL_TOOLS=false and AUTO_APPROVE_PERMISSIONS=false).
  */
 import type { Api } from "grammy";
 import { InlineKeyboard } from "grammy";
@@ -35,17 +36,31 @@ interface Pending {
 export class PermissionService {
   private readonly pending = new Map<string, Pending>();
   private seq = 0;
+  /** When true, every permission request is auto-approved (session-scope preferred). */
+  autoApprove: boolean;
 
   constructor(
     private readonly api: Api,
     private readonly registry: RuntimeRegistry,
-  ) {}
+    autoApprove = true,
+  ) {
+    this.autoApprove = autoApprove;
+  }
 
-  /** Handle a permission request: ask the owning chat, or auto-allow if none. */
+  /** Handle a permission request: auto-approve (default), ask the chat, or allow if unattended. */
   async handle(params: RequestPermissionParams): Promise<PermissionOutcome> {
+    if (this.autoApprove) {
+      const decision = autoDecideSession(params);
+      log.info(
+        `auto-approved permission for session ${params.sessionId.slice(0, 8)} ` +
+          `(${params.toolCall?.kind ?? "tool"}: ${params.toolCall?.title ?? "?"})`,
+      );
+      return decision;
+    }
+
     const desc = this.registry.describeSession(params.sessionId);
     const chatId = desc.chatId;
-    if (chatId === undefined) return autoDecide(params); // unattended (e.g. scheduled task / orphan subagent)
+    if (chatId === undefined) return autoDecideSession(params); // unattended (scheduled / orphan)
 
     const reqId = String(++this.seq);
     const isForeground = !desc.subagent && this.registry.get(chatId).sessionId === params.sessionId;
@@ -75,7 +90,7 @@ export class PermissionService {
       messageId = msg.message_id;
     } catch (e) {
       log.warn("failed to send permission prompt:", (e as Error).message);
-      return autoDecide(params);
+      return autoDecideSession(params);
     }
 
     return new Promise<PermissionOutcome>((resolve) => {
@@ -136,14 +151,43 @@ function describe(
 
 function buttonLabel(o: { name: string; kind?: string }): string {
   const k = `${o.kind ?? ""} ${o.name}`.toLowerCase();
-  const icon = /reject|deny|no|cancel/.test(k) ? "\u26D4" : /always|all/.test(k) ? "\u2705\u267E\uFE0F" : "\u2705";
+  const icon = /reject|deny|no|cancel/.test(k) ? "\u26D4" : /always|all|session/.test(k) ? "\u2705\u267E\uFE0F" : "\u2705";
   return `${icon} ${o.name}`;
 }
 
-/** Pick an allow option when nobody can be asked (otherwise cancel). */
-function autoDecide(params: RequestPermissionParams): PermissionOutcome {
-  const allow = params.options.find((o) => /allow|approve|yes|once/i.test(`${o.kind ?? ""} ${o.name}`));
-  return allow
-    ? { outcome: { outcome: "selected", optionId: allow.optionId } }
+/**
+ * Score an allow-option. Higher is better for bot auto-approve:
+ *   4 — always allow all sessions / forever
+ *   3 — allow for this session (preferred default)
+ *   2 — allow always (unscoped)
+ *   1 — allow once / approve / yes
+ *   0 — not an allow option (reject/deny)
+ */
+function allowScore(o: { name: string; kind?: string }): number {
+  const k = `${o.kind ?? ""} ${o.name}`.toLowerCase();
+  if (/reject|deny|cancel|no\b|block/.test(k)) return 0;
+  if (/all.?sessions|always_allow_all|forever|unrestricted/.test(k)) return 4;
+  if (/this.?session|session|allow_session|always_allow_session/.test(k)) return 3;
+  if (/always|allow_always|allow.?all\b/.test(k)) return 2;
+  if (/allow|approve|yes|once|ok\b/.test(k)) return 1;
+  return 0;
+}
+
+/**
+ * Pick the best allow option, preferring "this session" / "always" so the agent
+ * stops re-prompting. Falls back to cancelled only when no allow option exists.
+ */
+export function autoDecideSession(params: RequestPermissionParams): PermissionOutcome {
+  let best: { optionId: string; score: number } | undefined;
+  for (const o of params.options) {
+    const score = allowScore(o);
+    if (score <= 0) continue;
+    if (!best || score > best.score) best = { optionId: o.optionId, score };
+  }
+  if (best) return { outcome: { outcome: "selected", optionId: best.optionId } };
+  // Last resort: first option if present (agent convention: allow first).
+  const first = params.options[0];
+  return first
+    ? { outcome: { outcome: "selected", optionId: first.optionId } }
     : { outcome: { outcome: "cancelled" } };
 }

package/src/bot/reauth-controller.ts

@@ -233,14 +233,14 @@ export class ReauthController {
         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{1F511} Sign in \u2014 runs `grok login --device-auth` (no browser); open the link/code here 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", ""];
+        const lines = ["\u{1F511} Signing in to Grok (device code, no browser)\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", "");
+        if (!s.url && !s.code) lines.push("Starting headless device-code sign-in\u2026", "");
         lines.push(`${loader} Waiting\u2026`);
         return lines.join("\n");
       }

package/src/bot/session-runtime.ts

@@ -1,5 +1,5 @@
 /**
- * SessionRuntime — binds one Telegram chat to one Grok ACP session and drives
+ * SessionRuntime — binds one Telegram chat to one Grok ACP session and drives
  * the prompt/stream lifecycle, typing indicator, follow-up queue, live watch,
  * and per-chat preferences (project, agent, model, reasoning). State persists
  * to the settings store so it survives restarts.
@@ -54,7 +54,7 @@ const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms
 const RESUME_INSTRUCTION =
   "Your previous response was interrupted by a transient service error (the model stream was throttled), " +
   "so your last turn did not finish. Continue from exactly where you stopped and complete the response. " +
-  "Do NOT repeat any file edits, commands, or other tool calls you already completed — their results are " +
+  "Do NOT repeat any file edits, commands, or other tool calls you already completed — their results are " +
   "already in this conversation. If you had already fully answered, just briefly conclude.";
 
 export class SessionRuntime {
@@ -82,7 +82,7 @@ export class SessionRuntime {
   /** Subagent sessionId -> last status key shown this turn (dedupe). */
   private subagentShown = new Map<string, string>();
   private turnStartedAt = 0;
-  /** Count of completed (non-cancelled) turns this session — shown in /usage. */
+  /** Count of completed (non-cancelled) turns this session — shown in /usage. */
   private turnCount = 0;
   /** Telegram message id of the current turn's prompt, so replies thread to it. */
   private turnReplyTo: number | undefined;
@@ -93,7 +93,7 @@ export class SessionRuntime {
   private watcher: TailWatcher | undefined;
   /** True when the active watch is a transient "follow" of this session's own
    *  in-flight turn (started on switch) rather than an explicit /watch of
-   *  another session — follow-watches are auto-stopped when a new turn streams. */
+   *  another session — follow-watches are auto-stopped when a new turn streams. */
   private watchIsFollow = false;
   private rebindPending = false;
   private sessionLive = false;
@@ -159,7 +159,7 @@ export class SessionRuntime {
     return this.lastCompletion;
   }
 
-  /** Latest task-completion % (0–100) parsed this turn, or undefined if none. */
+  /** Latest task-completion % (0–100) parsed this turn, or undefined if none. */
   get taskProgress(): number | undefined {
     return this.progress;
   }
@@ -174,8 +174,8 @@ export class SessionRuntime {
     this.changed();
   }
 
-  /** Searchable hashtag footer for this session (project · session · model ·
-   *  reasoning) — appended to every AI-output surface for this session. */
+  /** Searchable hashtag footer for this session (project В· session В· model В·
+   *  reasoning) — appended to every AI-output surface for this session. */
   get tags(): string {
     return this.hashtags();
   }
@@ -189,7 +189,7 @@ export class SessionRuntime {
     if (value) {
       // A turn was started here and is still in flight, but its streamer was
       // finalized when we went background. Recreate it and let onUpdate feed
-      // the remaining chunks/thoughts/tools just like a normal live turn — we
+      // the remaining chunks/thoughts/tools just like a normal live turn — we
       // own the agent's session/update events, so no tail-watch is needed.
       if (this.busy && !this.streamer) {
         // Any transient follow-watch of this session is now superseded.
@@ -234,7 +234,7 @@ export class SessionRuntime {
     this.stopWatch();
   }
 
-  // ── sessions ───────────────────────────────────────────────────────────────
+  // в”Ђв”Ђ sessions в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async startNewSession(cwd: string, projectName?: string): Promise<void> {
     if (this.busy) await this.cancel();
@@ -314,7 +314,7 @@ export class SessionRuntime {
     return true;
   }
 
-  // ── preferences ──────────────────────────────────────────────────────────
+  // в”Ђв”Ђ preferences в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async setModelPref(modelId: string): Promise<{ ok: boolean; error?: string }> {
     // Persist the choice always; only talk to Grok when a session is live in
@@ -378,7 +378,7 @@ export class SessionRuntime {
     }
   }
 
-  // ── prompting ──────────────────────────────────────────────────────────────
+  // в”Ђв”Ђ prompting в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async submit(input: PromptInput): Promise<"ran" | "queued"> {
     await this.ensureSession();
@@ -425,7 +425,7 @@ export class SessionRuntime {
       // The session genuinely can't be reloaded (its exclusive lock is held,
       // or its log/metadata is gone). Never silently drop the conversation:
       // fork a linked continuation primed with the recent transcript so the
-      // thread survives — including any question the agent had just asked.
+      // thread survives — including any question the agent had just asked.
       // forkFromLostSession() only throws if the agent is fully down, in which
       // case we leave rebindPending set so the next message retries cleanly.
       await this.forkFromLostSession(this.sessionId);
@@ -438,7 +438,7 @@ export class SessionRuntime {
   /** Reload a persisted session, retrying flaky failures with a short backoff.
    *  Returns true once loaded, false after the attempts are exhausted. */
   private async rebindWithRetries(sessionId: string, attempts = 4): Promise<boolean> {
-    const delays = [400, 1200, 3000]; // ≈4.6s total before giving up
+    const delays = [400, 1200, 3000]; // ≈4.6s total before giving up
     for (let i = 0; i < attempts; i++) {
       try {
         await this.acp.loadSession(sessionId, this.cwd);
@@ -518,7 +518,7 @@ export class SessionRuntime {
       if (resumed) final = resumed;
       const streamedOutput = this.streamer?.hasOutput ?? false;
       // On a successful, non-cancelled turn, top the fallback bar up to 100 (a
-      // no-op when the agent reported its own progress — its value is kept).
+      // no-op when the agent reported its own progress — its value is kept).
       if (final.result && !this.cancelled) this.streamer?.completeFallback();
       if (this.streamer) await this.streamer.finalize();
       if (this.foreground) await this.sendTurnImages();
@@ -527,7 +527,7 @@ export class SessionRuntime {
       // the foreground turn, or a background turn when NOTIFY_OTHER_SESSIONS is on.
       const canPing = this.foreground || this.cfg.notifyOtherSessions;
       // A background session about to run a queued follow-up shouldn't ping its
-      // interim "Done" — only the final, queue-empty turn announces completion.
+      // interim "Done" — only the final, queue-empty turn announces completion.
       const hasQueued = this.queue.length > 0;
       const switchKb = this.switchKeyboard();
       if (final.result && !this.cancelled) this.turnCount++;
@@ -594,11 +594,11 @@ export class SessionRuntime {
   }
 
   /**
-   * True when a prompt failure is attributable to an exhausted context window —
+   * True when a prompt failure is attributable to an exhausted context window —
    * either the error message says so, or this session's last-known context
    * usage is at/above the configured fork threshold. Such failures won't clear
    * by retrying the same oversized prompt (throttling on a near-full session
-   * surfaces as a plain "-32603 … throttled"), so the session must be compacted
+   * surfaces as a plain "-32603 … throttled"), so the session must be compacted
    * by forking a fresh, smaller continuation.
    */
   private isContextRelatedFailure(error: Error): boolean {
@@ -663,7 +663,7 @@ export class SessionRuntime {
   /**
    * Auto-rotate-on-give-up. When a turn has failed (retries exhausted, auto-fork
    * didn't recover it) and nothing was streamed, cycle through the OTHER saved
-   * accounts once — switching login + restarting the agent, then retrying the
+   * accounts once — switching login + restarting the agent, then retrying the
    * same prompt on a fresh session for each. The first account that succeeds
    * wins and stays active; if every account fails we return a single combined
    * error listing what each one reported. Bounded to ONE pass (no infinite
@@ -719,14 +719,14 @@ export class SessionRuntime {
       errors.push(`\u2022 ${t.label}: ${last.error?.message ?? "failed"}`);
     }
 
-    // One full cycle done and still failing — stop with a combined report.
+    // One full cycle done and still failing — stop with a combined report.
     const combined = new Error(`Tried ${targets.length + 1} account(s), all failed:\n${errors.join("\n")}`);
     return { error: combined, attempts: last.attempts };
   }
 
   /**
    * Run the prompt, retrying *transient* agent errors (e.g. "high volume of
-   * traffic" / -32603) with an exponential backoff (6s → 12s → 24s → 48s → 60s,
+   * traffic" / -32603) with an exponential backoff (6s в†’ 12s в†’ 24s в†’ 48s в†’ 60s,
    * then give up). The real error is shown to the user on every failed attempt.
    *
    * We only retry while the turn has produced **no streamed output** (so tools
@@ -748,7 +748,7 @@ export class SessionRuntime {
         const error = err as Error;
         const canRecover = !this.cancelled && !(this.streamer?.hasOutput ?? false);
         // A context-exhausted session won't recover by retrying the same
-        // oversized prompt — skip the backoff and let auto-fork compact it now.
+        // oversized prompt — skip the backoff and let auto-fork compact it now.
         const forkInstead = canRecover && this.cfg.autoForkOnError && this.isContextRelatedFailure(error);
         const willRetry =
           attempt <= delays.length &&
@@ -784,8 +784,8 @@ export class SessionRuntime {
    * The pre-stream paths (retry / auto-fork / account-rotate) all bail once any
    * output exists, because re-sending the original prompt would re-execute the
    * tools that already ran (duplicate/destructive side effects). Instead we ask
-   * the SAME session to CONTINUE from where it stopped — its partial reply and
-   * any completed tool results are already in history, so nothing is repeated —
+   * the SAME session to CONTINUE from where it stopped — its partial reply and
+   * any completed tool results are already in history, so nothing is repeated —
    * using the same exponential backoff so a throttle has time to clear. The
    * open streamer keeps appending, so the reply is completed in place.
    *
@@ -800,7 +800,7 @@ export class SessionRuntime {
     if (!(this.streamer?.hasOutput ?? false)) return undefined;
     if (!isTransientError(final.error)) return undefined;
     // A context-full session won't recover by continuing (it'll just throttle
-    // again each attempt) — don't burn the backoff; surface the error so the
+    // again each attempt) — don't burn the backoff; surface the error so the
     // user can fork/compact. Resume targets transient throttles on a session
     // that still has headroom.
     if (this.isContextRelatedFailure(final.error)) return undefined;
@@ -878,7 +878,7 @@ export class SessionRuntime {
     const meta = this.contextInfo();
     const ctx = meta?.contextUsagePercentage;
     const ctxStr = ctx !== undefined ? ` \u00B7 ctx ${ctx.toFixed(0)}%` : "";
-    // Credits consumed this turn — only shown when Grok actually reports it
+    // Credits consumed this turn — only shown when Grok actually reports it
     // (not part of ACP today; degrades to nothing rather than guessing).
     const credits = meta?.credits;
     const creditStr = credits !== undefined ? ` \u00B7 \u{1FA99} ${fmtCredits(credits)}` : "";
@@ -898,7 +898,7 @@ export class SessionRuntime {
     return `\u{1F4E8} From other session ${this.sessionTag()}\n${summary}${shortFiles}\n\n${tags}`;
   }
 
-  /** "[project · 1a2b3c4d]" — identifies which background session a ping is from. */
+  /** "[project · 1a2b3c4d]" — identifies which background session a ping is from. */
   private sessionTag(): string {
     const name = this.projectName || basename(this.cwd) || "session";
     const id = this.sessionId ? ` \u00B7 ${this.sessionId.slice(0, 8)}` : "";
@@ -962,9 +962,29 @@ export class SessionRuntime {
     }
     if (kind === "tool_call" || kind === "tool_call_update") {
       if (!this.cfg.showToolCalls) return;
-      const id = update.toolCallId || `${kind}:${update.title ?? ""}`;
-      if (this.shownToolIds.has(id)) return;
-      this.shownToolIds.add(id);
+      const id = update.toolCallId || "";
+      const status = (update.status || "").toLowerCase();
+
+      if (kind === "tool_call_update") {
+        // Skip "in_progress"/"pending" duplicates of an already-shown initial call.
+        if (status === "pending" || status === "in_progress") {
+          const hasNewContent =
+            Array.isArray(update.content_blocks) && update.content_blocks.length > 0;
+          if (!hasNewContent) return;
+        }
+        // For completed/failed: show once (so the user sees the final status).
+        const doneKey = (id || update.title || "") + ":done";
+        if (status === "completed" || status === "failed") {
+          if (this.shownToolIds.has(doneKey)) return;
+          this.shownToolIds.add(doneKey);
+        }
+      } else {
+        // Initial tool_call: dedupe by id to avoid double-showing.
+        const shownKey = id || `tool_call:${update.title ?? ""}`;
+        if (this.shownToolIds.has(shownKey)) return;
+        this.shownToolIds.add(shownKey);
+      }
+
       const md = formatToolCall(update, {
         showDiffs: this.cfg.showEditDiffs,
         diffMaxLines: this.cfg.diffMaxLines,
@@ -1019,7 +1039,7 @@ export class SessionRuntime {
       .map((e) => {
         const icon = WATCH_ICON[e.role] ?? "\u2022";
         if (e.role === "tool") return `${icon} ${e.tool ? `\`${e.tool}\`` : "tool"}`;
-        const text = e.text.length > WATCH_ENTRY_MAX ? e.text.slice(0, WATCH_ENTRY_MAX) + " …" : e.text;
+        const text = e.text.length > WATCH_ENTRY_MAX ? e.text.slice(0, WATCH_ENTRY_MAX) + " …" : e.text;
         return `${icon} ${text}`;
       })
       .filter(Boolean)

package/src/config.ts

@@ -99,6 +99,13 @@ export interface AppConfig {
    *  --agent flag headlessly). */
   agent?: string;
   trustAllTools: boolean;
+  /**
+   * Auto-approve ACP `session/request_permission` prompts (prefer "allow for
+   * this session"). Defaults true — Telegram bots shouldn't block on tool
+   * approvals. Set false (and GROK_TRUST_ALL_TOOLS=false) for interactive
+   * Approve/Deny buttons.
+   */
+  autoApprovePermissions: boolean;
   projectRoots: string[];
   streamThrottleMs: number;
   messageBatchMs: number;
@@ -183,6 +190,8 @@ export function loadConfig(): AppConfig {
     maxToolRounds: num(process.env.GROK_MAX_TOOL_ROUNDS, 400),
     agent: process.env.GROK_AGENT?.trim() || undefined,
     trustAllTools: bool(process.env.GROK_TRUST_ALL_TOOLS, true),
+    // Default true: auto-approve with session-scope when the agent still asks.
+    autoApprovePermissions: bool(process.env.AUTO_APPROVE_PERMISSIONS, true),
     projectRoots: [...new Set(roots)],
     streamThrottleMs: num(process.env.STREAM_THROTTLE_MS, 1500),
     messageBatchMs: nonNegNum(process.env.MESSAGE_BATCH_MS, 800),

package/src/grok/client.ts

@@ -13,6 +13,7 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { createLogger } from "../logger.js";
+import { hasLogin } from "../app/grok-credentials.js";
 import { contextWindowFor, DEFAULT_MODEL, KNOWN_MODELS } from "./models.js";
 import { PROGRESS_DIRECTIVE } from "../render/progress.js";
 import { SessionLog } from "./session-log.js";
@@ -76,6 +77,47 @@ function shortJson(v: unknown): string {
   }
 }
 
+/** Auth methods that open a browser / interactive UI — never use from the bot. */
+const BROWSER_AUTH_RE = /grok\.com|browser|oauth|interactive|web.?login/i;
+
+/**
+ * Pick a headless-safe auth method. Prefer `cached_token` (auth.json) so
+ * multi-account rotation works by swapping that file; then `xai.api_key` when
+ * an API key is configured. Never falls back to browser methods.
+ */
+export function pickHeadlessAuthMethod(
+  methods: Array<{ id: string; name?: string }>,
+  hasApiKey: boolean,
+): string | undefined {
+  const ids = methods.map((m) => m.id);
+  const safe = (id: string) => !BROWSER_AUTH_RE.test(id) && !/login|sign.?in/i.test(id);
+  if (ids.includes("cached_token") && safe("cached_token")) return "cached_token";
+  if (hasApiKey && ids.includes("xai.api_key") && safe("xai.api_key")) return "xai.api_key";
+  // Any other non-browser, non-key method the agent advertises.
+  return ids.find((id) => safe(id) && id !== "xai.api_key");
+}
+
+/** Auto-pick an allow option for permission requests (prefer session/always). */
+function pickAllowOption(
+  opts: Array<{ optionId: string; name?: string; kind?: string }>,
+): PermissionOutcome {
+  let best: { optionId: string; score: number } | undefined;
+  for (const o of opts) {
+    const k = `${o.kind ?? ""} ${o.name ?? ""}`.toLowerCase();
+    let score = 0;
+    if (/reject|deny|cancel|no\b|block/.test(k)) score = 0;
+    else if (/all.?sessions|always_allow_all|forever/.test(k)) score = 4;
+    else if (/this.?session|session|allow_session/.test(k)) score = 3;
+    else if (/always|allow_always|allow.?all\b/.test(k)) score = 2;
+    else if (/allow|approve|yes|once|ok\b/.test(k)) score = 1;
+    if (score > 0 && (!best || score > best.score)) best = { optionId: o.optionId, score };
+  }
+  if (best) return { outcome: { outcome: "selected", optionId: best.optionId } };
+  return opts[0]
+    ? { outcome: { outcome: "selected", optionId: opts[0].optionId } }
+    : { outcome: { outcome: "cancelled" } };
+}
+
 export interface GrokClientOptions {
   grokCliPath: string;
   workspace: string;
@@ -161,8 +203,13 @@ export class GrokClient extends EventEmitter {
   }
 
   private async connect(): Promise<void> {
-    const args = ["agent", "stdio", "--no-auto-update"];
+    // `--always-approve` is a `grok agent` option (not `grok agent stdio`),
+    // so it must come before the `stdio` subcommand. `--no-leader` keeps auth
+    // process-local so swapping ~/.grok/auth.json + restart actually picks up
+    // the new token. `--no-auto-update` was removed in grok 0.2.x (exit 2).
+    const args = ["agent", "--no-leader"];
     if (this.opts.trustAllTools) args.push("--always-approve");
+    args.push("stdio");
 
     log.info(`spawning: ${this.opts.grokCliPath} ${args.join(" ")}`);
     const env = { ...process.env };
@@ -193,7 +240,7 @@ export class GrokClient extends EventEmitter {
     const init = (await this.request("initialize", {
       protocolVersion: 1,
       clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
-      clientInfo: { name: "grok-telegram-bot", version: "2.0.0" },
+      clientInfo: { name: "grok-telegram-bot", version: "2.2.0" },
     })) as InitializeResult;
 
     this.agentInfo = init.agentInfo ?? { name: "grok" };
@@ -202,19 +249,29 @@ export class GrokClient extends EventEmitter {
     this.subagents = [];
     this.pendingStages = [];
 
-    // Authenticate: prefer the cached `grok login` token; fall back to API key.
-    const methods = new Set((init.authMethods ?? []).map((m) => m.id));
-    this.authMethodId =
-      this.opts.apiKey && methods.has("xai.api_key")
-        ? "xai.api_key"
-        : methods.has("cached_token")
-          ? "cached_token"
-          : (init.authMethods?.[0]?.id ?? undefined);
-    if (this.authMethodId) {
+    // Authenticate headlessly only. NEVER pick browser methods (e.g. "grok.com")
+    // — those open a browser and hang/kill the bot host. Prefer cached_token
+    // from ~/.grok/auth.json, then xai.api_key when configured.
+    this.authMethodId = pickHeadlessAuthMethod(init.authMethods ?? [], !!this.opts.apiKey);
+    if (!this.authMethodId) {
+      // Never fall back to browser methods (e.g. grok.com) — that opens a
+      // browser and freezes headless hosts. Boot unauthenticated so /reauth works.
+      log.warn(
+        "No headless Grok auth method available. Run `grok login` / /reauth, or set XAI_API_KEY. " +
+          "Refusing browser-based auth methods.",
+      );
+    } else {
       try {
         await this.request("authenticate", { methodId: this.authMethodId, _meta: { headless: true } });
       } catch (e) {
-        log.warn(`authenticate (${this.authMethodId}) failed: ${(e as Error).message}`);
+        const msg = (e as Error).message;
+        log.warn(`authenticate (${this.authMethodId}) failed: ${msg}`);
+        // If a login (or API key) is present, auth should have worked — surface
+        // the error so account switch/rotation doesn't silently keep a dead agent.
+        // If nothing is configured yet, soft-fail so the bot can still boot for /reauth.
+        if (hasLogin() || this.opts.apiKey) {
+          throw new Error(`Grok authenticate (${this.authMethodId}) failed: ${msg}`);
+        }
       }
     }
     log.info(`connected: ${this.agentInfo?.name ?? "grok"} ${this.agentInfo?.version ?? ""}`.trim());
@@ -515,11 +572,9 @@ export class GrokClient extends EventEmitter {
       if (method === "session/request_permission" && this.permissionHandler) {
         result = await this.permissionHandler(params as unknown as RequestPermissionParams);
       } else if (method === "session/request_permission") {
-        // No handler (trust-all): auto-approve the first option, else cancel.
-        const opts = (params.options as Array<{ optionId: string }>) ?? [];
-        result = opts[0]
-          ? { outcome: { outcome: "selected", optionId: opts[0].optionId } }
-          : { outcome: { outcome: "cancelled" } };
+        // No handler: auto-approve, preferring session-scope / always options.
+        const opts = (params.options as Array<{ optionId: string; name?: string; kind?: string }>) ?? [];
+        result = pickAllowOption(opts);
       } else {
         // We advertise no fs/terminal capabilities, so the agent shouldn't ask.
         throw new GrokError(`unsupported client method: ${method}`, -32601);