grok-telegram-bot 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -9,6 +9,23 @@ The latest section is published verbatim as the GitHub Release notes by
 
 ## [Unreleased]
 
+## [2.3.1] - 2026-07-19
+
+### Fixed
+
+- **Stable account rotation across concurrent chats.** Account selection is now
+  serialized around the single shared Grok CLI process. Chats reuse the working
+  account selected by another session and create their own ACP session instead
+  of starting competing rotation loops that repeatedly restart the agent.
+- **Session failures no longer condemn valid accounts.** `unknown session id`,
+  agent-restart/process-exit, and headless-auth initialization errors now trigger
+  a session rebind/retry on the active account rather than quarantining or
+  cycling functional logins.
+- **Reliable restart propagation.** Credential imports, manual switches,
+  reauthentication, and automatic rotation notify every chat runtime after the
+  shared process restarts; new session binding waits until candidate validation
+  completes.
+
 ## [2.3.0] - 2026-07-17
 
 ### Added
@@ -761,6 +778,7 @@ 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.3.1]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.1
 [2.3.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.0
 [2.2.4]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.4
 [2.2.3]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "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/src/bot/account-rotator.ts

@@ -30,6 +30,12 @@ export interface RotationTarget {
   label: string;
 }
 
+export interface RotationState {
+  generation: number;
+  activeId?: string;
+  activeLabel?: string;
+}
+
 export interface AccountRotator {
   /** Whether auto-rotate is switched on. */
   enabled(): boolean;
@@ -39,9 +45,19 @@ export interface AccountRotator {
   activate(id: string): Promise<void>;
   /** Quarantine an account after an account-specific failure. Undefined means active. */
   markFailed(id: string | undefined, reason: string): Promise<void>;
+  /** Process/account generation observed when a turn failed. */
+  state(): RotationState;
+  /** Serialize a complete rotation probe. `changed` means another chat already
+   * selected/restarted an account while this caller was waiting. */
+  withRotationLock<T>(observed: RotationState, run: (changed: boolean) => Promise<T>): Promise<T>;
+  /** Wait for an in-progress rotation probe before re-binding a stale session. */
+  waitForIdle(): Promise<void>;
 }
 
 export class AccountRotatorImpl implements AccountRotator {
+  private generation = 0;
+  private rotationTail: Promise<void> = Promise.resolve();
+
   constructor(
     private readonly accounts: AccountManager,
     private readonly acp: GrokClient,
@@ -51,6 +67,42 @@ export class AccountRotatorImpl implements AccountRotator {
     return this.accounts.autoRotateEnabled();
   }
 
+  state(): RotationState {
+    const activeId = this.accounts.activeAccountId();
+    return {
+      generation: this.generation,
+      activeId,
+      activeLabel: activeId ? this.accounts.get(activeId)?.label : undefined,
+    };
+  }
+
+  async withRotationLock<T>(observed: RotationState, run: (changed: boolean) => Promise<T>): Promise<T> {
+    const previous = this.rotationTail;
+    let release!: () => void;
+    this.rotationTail = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      const current = this.state();
+      const changed =
+        current.generation !== observed.generation || current.activeId !== observed.activeId;
+      return await run(changed);
+    } finally {
+      release();
+    }
+  }
+
+  async waitForIdle(): Promise<void> {
+    // Include work queued while we were waiting, not only the first captured
+    // promise, so callers never re-bind in the middle of a candidate switch.
+    for (;;) {
+      const pending = this.rotationTail;
+      await pending;
+      if (pending === this.rotationTail) return;
+    }
+  }
+
   async targets(): Promise<RotationTarget[]> {
     const list = this.accounts.list();
     const activeId = this.accounts.activeAccountId();
@@ -96,12 +148,19 @@ export class AccountRotatorImpl implements AccountRotator {
       log.info(`rotating: auth.json now ${meta.label}; starting Grok CLI + re-auth`);
       // start() → connect() → initialize + authenticate(cached_token) against
       // the freshly written auth.json. A live process would keep the old token.
-      await this.acp.start();
+      await this.acp.start(true);
+      this.generation++;
       log.info(`rotating: Grok CLI up on ${meta.label}`);
     } 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));
+      await this.acp.stopAndWait().catch(() => {});
+      await this.acp
+        .start(true)
+        .then(() => {
+          this.generation++;
+        })
+        .catch((err) => log.warn("post-rotate restart failed:", (err as Error).message));
       throw e;
     }
   }

package/src/bot/handlers/accounts.ts

@@ -205,9 +205,9 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
     // Import reuses the live auth.json — just re-bind the agent headlessly.
     try {
       await deps.acp.stopAndWait();
-      await deps.acp.start();
+      await deps.acp.start(true);
     } catch (e) {
-      await deps.acp.start().catch(() => {});
+      await deps.acp.start(true).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})` : ""}.`;
@@ -239,9 +239,9 @@ export function registerAccounts(bot: Bot, deps: BotDeps): void {
       try {
         meta = await deps.accounts.switchTo(id);
         // 3) Start agent; it authenticates headlessly with cached_token.
-        await deps.acp.start();
+        await deps.acp.start(true);
       } catch (e) {
-        await deps.acp.start().catch(() => {});
+        await deps.acp.start(true).catch(() => {});
         throw e;
       }
       const note = (await deps.usage.isLoggedIn())

package/src/bot/reauth-controller.ts

@@ -180,7 +180,7 @@ export class ReauthController {
       }
       s.phase = "restarting";
       await this.render(s);
-      await this.grok.start();
+      await this.grok.start(true);
       agentDown = false;
       s.accountLabel = accountLabel(await this.getAccount?.().catch(() => undefined));
       s.phase = "done";
@@ -191,7 +191,7 @@ export class ReauthController {
     } finally {
       s.abort = undefined;
       this.stopAnim(s);
-      if (agentDown) await this.grok.start().catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
+      if (agentDown) await this.grok.start(true).catch((e) => log.warn("post-reauth restart failed:", (e as Error).message));
       await this.render(s);
     }
   }

package/src/bot/session-runtime.ts

@@ -10,6 +10,7 @@ import {
   type GrokClient,
   isAccountRotationError,
   isContextExhaustedError,
+  isSessionLifecycleError,
   isTransientError,
   type SessionMetadata,
 } from "../grok/client.js";
@@ -256,6 +257,7 @@ export class SessionRuntime {
   // в”Ђв”Ђ sessions в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async startNewSession(cwd: string, projectName?: string): Promise<void> {
+    await this.accountRotator?.waitForIdle();
     if (this.busy) await this.cancel();
     await this.bindNewSession(cwd, projectName);
   }
@@ -430,6 +432,9 @@ export class SessionRuntime {
   }
 
   private async ensureSession(): Promise<void> {
+    // Account rotation restarts the process globally. Do not bind a new chat
+    // to a candidate account until the owner has finished probing it.
+    await this.accountRotator?.waitForIdle();
     if (this.rebindPending && this.sessionId) {
       // The ACP process is frequently mid-restart the first time we re-bind
       // (auto-restart after a crash, or a fresh bot boot), so a single attempt
@@ -525,8 +530,10 @@ export class SessionRuntime {
 
     try {
       const outcome = await this.runPromptWithRetries(content);
-      const recovered = await this.maybeAutoFork(input, outcome);
-      let final = recovered ?? outcome;
+      const rebound = await this.maybeRecoverAgentSession(input, outcome);
+      let final = rebound ?? outcome;
+      const recovered = await this.maybeAutoFork(input, final);
+      final = recovered ?? final;
       // Last resort: if the turn still failed, rotate through other saved
       // accounts (once) and retry on each until one works.
       const rotated = await this.maybeRotateAccount(input, final);
@@ -629,6 +636,51 @@ export class SessionRuntime {
     return pct !== undefined && pct >= threshold;
   }
 
+  /** A shared-process restart invalidates this runtime's ACP session binding,
+   * but says nothing about account health. Wait for any account probe to
+   * settle, re-bind/fork this chat on the selected account, and retry once. */
+  private async maybeRecoverAgentSession(
+    input: PromptInput,
+    outcome: { result?: PromptResult; error?: Error; attempts: number },
+  ): Promise<{ result?: PromptResult; error?: Error; attempts: number } | undefined> {
+    if (
+      !outcome.error ||
+      !isSessionLifecycleError(outcome.error) ||
+      this.cancelled ||
+      (this.streamer?.hasOutput ?? false)
+    ) {
+      return undefined;
+    }
+    try {
+      await this.accountRotator?.waitForIdle();
+      if (this.cancelled) return outcome;
+      const previousId = this.sessionId;
+      this.sessionLive = false;
+      this.rebindPending = Boolean(previousId);
+      await this.ensureSession();
+      this.shownToolIds = new Set();
+      this.subagentShown = new Map();
+      this.streamer?.setFooter(this.hashtags());
+      const retryContent = buildContentBlocks(input, {
+        reasoning: reasoningDirective(this.reasoning),
+        priming: this.primingContext,
+        imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
+        progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+      });
+      this.primingContext = undefined;
+      log.info(
+        `chat ${this.chatId} recovered lifecycle error on the active account` +
+          (previousId && this.sessionId !== previousId
+            ? ` with fresh session ${this.sessionId?.slice(0, 8)}`
+            : " by re-binding its session"),
+      );
+      return this.runPromptWithRetries(retryContent);
+    } catch (error) {
+      log.warn(`chat ${this.chatId} session recovery failed: ${(error as Error).message}`);
+      return { error: error as Error, attempts: outcome.attempts };
+    }
+  }
+
   /**
    * Auto-fork-on-error recovery. When a turn fails with a *transient* error (or
    * a context-exhaustion error) and nothing was streamed to the user, the
@@ -700,25 +752,57 @@ export class SessionRuntime {
   ): Promise<{ result?: PromptResult; error?: Error; attempts: number } | undefined> {
     const rotator = this.accountRotator;
     if (!rotator?.enabled() || !final.error || this.cancelled) return undefined;
+    if (isSessionLifecycleError(final.error)) return undefined;
+    const originalError = final.error;
+    const observed = rotator.state();
+    return rotator.withRotationLock(observed, async (changed) => {
+      if (this.cancelled) return final;
+      if (changed) {
+        if (this.streamer?.hasOutput ?? false) return undefined;
+        const current = rotator.state();
+        const transcript = this.sessionId ? recentTranscript(this.cfg.sessionsDir, this.sessionId) : undefined;
+        if (this.foreground) {
+          await this.notify(
+            `\u{1F504} Reusing ${current.activeLabel ?? "the account selected by another chat"} with a fresh session…`,
+            { replyTo: this.turnReplyTo },
+          );
+        }
+        log.info(`chat ${this.chatId} reusing account generation ${current.generation} selected by another chat`);
+        try {
+          await this.bindNewSession(this.cwd, this.projectName);
+        } catch (error) {
+          return { error: error as Error, attempts: final.attempts };
+        }
+        this.shownToolIds = new Set();
+        this.subagentShown = new Map();
+        this.streamer?.setFooter(this.hashtags());
+        const content = buildContentBlocks(input, {
+          reasoning: reasoningDirective(this.reasoning),
+          priming: transcript ? buildPriming(transcript) : undefined,
+          imageOutput: this.cfg.sendAgentImages ? IMAGE_OUTPUT_DIRECTIVE : undefined,
+          progress: this.cfg.showProgress ? PROGRESS_DIRECTIVE : undefined,
+        });
+        return this.runPromptWithRetries(content);
+      }
     // A quota-exhausted or access-denied response cannot be recovered by retrying
     // this login. Quarantine it before choosing targets, so later rotations do not
     // cycle back to a known-bad account. This intentionally happens before the
     // partial-stream guard: we must not retry/rotate a partial reply, but its
     // account still needs to be skipped during a future rotation.
-    if (isAccountRotationError(final.error)) {
-      await rotator.markFailed(undefined, final.error.message);
+    if (isAccountRotationError(originalError)) {
+      await rotator.markFailed(observed.activeId, originalError.message);
     }
     if (this.streamer?.hasOutput ?? false) return undefined;
     const targets = await rotator.targets().catch(() => [] as { id: string; label: string }[]);
     if (targets.length === 0) return undefined;
 
     const transcript = this.sessionId ? recentTranscript(this.cfg.sessionsDir, this.sessionId) : undefined;
-    const errors: string[] = [`\u2022 previous: ${final.error.message}`];
+    const errors: string[] = [`\u2022 previous: ${originalError.message}`];
     let last = final;
 
     for (const t of targets) {
       if (this.cancelled) return last;
-      const failReason = last.error ?? final.error;
+      const failReason = last.error ?? originalError;
       if (this.foreground) {
         await this.notify(formatAccountSwitchNotice(t.label, failReason), { replyTo: this.turnReplyTo });
       }
@@ -767,6 +851,7 @@ export class SessionRuntime {
     // 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 };
+    });
   }
 
   /**

package/src/grok/client.ts

@@ -59,6 +59,11 @@ const ACCOUNT_EXHAUSTED_RE =
  * saved login may be permitted, while same-account retries cannot help. */
 const ACCOUNT_ACCESS_DENIED_RE =
   /\b403\b|forbidden|access denied/i;
+/** Process/session lifecycle failures are not evidence that the active login
+ * is bad. They require a session re-bind on the current process generation,
+ * never account rotation. */
+const SESSION_LIFECYCLE_RE =
+  /unknown session id|grok agent is restarting|grok agent stdio exited|grok agent (?:is )?not running|agent connection (?:is )?closed|authentication required.{0,80}no auth method id provided/i;
 
 export class GrokError extends Error {
   constructor(
@@ -123,7 +128,14 @@ export function isAccountRotationError(err: Error): boolean {
   return false;
 }
 
+export function isSessionLifecycleError(err: Error): boolean {
+  return SESSION_LIFECYCLE_RE.test(err.message);
+}
+
 export function isTransientError(err: Error): boolean {
+  // Retrying the same stale session cannot recover a process-generation
+  // mismatch. SessionRuntime owns the immediate re-bind + one safe retry.
+  if (isSessionLifecycleError(err)) return false;
   // Quota exhaustion and access denial are permanent for this login — rotate,
   // never back off and retry the same credentials.
   if (isAccountRotationError(err)) return false;
@@ -265,9 +277,10 @@ export class GrokClient extends EventEmitter {
     this.availableModels = KNOWN_MODELS.map((m) => ({ modelId: m.modelId, name: m.name, description: m.description }));
   }
 
-  async start(): Promise<void> {
+  async start(notifyRestarted = false): Promise<void> {
     this.stopped = false;
     await this.connect();
+    if (notifyRestarted) this.emit("restarted");
   }
 
   private async connect(): Promise<void> {
@@ -529,9 +542,7 @@ export class GrokClient extends EventEmitter {
     this.stopped = true;
     this.restartAttempts = 0;
     await this.killCurrent();
-    this.stopped = false;
-    await this.connect();
-    this.emit("restarted");
+    await this.start(true);
   }
 
   private killCurrent(): Promise<void> {