grok-telegram-bot 2.0.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,89 @@ 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
+for every tool the agent calls, so you can see exactly what's happening: which
+files are being read, edited (with diffs), created, deleted or moved, which
+searches run (pattern + scope + filters), which URLs are fetched, which shell
+commands execute, and which MCP tools are invoked — each with its completion
+status (✅ / ❌ / ⏳).
+
+### Added
+
+- **🔍 Rich tool-call detail for every kind.** Previously most tool calls showed
+  only a bare icon + title line. Now each kind gets its own formatted detail:
+  - **Search** — query/pattern, search path (📂), include/exclude filters
+    (📁/🚫), case-sensitivity flag.
+  - **Read** — file path + line/offset/limit when present.
+  - **Edit** — file path + unified diff block with `+added / -removed` count.
+  - **Write / Create** — file path + content preview with automatic language
+    detection for syntax highlighting (TypeScript, Python, Go, Rust, etc.).
+  - **Delete** — the file being removed.
+  - **Move / Rename** — source path (📄) → destination path (➡️).
+  - **Execute** — the full command in a `bash` code block + working directory.
+  - **Fetch / web_fetch** — URL, HTTP method, headers, and body preview.
+  - **Web search** — query string + result count.
+  - **MCP calls** — server + method + a compact argument preview.
+  - **Generic / unknown** — description or message extracted from raw input.
+- **✅ Status visibility for completed tool calls.** `tool_call_update`
+  notifications carrying `completed` or `failed` status are now shown (previously
+  they were silently deduped away because they shared the `toolCallId` of the
+  initial `tool_call`). You now see the final ✅ or ❌ for each tool action,
+  including diffs that arrive only in the completion update.
+- **🧩 New `tool-call-detail.ts` module** — shared extractors for paths, search
+  queries, URLs, commands, file content, filters, and destination paths, with a
+  `normalizeKind()` that maps common aliases (`bash` → `execute`, `grep` →
+  `search`, `rename` → `move`, etc.) to canonical kinds.
+
+### Changed
+
+- **`formatToolCall` rewritten** from a single switch to per-kind formatter
+  functions, each producing rich RAW markdown. Uses string concatenation instead
+  of template literals to avoid backtick-in-fence escaping issues.
+- **`session-runtime.ts` dedup logic** refined: initial `tool_call` messages are
+  deduped by `toolCallId` (no duplicate); `tool_call_update` with `completed` /
+  `failed` status is shown once (keyed by `toolCallId:done`); `pending` /
+  `in_progress` updates are skipped unless they carry new `content_blocks`.
+
 ## [2.0.0] - 2026-07-09
 
 The **Grok Build** release — the bot now drives the official **xAI Grok Build
@@ -586,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.0.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}`;