grok-telegram-bot 2.0.0

package/src/app/accounts.ts

@@ -0,0 +1,162 @@
+/**
+ * Multi-account support for Grok Build. Grok has one active sign-in at a time
+ * (`~/.grok/auth.json`, written by `grok login`). This manager keeps several
+ * logins side by side and switches between them:
+ *
+ *   • capture — snapshot the current auth.json as a named account,
+ *   • switch  — copy a saved snapshot back over auth.json (the caller restarts
+ *               the agent so the new identity takes effect),
+ *   • forget  — drop a saved snapshot.
+ *
+ * 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 { join } from "node:path";
+import { createLogger } from "../logger.js";
+import { JsonStore } from "./json-store.js";
+import { grokAuthPath, hasLogin, loginId, loginLabel } from "./grok-credentials.js";
+import type { AccountInfo } from "./usage.js";
+
+const log = createLogger("accounts");
+
+/** Persisted, non-secret metadata about a saved account. */
+export interface StoredAccount {
+  id: string;
+  label: string;
+  /** Hash of the sign-in token — the robust identity used to dedup/match. */
+  loginId?: string;
+  email?: string;
+  savedAt: string;
+  // Back-compat alias used by some callers.
+  startUrl?: string;
+  accountType?: string;
+  region?: string;
+}
+
+interface AccountsData {
+  accounts: StoredAccount[];
+  autoRotate?: boolean;
+}
+
+function makeId(): string {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export class AccountManager {
+  private readonly store: JsonStore<AccountsData>;
+  private readonly dir: string;
+
+  constructor(dataDir: string) {
+    this.dir = join(dataDir, "accounts");
+    this.store = new JsonStore<AccountsData>(join(this.dir, "index.json"), { accounts: [] });
+  }
+
+  list(): StoredAccount[] {
+    return [...this.store.get().accounts].sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+  }
+
+  autoRotateEnabled(): boolean {
+    return this.store.get().autoRotate === true;
+  }
+
+  setAutoRotate(on?: boolean): boolean {
+    const next = on ?? !this.autoRotateEnabled();
+    this.store.update((d) => {
+      d.autoRotate = next;
+    });
+    return next;
+  }
+
+  matchActive(key: string | undefined): StoredAccount | undefined {
+    if (!key) return undefined;
+    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. */
+  activeAccountId(): string | undefined {
+    const lid = loginId();
+    if (!lid) return undefined;
+    return this.store.get().accounts.find((a) => a.loginId === lid)?.id;
+  }
+
+  get(id: string): StoredAccount | undefined {
+    return this.store.get().accounts.find((a) => a.id === id);
+  }
+
+  private snapshotPath(id: string): string {
+    return join(this.dir, `${id}.json`);
+  }
+
+  /**
+   * Snapshot the current sign-in (auth.json) as a saved account. Refreshes an
+   * existing account with the same token instead of duplicating. Throws when
+   * not signed in.
+   */
+  async captureCurrent(_info?: AccountInfo, customLabel?: string): Promise<StoredAccount> {
+    if (!hasLogin()) throw new Error("Not signed in — run /reauth (grok login) first.");
+    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 });
+    const label = customLabel?.trim() || loginLabel() || `account ${lid.slice(0, 6)}`;
+    const email = loginLabel();
+    const existing = this.store.get().accounts.find((a) => a.loginId === lid);
+    const id = existing?.id ?? makeId();
+    await copyFile(grokAuthPath(), this.snapshotPath(id));
+    const meta: StoredAccount = {
+      id,
+      label,
+      loginId: lid,
+      email,
+      startUrl: 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);
+    });
+    log.info(`captured account ${meta.label} (${id})`);
+    return meta;
+  }
+
+  /**
+   * 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.
+   */
+  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.`);
+    await mkdir(join(grokAuthPath(), ".."), { recursive: true });
+    await writeFile(grokAuthPath(), raw, "utf-8");
+    log.info(`switched active login to ${meta.label} (${id})`);
+    return meta;
+  }
+
+  rename(id: string, label: string): StoredAccount | undefined {
+    const clean = label.trim();
+    if (!clean) return this.get(id);
+    let updated: StoredAccount | undefined;
+    this.store.update((d) => {
+      const a = d.accounts.find((x) => x.id === id);
+      if (a) {
+        a.label = clean;
+        updated = a;
+      }
+    });
+    return updated;
+  }
+
+  async forget(id: string): Promise<boolean> {
+    const existed = !!this.get(id);
+    await rm(this.snapshotPath(id), { force: true }).catch(() => {});
+    this.store.update((d) => {
+      d.accounts = d.accounts.filter((a) => a.id !== id);
+    });
+    return existed;
+  }
+}

package/src/app/auth-service.ts

@@ -0,0 +1,136 @@
+/**
+ * Grok authentication control for /reauth: `grok logout` then `grok login`.
+ * `grok login` performs the xAI account sign-in; on a bot host without a
+ * browser it prints a verification URL/code, which we stream back to Telegram.
+ */
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { createLogger } from "../logger.js";
+import { authFileExists, hasLogin, loginLabel } from "./grok-credentials.js";
+
+const run = promisify(execFile);
+const log = createLogger("auth");
+
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+export interface LoginResult {
+  ok: boolean;
+  code: number | null;
+  cancelled?: boolean;
+  error?: string;
+}
+
+export interface LoginOptions {
+  onOutput: (text: string) => void;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+export class AuthService {
+  constructor(private readonly grokCliPath: string) {}
+
+  /** Run `grok logout` (non-interactive, best-effort). */
+  async logout(): Promise<{ ok: boolean; out: string }> {
+    try {
+      const { stdout, stderr } = await run(this.grokCliPath, ["logout"], { timeout: 30_000, encoding: "utf-8" });
+      return { ok: true, out: clean(`${stdout}${stderr}`) };
+    } catch (e) {
+      const err = e as { stdout?: string; stderr?: string; message?: string };
+      const out = clean(`${err.stdout ?? ""}${err.stderr ?? ""}`) || err.message || "logout failed";
+      return { ok: false, out };
+    }
+  }
+
+  /**
+   * Adopt an existing sign-in already present on this machine (a prior
+   * `grok login` wrote ~/.grok/auth.json). Returns ok:false with guidance when
+   * none is present.
+   */
+  async importExisting(): Promise<{ ok: boolean; error?: string; label?: string }> {
+    if (hasLogin()) return { ok: true, label: loginLabel() };
+    if (!authFileExists()) {
+      return {
+        ok: false,
+        error: "No Grok login found. Run `grok login` on the host (or set XAI_API_KEY), then try again.",
+      };
+    }
+    return { ok: false, error: "The Grok auth file has no usable token — run `grok login` again." };
+  }
+
+  /**
+   * Run `grok login`, streaming stdout/stderr (so any verification URL/code
+   * reaches the user). Resolves when the process exits, times out, or aborts.
+   */
+  login(opts: LoginOptions): Promise<LoginResult> {
+    const { onOutput, timeoutMs = 300_000, signal } = opts;
+    return new Promise<LoginResult>((resolve) => {
+      if (signal?.aborted) return resolve({ ok: false, code: null, cancelled: true });
+      let proc;
+      try {
+        proc = spawn(this.grokCliPath, ["login"], { stdio: ["ignore", "pipe", "pipe"] });
+      } catch (e) {
+        onOutput(`error: ${(e as Error).message}`);
+        return resolve({ ok: false, code: null });
+      }
+      let cancelled = false;
+      let settled = false;
+      let hardKill: NodeJS.Timeout | undefined;
+
+      const onAbort = (): void => {
+        cancelled = true;
+        try {
+          proc.kill();
+        } catch {
+          /* ignore */
+        }
+        hardKill = setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+            /* ignore */
+          }
+        }, 2000);
+      };
+      const finish = (r: LoginResult): void => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (hardKill) clearTimeout(hardKill);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(r);
+      };
+      const feed = (b: Buffer): void => {
+        const t = clean(b.toString("utf-8"));
+        if (t) onOutput(t);
+      };
+      proc.stdout?.on("data", feed);
+      proc.stderr?.on("data", feed);
+      const timer = setTimeout(() => {
+        onOutput("\n\u23F1\uFE0F Timed out waiting for login to complete.");
+        try {
+          proc.kill();
+        } catch {
+          /* ignore */
+        }
+      }, timeoutMs);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      proc.on("error", (e: Error) => {
+        onOutput(`error: ${e.message}`);
+        finish({ ok: false, code: null, cancelled });
+      });
+      proc.on("exit", (code: number | null) => {
+        // Success = clean exit AND a usable token now on disk.
+        finish({ ok: code === 0 && !cancelled && hasLogin(), code, cancelled });
+      });
+    });
+  }
+
+  isConfigured(): boolean {
+    return hasLogin();
+  }
+}
+
+function clean(s: string): string {
+  return s.replace(ANSI_RE, "").replace(/\r/g, "");
+}

package/src/app/grok-credentials.ts

@@ -0,0 +1,103 @@
+/**
+ * Grok Build login state. The official CLI signs in with your xAI account
+ * (`grok login`, browser OIDC) and stores the token in `~/.grok/auth.json`:
+ *
+ *   { "<scope_url>": { "key": "<token>" }, ... }
+ *
+ * (An `XAI_API_KEY` env var is an alternative for non-browser hosts.) This
+ * module reads that file so the bot can show who's signed in, detect a usable
+ * login, and snapshot/switch logins as named accounts (/accounts). The token is
+ * never transmitted anywhere.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** Guidance shown when no usable login is configured. */
+export const UNSUPPORTED_LOGIN_HELP =
+  "Grok isn't signed in. Run `grok login` on the machine hosting the bot (or use " +
+  "/reauth), or set XAI_API_KEY. You need a SuperGrok or X Premium+ subscription.";
+
+/** OIDC + legacy sign-in scope keys used in ~/.grok/auth.json. */
+const OIDC_SCOPE = "https://auth.x.ai::b1a00492-073a-47ea-816f-4c329264a828";
+const LEGACY_SCOPE = "https://accounts.x.ai/sign-in";
+
+export function grokConfigDir(): string {
+  return join(homedir(), ".grok");
+}
+
+/** Path to the Grok CLI auth token file (written by `grok login`). */
+export function grokAuthPath(): string {
+  return join(grokConfigDir(), "auth.json");
+}
+
+export function authFileExists(): boolean {
+  return existsSync(grokAuthPath());
+}
+
+type AuthFile = Record<string, { key?: string } | undefined>;
+
+export function readAuth(): AuthFile {
+  try {
+    return JSON.parse(readFileSync(grokAuthPath(), "utf-8")) as AuthFile;
+  } catch {
+    return {};
+  }
+}
+
+/** The active sign-in token from auth.json (OIDC preferred, then legacy). */
+export function currentToken(auth: AuthFile = readAuth()): string | undefined {
+  const oidc = auth[OIDC_SCOPE]?.key?.trim();
+  if (oidc) return oidc;
+  const legacy = auth[LEGACY_SCOPE]?.key?.trim();
+  return legacy || undefined;
+}
+
+/** Whether a usable login exists (a token in auth.json, or XAI_API_KEY). */
+export function hasLogin(): boolean {
+  return !!currentToken() || !!process.env.XAI_API_KEY?.trim();
+}
+
+/** A stable, non-reversible id for the active login, for account dedup/match. */
+export function loginId(auth: AuthFile = readAuth()): string | undefined {
+  const tok = currentToken(auth);
+  if (!tok) return undefined;
+  return createHash("sha256").update(tok).digest("hex").slice(0, 16);
+}
+
+export interface LoginIdentity {
+  email?: string;
+  name?: string;
+}
+
+function decodeJwtPayload(jwt: string): Record<string, unknown> | undefined {
+  const parts = jwt.split(".");
+  if (parts.length < 2) return undefined;
+  try {
+    return JSON.parse(Buffer.from(parts[1]!, "base64url").toString("utf-8")) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Best-effort identity (email/name) decoded from the sign-in JWT. */
+export function identityFromAuth(auth: AuthFile = readAuth()): LoginIdentity {
+  const tok = currentToken(auth);
+  if (!tok) return {};
+  const claims = decodeJwtPayload(tok);
+  if (!claims) return {};
+  const str = (k: string): string | undefined => (typeof claims[k] === "string" ? (claims[k] as string) : undefined);
+  const emailish = str("email") || str("preferred_username") || str("upn");
+  const email = emailish && emailish.includes("@") ? emailish : undefined;
+  return { email, name: str("name") || str("given_name") };
+}
+
+/** A short human label for the active login (email, else a short token hash). */
+export function loginLabel(auth: AuthFile = readAuth()): string | undefined {
+  const id = identityFromAuth(auth);
+  if (id.email) return id.email;
+  if (id.name) return id.name;
+  const lid = loginId(auth);
+  return lid ? `account ${lid.slice(0, 6)}` : undefined;
+}

package/src/app/instance-lock.ts

@@ -0,0 +1,139 @@
+/**
+ * Single-instance guard, keyed per bot token (NOT per folder), so the same bot
+ * can't run twice no matter which directory it's started from.
+ *
+ * Telegram allows only ONE long-polling consumer per token — a second instance
+ * triggers 409 Conflict and, worse, a leftover "ghost" process started from an
+ * old folder keeps answering with a stale `.env` (e.g. an outdated
+ * `ALLOWED_USERS`, so you get "⛔ Not authorized"). On startup we therefore
+ * take an exclusive lock: if a still-alive instance holds it, we terminate that
+ * process (and its child tree on Windows) so the fresh process — with the
+ * current config — becomes the only consumer.
+ *
+ * The lock lives under the canonical home (`~/.grok/tg/locks/<tokenHash>.lock`)
+ * and stores only a pid + start time + whether the holder is supervised. The
+ * token itself is never written to disk (only its hash names the file).
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import { killPid } from "../sessions/process.js";
+import { isPidAlive } from "../sessions/store.js";
+
+const log = createLogger("lock");
+
+interface LockData {
+  pid: number;
+  startedAt: number;
+  /** True when the holder runs under a supervisor (systemd/launchd/Task). */
+  supervised: boolean;
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+
+export class InstanceLock {
+  private readonly file: string;
+  private held = false;
+
+  constructor(
+    token: string,
+    locksDir: string,
+    private readonly supervised: boolean,
+  ) {
+    const hash = createHash("sha256").update(token).digest("hex").slice(0, 16);
+    this.file = join(locksDir, `${hash}.lock`);
+  }
+
+  /**
+   * Become the sole instance for this token. Returns `false` (caller should
+   * exit) only when a *supervised* service instance is already running and this
+   * process is a plain manual start — we don't fight the background service
+   * (that would cause a restart/kill loop). Otherwise we take over: a live
+   * holder is terminated and the lock is rewritten with our pid.
+   */
+  async acquire(): Promise<boolean> {
+    const existing = this.read();
+    if (existing && existing.pid !== process.pid && isPidAlive(existing.pid)) {
+      if (existing.supervised && !this.supervised) {
+        log.warn(`a supervised service instance is already running (pid ${existing.pid}); not starting a duplicate`);
+        return false;
+      }
+      if (looksLikeNode(existing.pid)) {
+        log.warn(`another bot instance is running (pid ${existing.pid}); terminating it to take over`);
+        killPid(existing.pid);
+        for (let i = 0; i < 20 && isPidAlive(existing.pid); i++) await sleep(150); // up to ~3s
+        if (isPidAlive(existing.pid)) log.warn(`previous instance ${existing.pid} still alive after kill; continuing anyway`);
+      } else {
+        // The locked pid was recycled to an unrelated process — don't kill it,
+        // just reclaim the stale lock.
+        log.warn(`lock pid ${existing.pid} is not a node process; reclaiming stale lock`);
+      }
+    }
+    this.write();
+    this.held = true;
+    return true;
+  }
+
+  /** Release the lock if (and only if) we still own it. */
+  release(): void {
+    if (!this.held) return;
+    this.held = false;
+    try {
+      const cur = this.read();
+      if (cur?.pid === process.pid) rmSync(this.file, { force: true });
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  private write(): void {
+    const data: LockData = { pid: process.pid, startedAt: Date.now(), supervised: this.supervised };
+    try {
+      mkdirSync(join(this.file, ".."), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(data), "utf-8");
+    } catch (e) {
+      log.warn(`could not write lock file ${this.file}: ${(e as Error).message}`);
+    }
+  }
+
+  private read(): LockData | undefined {
+    try {
+      const d = JSON.parse(readFileSync(this.file, "utf-8")) as Partial<LockData>;
+      if (typeof d.pid === "number" && d.pid > 0) {
+        return { pid: d.pid, startedAt: Number(d.startedAt) || 0, supervised: Boolean(d.supervised) };
+      }
+    } catch {
+      /* no/invalid lock */
+    }
+    return undefined;
+  }
+}
+
+/**
+ * Best-effort check that `pid` is a node process (our bot), to avoid killing an
+ * unrelated process that happened to reuse the pid. If the platform query can't
+ * run or be parsed, we assume it's ours (only this bot writes the lock) — better
+ * to clear a ghost than to leave one fighting over the token.
+ */
+function looksLikeNode(pid: number): boolean {
+  try {
+    if (process.platform === "win32") {
+      const out = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      // No matching task prints an INFO line, not a CSV row — treat as "gone".
+      if (!/^\s*"/.test(out)) return false;
+      return /node\.exe|tsx/i.test(out);
+    }
+    const out = execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    return /node|tsx/i.test(out);
+  } catch {
+    return true;
+  }
+}

package/src/app/json-store.ts

@@ -0,0 +1,54 @@
+/**
+ * Minimal atomic JSON persistence. Reads on construction, writes atomically
+ * (temp file + rename) on save. No external dependencies.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("json-store");
+
+export class JsonStore<T> {
+  private data: T;
+
+  constructor(
+    private readonly path: string,
+    private readonly fallback: T,
+  ) {
+    this.data = this.read();
+  }
+
+  get(): T {
+    return this.data;
+  }
+
+  set(data: T): void {
+    this.data = data;
+    this.save();
+  }
+
+  /** Mutate via a callback, then persist. */
+  update(fn: (data: T) => void): void {
+    fn(this.data);
+    this.save();
+  }
+
+  private read(): T {
+    try {
+      return JSON.parse(readFileSync(this.path, "utf-8")) as T;
+    } catch {
+      return structuredClone(this.fallback);
+    }
+  }
+
+  private save(): void {
+    try {
+      mkdirSync(dirname(this.path), { recursive: true });
+      const tmp = `${this.path}.tmp`;
+      writeFileSync(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+      renameSync(tmp, this.path);
+    } catch (e) {
+      log.error(`failed to save ${this.path}:`, (e as Error).message);
+    }
+  }
+}

package/src/app/reasoning.ts

@@ -0,0 +1,30 @@
+/**
+ * Reasoning effort — a per-chat preference that steers how much deliberation
+ * the agent applies. Implemented as a concise directive prepended to prompts so
+ * it works regardless of backend-specific knobs.
+ */
+import type { ReasoningEffort } from "./types.js";
+
+const DIRECTIVE: Record<ReasoningEffort, string> = {
+  minimal: "Answer directly and briefly with minimal deliberation.",
+  low: "Keep reasoning light; prefer a quick, concise solution.",
+  medium: "", // default behaviour — no directive
+  high: "Think carefully and thoroughly before answering; verify your work.",
+  max: "Use maximum rigor: explore edge cases, double-check assumptions, and verify the result before finishing.",
+};
+
+const LABEL: Record<ReasoningEffort, string> = {
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  max: "Max",
+};
+
+export function reasoningDirective(effort: ReasoningEffort): string {
+  return DIRECTIVE[effort] ?? "";
+}
+
+export function reasoningLabel(effort: ReasoningEffort): string {
+  return LABEL[effort] ?? effort;
+}

package/src/app/settings-store.ts

@@ -0,0 +1,38 @@
+/**
+ * Per-chat settings persistence (project, agent, model, reasoning, pinned
+ * status message id). Backed by a single JSON file so state survives restarts.
+ */
+import { join } from "node:path";
+import { JsonStore } from "./json-store.js";
+import { type ChatSettings, defaultSettings } from "./types.js";
+
+type SettingsMap = Record<string, ChatSettings>;
+
+export class SettingsStore {
+  private readonly store: JsonStore<SettingsMap>;
+
+  constructor(dataDir: string) {
+    this.store = new JsonStore<SettingsMap>(join(dataDir, "settings.json"), {});
+  }
+
+  get(chatId: number): ChatSettings {
+    const existing = this.store.get()[String(chatId)];
+    return existing ?? defaultSettings();
+  }
+
+  update(chatId: number, patch: Partial<ChatSettings>): ChatSettings {
+    const key = String(chatId);
+    const next = { ...this.get(chatId), ...patch };
+    this.store.update((m) => {
+      m[key] = next;
+    });
+    return next;
+  }
+
+  /** All chat ids that have interacted (for broadcast announcements). */
+  chatIds(): number[] {
+    return Object.keys(this.store.get())
+      .map(Number)
+      .filter((n) => Number.isFinite(n));
+  }
+}