grok-telegram-bot 2.1.0 → 2.2.0

package/.env.example

@@ -32,6 +32,11 @@ GROK_WORKSPACE=
 # Grok runs risky tools (file writes, shell commands) — ACP "ask" mode.
 GROK_TRUST_ALL_TOOLS=true
 
+# Auto-approve ACP permission requests, preferring "allow for this session".
+# Defaults true. Set false (and GROK_TRUST_ALL_TOOLS=false) for interactive
+# Approve/Deny buttons in Telegram.
+AUTO_APPROVE_PERMISSIONS=true
+
 # Comma-separated roots the /projects browser is allowed to list.
 # Supports ~ for home directory. Defaults to GROK_WORKSPACE's parent + home.
 # Example: H:\Lucru\Domains,C:\Lucru\Domains

package/CHANGELOG.md

@@ -9,6 +9,43 @@ The latest section is published verbatim as the GitHub Release notes by
 
 ## [Unreleased]
 
+## [2.2.0] - 2026-07-12
+
+The **reliable multi-account** release — account switch / auto-rotate now only
+swaps `~/.grok/auth.json` and restarts the agent headlessly (never opens a
+browser), and tool permission prompts are auto-approved for the session by
+default.
+
+### Fixed
+
+- **🔁 Account switch & auto-rotate no longer open a browser.** Switching or
+  auto-rotating accounts now: (1) stops the shared agent, (2) replaces
+  `~/.grok/auth.json` with the saved snapshot, (3) starts the agent and
+  authenticates with headless `cached_token` only. Browser auth methods such as
+  `grok.com` are never selected (they used to hang the host and kill Telegram).
+- **🪪 Explicit `activeId` tracking** so rotation still knows which account is
+  live after silent token refreshes (token-hash drift no longer confuses the
+  target list).
+- **🛡️ Auth failures after a switch are surfaced** instead of silently running
+  an unauthenticated agent.
+
+### Added
+
+- **✅ Auto-approve permissions (session scope).** ACP
+  `session/request_permission` requests are auto-approved by default, preferring
+  “allow for this session” / “always allow” over “allow once”. Configure with
+  `AUTO_APPROVE_PERMISSIONS` (default `true`). Interactive Approve/Deny buttons
+  only when both `AUTO_APPROVE_PERMISSIONS=false` and `GROK_TRUST_ALL_TOOLS=false`.
+- **`grok login --device-auth` for `/reauth`** — device-code sign-in streamed to
+  Telegram instead of opening a browser on the host.
+- **`--no-leader`** on `grok agent` so auth is process-local and auth.json swaps
+  take effect on restart.
+
+### Changed
+
+- Headless auth method selection prefers `cached_token` (multi-account) over
+  API key / browser methods.
+
 ## [2.1.0] - 2026-07-10
 
 The **"show me everything"** release — the bot now streams rich, real-time detail
@@ -632,6 +669,9 @@ from a single chat and switch between them, on a redesigned, compact menu.
   diffs, MarkdownV2 rendering, scheduled tasks, multi-image prompts, and a
   cross-platform 24/7 background service.
 
+[2.2.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.0
+[2.1.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.1.0
+[2.0.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.0.0
 [1.7.1]: https://github.com/artickc/grok-telegram-bot/releases/tag/v1.7.1
 [1.7.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v1.7.0
 [1.6.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v1.6.0

package/README.md

@@ -17,8 +17,8 @@ account (SuperGrok / X Premium+), send a message from anywhere, and watch Grok
 plan, read files, run commands, and edit code on your machine — with live typing
 indicators, clean Telegram markdown, and unified edit diffs.
 
-Inspired by [`ajitnk-lab/kiro-acp-telegram-bot`](https://github.com/ajitnk-lab/kiro-acp-telegram-bot)
-and extended into a full multi-session client.
+A fork of [`artickc/kiro-telegram-bot`](https://github.com/artickc/kiro-telegram-bot),
+re-architected for the Grok Build CLI and extended into a full multi-session client.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Control the official Grok Build CLI from Telegram over the Agent Client Protocol (ACP). Sign in with your xAI account, switch projects, resume sessions, stream responses with diffs, queue follow-ups, manage multiple sign-ins, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",

package/scripts/_push-branch.mjs

@@ -0,0 +1,89 @@
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+const files = [
+  ".env.example",
+  "CHANGELOG.md",
+  "src/app/accounts.ts",
+  "src/app/auth-service.ts",
+  "src/bot/account-rotator.ts",
+  "src/bot/bot.ts",
+  "src/bot/handlers/accounts.ts",
+  "src/bot/permission-service.ts",
+  "src/bot/reauth-controller.ts",
+  "src/config.ts",
+  "src/grok/client.ts",
+  "test/auth-and-permissions.test.ts",
+];
+
+const owner = "artickc";
+const repo = "grok-telegram-bot";
+const branch = "feat/fix-rotation-and-auto-approve";
+const message =
+  "fix: account rotation swaps auth.json headlessly; auto-approve session permissions";
+
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function ghApi(method, path, body) {
+  const args = ["api", "-X", method, path];
+  const opts = {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    shell: false,
+    env: { ...process.env, NO_COLOR: "1", CLICOLOR: "0", FORCE_COLOR: "0", GH_FORCE_TTY: "0" },
+  };
+  if (body !== undefined) {
+    args.push("--input", "-");
+    opts.input = JSON.stringify(body);
+  }
+  const r = spawnSync("gh", args, opts);
+  if (r.status !== 0) {
+    throw new Error(`gh api ${method} ${path} failed (${r.status}): ${r.stderr || r.stdout}`);
+  }
+  const text = (r.stdout || "").replace(ANSI_RE, "").trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new Error(`JSON parse failed for ${method} ${path}: ${text.slice(0, 200)}`);
+  }
+}
+
+const refPath = `repos/${owner}/${repo}/git/ref/heads/${branch}`;
+const ref = ghApi("GET", refPath);
+const baseSha = ref.object.sha;
+console.log("base", baseSha);
+
+const baseCommit = ghApi("GET", `repos/${owner}/${repo}/git/commits/${baseSha}`);
+const baseTree = baseCommit.tree.sha;
+
+const tree = [];
+for (const path of files) {
+  const content = readFileSync(path, "utf8");
+  const blob = ghApi("POST", `repos/${owner}/${repo}/git/blobs`, {
+    content: Buffer.from(content, "utf8").toString("base64"),
+    encoding: "base64",
+  });
+  tree.push({ path, mode: "100644", type: "blob", sha: blob.sha });
+  console.log("blob", path, blob.sha.slice(0, 8));
+}
+
+const newTree = ghApi("POST", `repos/${owner}/${repo}/git/trees`, {
+  base_tree: baseTree,
+  tree,
+});
+console.log("tree", newTree.sha);
+
+const commit = ghApi("POST", `repos/${owner}/${repo}/git/commits`, {
+  message,
+  tree: newTree.sha,
+  parents: [baseSha],
+});
+console.log("commit", commit.sha);
+
+ghApi("PATCH", `repos/${owner}/${repo}/git/refs/heads/${branch}`, {
+  sha: commit.sha,
+  force: false,
+});
+console.log("updated", branch, "->", commit.sha);

package/scripts/_release-version.mjs

@@ -0,0 +1,87 @@
+/**
+ * Bump package.json on main + create vX.Y.Z tag via the GitHub API
+ * (local git push/commit is restricted in this environment).
+ */
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+const owner = "artickc";
+const repo = "grok-telegram-bot";
+const branch = "main";
+const version = "2.2.0";
+const tag = `v${version}`;
+const message = `v${version} — headless account rotation + auto-approve session permissions`;
+
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+function ghApi(method, path, body) {
+  const args = ["api", "-X", method, path];
+  const opts = {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    shell: false,
+    env: { ...process.env, NO_COLOR: "1", CLICOLOR: "0", FORCE_COLOR: "0", GH_FORCE_TTY: "0" },
+  };
+  if (body !== undefined) {
+    args.push("--input", "-");
+    opts.input = JSON.stringify(body);
+  }
+  const r = spawnSync("gh", args, opts);
+  if (r.status !== 0) {
+    throw new Error(`gh api ${method} ${path} failed (${r.status}): ${r.stderr || r.stdout}`);
+  }
+  const text = (r.stdout || "").replace(ANSI_RE, "").trim();
+  if (!text) return {};
+  return JSON.parse(text);
+}
+
+const ref = ghApi("GET", `repos/${owner}/${repo}/git/ref/heads/${branch}`);
+const baseSha = ref.object.sha;
+const baseCommit = ghApi("GET", `repos/${owner}/${repo}/git/commits/${baseSha}`);
+const baseTree = baseCommit.tree.sha;
+console.log("base", baseSha);
+
+const content = readFileSync("package.json", "utf8");
+const blob = ghApi("POST", `repos/${owner}/${repo}/git/blobs`, {
+  content: Buffer.from(content, "utf8").toString("base64"),
+  encoding: "base64",
+});
+
+const newTree = ghApi("POST", `repos/${owner}/${repo}/git/trees`, {
+  base_tree: baseTree,
+  tree: [{ path: "package.json", mode: "100644", type: "blob", sha: blob.sha }],
+});
+
+const commit = ghApi("POST", `repos/${owner}/${repo}/git/commits`, {
+  message,
+  tree: newTree.sha,
+  parents: [baseSha],
+});
+console.log("commit", commit.sha);
+
+ghApi("PATCH", `repos/${owner}/${repo}/git/refs/heads/${branch}`, {
+  sha: commit.sha,
+  force: false,
+});
+console.log("updated", branch, "->", commit.sha);
+
+// Annotated tag for release workflow.
+const tagObj = ghApi("POST", `repos/${owner}/${repo}/git/tags`, {
+  tag,
+  message: message,
+  object: commit.sha,
+  type: "commit",
+  tagger: {
+    name: "artickc",
+    email: "artickc@users.noreply.github.com",
+    date: new Date().toISOString(),
+  },
+});
+console.log("tag object", tagObj.sha);
+
+ghApi("POST", `repos/${owner}/${repo}/git/refs`, {
+  ref: `refs/tags/${tag}`,
+  sha: tagObj.sha,
+});
+console.log("created tag", tag);

package/src/app/accounts.ts

@@ -11,7 +11,7 @@
  * Snapshots are copies of auth.json under `<dataDir>/accounts/` (git-ignored).
  * The index stores only a label + token hash, never the token itself.
  */
-import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { createLogger } from "../logger.js";
 import { JsonStore } from "./json-store.js";
@@ -37,6 +37,8 @@ export interface StoredAccount {
 interface AccountsData {
   accounts: StoredAccount[];
   autoRotate?: boolean;
+  /** Explicitly tracked active account id (survives token-hash drift after refresh). */
+  activeId?: string;
 }
 
 function makeId(): string {
@@ -73,11 +75,18 @@ export class AccountManager {
     return this.store.get().accounts.find((a) => a.email === key || a.startUrl === key || a.loginId === key);
   }
 
-  /** Id of the saved account matching the currently active sign-in, by token hash. */
+  /**
+   * Id of the currently active saved account. Prefers the last switch target
+   * (`activeId`), then falls back to matching the live auth.json token hash.
+   */
   activeAccountId(): string | undefined {
+    const data = this.store.get();
+    if (data.activeId && data.accounts.some((a) => a.id === data.activeId)) {
+      return data.activeId;
+    }
     const lid = loginId();
     if (!lid) return undefined;
-    return this.store.get().accounts.find((a) => a.loginId === lid)?.id;
+    return data.accounts.find((a) => a.loginId === lid)?.id;
   }
 
   get(id: string): StoredAccount | undefined {
@@ -98,23 +107,36 @@ export class AccountManager {
     const lid = loginId();
     if (!lid) throw new Error("No browser sign-in to save (an XAI_API_KEY-only login can't be snapshotted).");
     await mkdir(this.dir, { recursive: true });
+    // Prefer a usable token in the live file; reject empty/corrupt auth.json.
+    const raw = await readFile(grokAuthPath(), "utf-8").catch(() => undefined);
+    if (!raw?.trim()) throw new Error("auth.json is empty or missing — run /reauth first.");
+    try {
+      JSON.parse(raw);
+    } catch {
+      throw new Error("auth.json is not valid JSON — run /reauth to repair it.");
+    }
     const label = customLabel?.trim() || loginLabel() || `account ${lid.slice(0, 6)}`;
     const email = loginLabel();
-    const existing = this.store.get().accounts.find((a) => a.loginId === lid);
+    // Match by token hash first; fall back to the currently marked active slot
+    // when the user is re-saving after a silent token refresh.
+    const existing =
+      this.store.get().accounts.find((a) => a.loginId === lid) ??
+      (this.store.get().activeId ? this.get(this.store.get().activeId!) : undefined);
     const id = existing?.id ?? makeId();
-    await copyFile(grokAuthPath(), this.snapshotPath(id));
+    await writeFile(this.snapshotPath(id), raw, "utf-8");
     const meta: StoredAccount = {
       id,
-      label,
+      label: customLabel?.trim() || existing?.label || label,
       loginId: lid,
-      email,
-      startUrl: email,
+      email: email || existing?.email,
+      startUrl: email || existing?.email,
       savedAt: new Date().toISOString(),
     };
     this.store.update((d) => {
       const idx = d.accounts.findIndex((a) => a.id === id);
       if (idx >= 0) d.accounts[idx] = meta;
       else d.accounts.push(meta);
+      d.activeId = id;
     });
     log.info(`captured account ${meta.label} (${id})`);
     return meta;
@@ -122,18 +144,32 @@ export class AccountManager {
 
   /**
    * Make a saved account the active sign-in by copying its snapshot over
-   * auth.json. The caller restarts the ACP agent so the new identity takes
-   * effect. Throws when the snapshot is missing.
+   * auth.json. The caller MUST stop the ACP agent first (so it cannot rewrite
+   * auth.json mid-swap), then restart after this returns. Never opens a
+   * browser — pure file replace. Throws when the snapshot is missing/invalid.
    */
   async switchTo(id: string): Promise<StoredAccount> {
     const meta = this.get(id);
     if (!meta) throw new Error("That account is no longer saved.");
     const snap = this.snapshotPath(id);
     const raw = await readFile(snap, "utf-8").catch(() => undefined);
-    if (!raw) throw new Error(`Saved login for ${meta.label} is missing — re-add it.`);
+    if (!raw?.trim()) throw new Error(`Saved login for ${meta.label} is missing — re-add it.`);
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error(`Saved login for ${meta.label} is corrupt — re-save it via /accounts.`);
+    }
+    // Sanity-check: snapshot must look like auth.json (object with at least one key).
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || Object.keys(parsed as object).length === 0) {
+      throw new Error(`Saved login for ${meta.label} has no token — re-save it via /accounts.`);
+    }
     await mkdir(join(grokAuthPath(), ".."), { recursive: true });
     await writeFile(grokAuthPath(), raw, "utf-8");
-    log.info(`switched active login to ${meta.label} (${id})`);
+    this.store.update((d) => {
+      d.activeId = id;
+    });
+    log.info(`switched active login to ${meta.label} (${id}) — auth.json replaced`);
     return meta;
   }
 
@@ -156,6 +192,7 @@ export class AccountManager {
     await rm(this.snapshotPath(id), { force: true }).catch(() => {});
     this.store.update((d) => {
       d.accounts = d.accounts.filter((a) => a.id !== id);
+      if (d.activeId === id) d.activeId = undefined;
     });
     return existed;
   }

package/src/app/auth-service.ts

@@ -68,7 +68,10 @@ export class AuthService {
       if (signal?.aborted) return resolve({ ok: false, code: null, cancelled: true });
       let proc;
       try {
-        proc = spawn(this.grokCliPath, ["login"], { stdio: ["ignore", "pipe", "pipe"] });
+        // Prefer device-code login so a headless/service host never opens a
+        // browser window (which hangs the bot). The verification URL + code are
+        // streamed to Telegram via onOutput.
+        proc = spawn(this.grokCliPath, ["login", "--device-auth"], { stdio: ["ignore", "pipe", "pipe"] });
       } catch (e) {
         onOutput(`error: ${(e as Error).message}`);
         return resolve({ ok: false, code: null });

package/src/bot/account-rotator.ts

@@ -1,52 +1,79 @@
-/**
- * Auto-rotate-on-give-up. When a turn exhausts its retries (and auto-fork can't
- * recover it), the runtime can cycle through the OTHER saved Grok accounts,
- * retrying the same prompt on each — useful when the active account is
- * throttled, out of quota, or its backend keeps returning "dispatch failure".
- *
- * The rotation is bounded to a SINGLE pass over the saved accounts (no infinite
- * loop): each account is tried once; the first that succeeds wins and stays
- * active, otherwise the runtime reports the error gathered from every account.
- *
- * Account switching is process-global (one machine → one active Grok login), so
- * a rotation restarts the shared agent and affects every chat — intended, since
- * the whole point is to move everyone onto a working login.
- */
-import type { GrokClient } from "../grok/client.js";
-import type { AccountManager } from "../app/accounts.js";
-
-export interface RotationTarget {
-  id: string;
-  label: string;
-}
-
-export interface AccountRotator {
-  /** Whether auto-rotate is switched on. */
-  enabled(): boolean;
-  /** Saved accounts to try, EXCLUDING the one that's currently active. */
-  targets(): Promise<RotationTarget[]>;
-  /** Make a saved account active (swap the sign-in + re-bind). Throws on error. */
-  activate(id: string): Promise<void>;
-}
-
-export class AccountRotatorImpl implements AccountRotator {
-  constructor(
-    private readonly accounts: AccountManager,
-    private readonly acp: GrokClient,
-  ) {}
-
-  enabled(): boolean {
-    return this.accounts.autoRotateEnabled();
-  }
-
-  async targets(): Promise<RotationTarget[]> {
-    const list = this.accounts.list();
-    const activeId = this.accounts.activeAccountId();
-    return list.filter((a) => a.id !== activeId).map((a) => ({ id: a.id, label: a.label }));
-  }
-
-  async activate(id: string): Promise<void> {
-    await this.accounts.switchTo(id);
-    await this.acp.restart();
-  }
-}
+/**
+ * Auto-rotate-on-give-up. When a turn exhausts its retries (and auto-fork can't
+ * recover it), the runtime can cycle through the OTHER saved Grok accounts,
+ * retrying the same prompt on each — useful when the active account is
+ * throttled, out of quota, or its backend keeps returning "dispatch failure".
+ *
+ * The rotation is bounded to a SINGLE pass over the saved accounts (no infinite
+ * loop): each account is tried once; the first that succeeds wins and stays
+ * active, otherwise the runtime reports the error gathered from every account.
+ *
+ * Account switching is process-global (one machine → one active Grok login), so
+ * a rotation restarts the shared agent and affects every chat — intended, since
+ * the whole point is to move everyone onto a working login.
+ *
+ * CRITICAL: switch = stop agent → replace ~/.grok/auth.json → start agent with
+ * headless `cached_token` auth. Never opens a browser / never runs `grok login`.
+ */
+import type { GrokClient } from "../grok/client.js";
+import type { AccountManager } from "../app/accounts.js";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("account-rotator");
+
+export interface RotationTarget {
+  id: string;
+  label: string;
+}
+
+export interface AccountRotator {
+  /** Whether auto-rotate is switched on. */
+  enabled(): boolean;
+  /** Saved accounts to try, EXCLUDING the one that's currently active. */
+  targets(): Promise<RotationTarget[]>;
+  /** Make a saved account active (swap auth.json + re-bind). Throws on error. */
+  activate(id: string): Promise<void>;
+}
+
+export class AccountRotatorImpl implements AccountRotator {
+  constructor(
+    private readonly accounts: AccountManager,
+    private readonly acp: GrokClient,
+  ) {}
+
+  enabled(): boolean {
+    return this.accounts.autoRotateEnabled();
+  }
+
+  async targets(): Promise<RotationTarget[]> {
+    const list = this.accounts.list();
+    const activeId = this.accounts.activeAccountId();
+    return list.filter((a) => a.id !== activeId).map((a) => ({ id: a.id, label: a.label }));
+  }
+
+  /**
+   * Pure file-based account swap:
+   *   1. Stop the shared agent (so it cannot rewrite auth.json),
+   *   2. Copy the saved snapshot over ~/.grok/auth.json,
+   *   3. Start the agent and authenticate with `cached_token` (headless).
+   * Never launches a browser.
+   */
+  async activate(id: string): Promise<void> {
+    // Snapshot the current login first so we never lose it mid-rotation.
+    await this.accounts.captureCurrent().catch((e) => {
+      log.warn("pre-rotate capture failed (continuing):", (e as Error).message);
+    });
+    log.info(`rotating: stopping agent before auth.json swap (${id})`);
+    await this.acp.stopAndWait();
+    try {
+      const meta = await this.accounts.switchTo(id);
+      log.info(`rotating: auth.json now ${meta.label}; starting agent`);
+      await this.acp.start();
+    } catch (e) {
+      // Best-effort recover the agent so the bot stays usable even if the
+      // target login was bad.
+      await this.acp.start().catch((err) => log.warn("post-rotate restart failed:", (err as Error).message));
+      throw e;
+    }
+  }
+}

package/src/bot/bot.ts

@@ -123,8 +123,10 @@ export async function createBot(cfg: AppConfig, acp: GrokClient): Promise<BotBun
   // Auto-rotate-on-give-up: let a stuck turn cycle through other saved logins.
   registry.setAccountRotator(new AccountRotatorImpl(deps.accounts, acp));
 
-  // Inline approvals: when NOT in trust-all mode, Grok asks before risky tools.
-  const permissions = new PermissionService(bot.api, registry);
+  // Permission handling: default is auto-approve (prefer "this session" / always).
+  // Interactive Approve/Deny buttons only when both trust-all and auto-approve are off.
+  const autoApprovePerms = cfg.autoApprovePermissions || cfg.trustAllTools;
+  const permissions = new PermissionService(bot.api, registry, autoApprovePerms);
   acp.permissionHandler = (p) => permissions.handle(p);
 
   // The bot pins/unpins the status panel, and Telegram emits a "pinned a

package/src/bot/handlers/accounts.ts

@@ -175,9 +175,12 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
     await ctx.answerCallbackQuery({ text: "Importing…" });
     const res = await auth.importExisting();
     if (!res.ok) return void rerender(ctx, deps, `\u274C ${res.error ?? "Import failed."}`);
+    // Import reuses the live auth.json — just re-bind the agent headlessly.
     try {
-      await deps.acp.restart();
+      await deps.acp.stopAndWait();
+      await deps.acp.start();
     } catch (e) {
+      await deps.acp.start().catch(() => {});
       return void rerender(ctx, deps, `\u26A0\uFE0F Imported, but re-bind failed: ${(e as Error).message}`);
     }
     let note = `\u2705 Imported the current login${res.label ? ` (${res.label})` : ""}.`;
@@ -196,10 +199,24 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
     if (reason) return void ctx.answerCallbackQuery({ text: reason, show_alert: true });
     await ctx.answerCallbackQuery({ text: "Switching…" });
     try {
-      await deps.accounts.captureCurrent().catch(() => {}); // don't lose the current login
-      const meta = await deps.accounts.switchTo(id);
-      await ctx.editMessageText(`\u{1F504} Switching to ${meta.label}\u2026 restarting agent`).catch(() => {});
-      await deps.acp.restart();
+      // 1) Snapshot the current login so it isn't lost.
+      await deps.accounts.captureCurrent().catch(() => {});
+      const target = deps.accounts.get(id);
+      await ctx
+        .editMessageText(`\u{1F504} Switching to ${target?.label ?? "account"}\u2026 replacing auth.json + restarting agent`)
+        .catch(() => {});
+      // 2) Stop agent BEFORE writing auth.json (avoids the live process
+      //    overwriting / racing the file, and never opens a browser).
+      await deps.acp.stopAndWait();
+      let meta;
+      try {
+        meta = await deps.accounts.switchTo(id);
+        // 3) Start agent; it authenticates headlessly with cached_token.
+        await deps.acp.start();
+      } catch (e) {
+        await deps.acp.start().catch(() => {});
+        throw e;
+      }
       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}`;

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/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;
@@ -162,9 +204,10 @@ export class GrokClient extends EventEmitter {
 
   private async connect(): Promise<void> {
     // `--always-approve` is a `grok agent` option (not `grok agent stdio`),
-    // so it must come before the `stdio` subcommand. `--no-auto-update` was
-    // removed in grok 0.2.x and causes exit code 2.
-    const args = ["agent"];
+    // 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");
 
@@ -197,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" };
@@ -206,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());
@@ -519,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);