grok-telegram-bot 2.0.0

package/src/app/stt.ts

@@ -0,0 +1,53 @@
+/**
+ * Speech-to-text via any OpenAI/Whisper-compatible endpoint.
+ *
+ * Language handling: when STT_LANGUAGE is unset, Whisper auto-detects the
+ * spoken language (covers English, Russian, Romanian/Moldovan, and ~100 more),
+ * so multilingual voice notes work out of the box.
+ */
+import { createLogger } from "../logger.js";
+
+const log = createLogger("stt");
+
+export interface SttConfig {
+  apiUrl?: string;
+  apiKey?: string;
+  model: string;
+  language?: string;
+}
+
+export class SttService {
+  constructor(private readonly cfg: SttConfig) {}
+
+  get enabled(): boolean {
+    return Boolean(this.cfg.apiUrl);
+  }
+
+  /** Transcribe audio bytes; returns the recognized text (may be empty). */
+  async transcribe(bytes: Buffer, mimeType: string, filename: string): Promise<string> {
+    if (!this.cfg.apiUrl) throw new Error("STT is not configured (set STT_API_URL).");
+    const url = endpoint(this.cfg.apiUrl);
+
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(bytes)], { type: mimeType }), filename);
+    form.append("model", this.cfg.model);
+    if (this.cfg.language) form.append("language", this.cfg.language);
+
+    const headers: Record<string, string> = {};
+    if (this.cfg.apiKey) headers.Authorization = `Bearer ${this.cfg.apiKey}`;
+
+    const res = await fetch(url, { method: "POST", headers, body: form });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(`STT HTTP ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const data = (await res.json()) as { text?: string };
+    log.debug("transcribed", (data.text ?? "").length, "chars");
+    return (data.text ?? "").trim();
+  }
+}
+
+function endpoint(base: string): string {
+  const b = base.replace(/\/$/, "");
+  return b.endsWith("/audio/transcriptions") ? b : `${b}/audio/transcriptions`;
+}

package/src/app/types.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared application types: per-chat settings, reasoning levels, and the
+ * prompt input model (text plus optional images) used across the bot.
+ */
+
+export const REASONING_LEVELS = ["minimal", "low", "medium", "high", "max"] as const;
+export type ReasoningEffort = (typeof REASONING_LEVELS)[number];
+
+export interface ChatSettings {
+  projectPath?: string;
+  projectName?: string;
+  sessionId?: string;
+  agent?: string;
+  model?: string;
+  reasoning: ReasoningEffort;
+  /** Telegram message id of the pinned status panel, if any. */
+  statusMessageId?: number;
+  /** Sessions this chat controls (for multi-session switching). */
+  controlledSessions?: ControlledSession[];
+  /** Which controlled session is currently in the foreground. */
+  foregroundSessionId?: string;
+}
+
+export interface ControlledSession {
+  sessionId?: string;
+  projectPath: string;
+  projectName?: string;
+}
+
+export function defaultSettings(): ChatSettings {
+  return { reasoning: "medium" };
+}
+
+/** A decoded image to attach to a prompt as an ACP image content block. */
+export interface PromptImage {
+  data: string; // base64-encoded bytes
+  mimeType: string;
+}
+
+/** A unit of work submitted to the agent: text plus optional images. */
+export interface PromptInput {
+  text: string;
+  images: PromptImage[];
+  /** Telegram message id of the prompt, so the reply threads to it. */
+  replyTo?: number;
+  /**
+   * Content of the message the user was replying to (or the portion they
+   * quoted). Injected as context so the agent sees what the user is responding
+   * to. See {@link ../bot/reply-context.ts}.
+   */
+  quotedText?: string;
+}
+
+export function textPrompt(text: string, replyTo?: number, quotedText?: string): PromptInput {
+  return { text, images: [], replyTo, quotedText };
+}

package/src/app/updater.ts

@@ -0,0 +1,234 @@
+/**
+ * Auto-updater — once an hour, asks npm for the latest published version with a
+ * single lightweight request. When a newer version exists AND the bot is fully
+ * idle (no in-flight prompt, no other active Grok session on the PC), it
+ * announces in chat, runs `npm install -g grok-telegram-bot@<latest>`, and
+ * restarts to apply. After the restart it posts the new version's CHANGELOG
+ * (tagged #update) so every release is easy to find in the conversation.
+ *
+ * Safety:
+ *   • only ever updates when idle — never interrupts a running turn/task;
+ *   • only for a global npm install (a cloned/source checkout is left alone);
+ *   • restart is supervisor-aware: under systemd/launchd it exits cleanly and
+ *     lets the supervisor relaunch; on Windows / foreground it re-execs itself.
+ */
+import { spawn } from "node:child_process";
+import { get } from "node:https";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { JsonStore } from "./json-store.js";
+import { createLogger } from "../logger.js";
+import { extractChangelog, isNewer, isSafeVersion } from "./version.js";
+
+const log = createLogger("updater");
+const PKG = "grok-telegram-bot";
+
+interface PendingUpdate {
+  from: string;
+  to: string;
+  chats: number[];
+}
+
+export interface UpdaterOptions {
+  enabled: boolean;
+  intervalMs: number;
+  projectRoot: string;
+  instanceDir: string;
+  dataDir: string;
+  /** True while the agent is busy (a chat turn or scheduled task). */
+  isPromptInFlight: () => boolean;
+  /** Active Grok sessions on this PC NOT owned by the bot's own agent. */
+  otherActiveSessions: () => number;
+  /** Send a plain or markdown message to every chat. */
+  announce: (text: string, markdown: boolean) => Promise<void>;
+  /** Stop polling + the agent before the process exits/re-execs. */
+  shutdown: () => Promise<void>;
+}
+
+export class Updater {
+  private timer: NodeJS.Timeout | undefined;
+  private readonly state: JsonStore<PendingUpdate | null>;
+  private readonly current: string;
+  private attempting = false;
+  private readonly tried = new Set<string>();
+
+  constructor(private readonly opts: UpdaterOptions) {
+    this.state = new JsonStore<PendingUpdate | null>(join(opts.dataDir, "update-state.json"), null);
+    this.current = readVersion(opts.projectRoot);
+  }
+
+  /** Announce a just-applied update (if any), then begin hourly checks. */
+  async start(): Promise<void> {
+    await this.announcePending();
+    if (!this.opts.enabled) {
+      log.info("auto-update disabled (AUTO_UPDATE=false)");
+      return;
+    }
+    if (!this.isNpmInstall()) {
+      log.info("running from source — auto-update is a no-op (use git to update)");
+      return;
+    }
+    // First check shortly after boot, then on the configured interval.
+    this.timer = setTimeout(() => void this.tick(), 60_000);
+  }
+
+  stop(): void {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+
+  private schedule(): void {
+    this.timer = setTimeout(() => void this.tick(), this.opts.intervalMs);
+  }
+
+  private async tick(): Promise<void> {
+    try {
+      await this.checkAndUpdate();
+    } catch (e) {
+      log.debug("update check failed:", (e as Error).message);
+    } finally {
+      this.schedule();
+    }
+  }
+
+  private async checkAndUpdate(): Promise<void> {
+    if (this.attempting) return;
+    const latest = await fetchLatestVersion();
+    if (!latest || !isSafeVersion(latest)) return;
+    if (!isNewer(latest, this.current)) return;
+    if (this.tried.has(latest)) return; // don't loop on a version we already tried
+
+    if (this.opts.isPromptInFlight() || this.opts.otherActiveSessions() > 0) {
+      log.info(`update ${this.current} -> ${latest} available; waiting for idle`);
+      return; // re-evaluated next interval
+    }
+    await this.applyUpdate(latest);
+  }
+
+  private async applyUpdate(latest: string): Promise<void> {
+    this.attempting = true;
+    this.tried.add(latest);
+    log.info(`updating ${this.current} -> ${latest}`);
+    await this.opts.announce(
+      `\u{1F504} #update Updating ${PKG} v${this.current} \u2192 v${latest}\u2026\nThe bot is idle, so it's safe \u2014 it will restart and report what changed.`,
+      false,
+    );
+
+    const ok = await npmInstall(latest);
+    if (!ok) {
+      this.attempting = false;
+      await this.opts.announce(
+        `\u26A0\uFE0F #update Update to v${latest} failed (\`npm install -g\`). I'll try again after the next restart.`,
+        false,
+      );
+      return;
+    }
+
+    this.state.set({ from: this.current, to: latest, chats: this.announceChats() });
+    await this.restart();
+  }
+
+  /** After a restart, post the new version's changelog (once), tagged #update. */
+  private async announcePending(): Promise<void> {
+    const pending = this.state.get();
+    if (!pending) return;
+    this.state.set(null); // consume regardless, so we never re-announce
+    if (pending.to !== this.current) {
+      log.warn(`pending update to ${pending.to} but running ${this.current}; skipping announce`);
+      return;
+    }
+    const notes = this.changelogFor(pending.to);
+    const body = notes
+      ? `\u{1F680} #update Updated v${pending.from} \u2192 **v${pending.to}**\n\n${notes}`
+      : `\u{1F680} #update Updated to **v${pending.to}**.`;
+    await this.opts.announce(body, true);
+  }
+
+  private async restart(): Promise<void> {
+    await this.opts.shutdown().catch(() => {});
+    // Under systemd/launchd, a clean exit triggers a managed relaunch (no double
+    // instance). On Windows / foreground there is no supervisor, so re-exec.
+    if (process.env.GROK_TG_SUPERVISED === "1") {
+      log.info("exiting for supervisor to relaunch the updated bot");
+      setTimeout(() => process.exit(0), 250);
+      return;
+    }
+    log.info("re-executing the updated bot");
+    const child = spawn(
+      process.execPath,
+      ["--import", "tsx", join(this.opts.projectRoot, "src", "index.ts"), "--instance", this.opts.instanceDir],
+      { detached: true, stdio: "ignore", cwd: this.opts.projectRoot, env: process.env },
+    );
+    child.unref();
+    setTimeout(() => process.exit(0), 500);
+  }
+
+  private isNpmInstall(): boolean {
+    return this.opts.projectRoot.replace(/\\/g, "/").includes("/node_modules/");
+  }
+
+  private announceChats(): number[] {
+    const pending = this.state.get();
+    return pending?.chats ?? [];
+  }
+
+  private changelogFor(version: string): string {
+    try {
+      const md = readFileSync(join(this.opts.projectRoot, "CHANGELOG.md"), "utf-8");
+      return extractChangelog(md, version);
+    } catch {
+      return "";
+    }
+  }
+}
+
+/** Read the installed version from package.json (falls back to "0.0.0"). */
+function readVersion(projectRoot: string): string {
+  try {
+    return (JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8")) as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+/** One small HTTPS GET to the npm registry's dist-tag manifest for `latest`. */
+function fetchLatestVersion(): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const req = get(
+      `https://registry.npmjs.org/${PKG}/latest`,
+      { timeout: 10_000, headers: { Accept: "application/json" } },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(undefined);
+          return;
+        }
+        let body = "";
+        res.setEncoding("utf-8");
+        res.on("data", (c) => (body += c));
+        res.on("end", () => {
+          try {
+            resolve((JSON.parse(body) as { version?: string }).version);
+          } catch {
+            resolve(undefined);
+          }
+        });
+      },
+    );
+    req.on("error", () => resolve(undefined));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(undefined);
+    });
+  });
+}
+
+/** Run `npm install -g grok-telegram-bot@<version>`; resolves true on success. */
+function npmInstall(version: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn(npm, ["install", "-g", `${PKG}@${version}`], { stdio: "ignore" });
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+}

package/src/app/usage.ts

@@ -0,0 +1,38 @@
+/**
+ * Account info for Grok Build. Grok signs in with your xAI account
+ * (`grok login`), so /usage surfaces the signed-in identity (from the token in
+ * ~/.grok/auth.json) plus the live per-session context usage the ACP agent
+ * reports.
+ */
+import { hasLogin, identityFromAuth, loginLabel } from "./grok-credentials.js";
+
+export interface AccountInfo {
+  /** Signed-in identity (email when the token carries one, else a label). */
+  email?: string;
+  /** Subscription/plan, when known. */
+  accountType?: string;
+  region?: string;
+  /** Stable identifier for matching saved accounts. */
+  startUrl?: string;
+}
+
+export class UsageService {
+  // Kept for signature compatibility; Grok state lives in ~/.grok/auth.json.
+  constructor(private readonly grokCliPath: string) {}
+
+  async account(): Promise<AccountInfo | undefined> {
+    if (!hasLogin()) {
+      // XAI_API_KEY with no browser login still counts as usable.
+      if (process.env.XAI_API_KEY?.trim()) return { email: "XAI_API_KEY", accountType: "api key" };
+      return undefined;
+    }
+    const id = identityFromAuth();
+    const label = loginLabel();
+    return { email: id.email || label, accountType: undefined, startUrl: label };
+  }
+
+  /** Whether Grok has a usable sign-in (browser token or XAI_API_KEY). */
+  async isLoggedIn(): Promise<boolean> {
+    return hasLogin();
+  }
+}

package/src/app/version.ts

@@ -0,0 +1,41 @@
+/**
+ * Tiny semver helpers + CHANGELOG section extraction for the auto-updater.
+ * Pure and dependency-free so they're easy to test.
+ */
+
+/** Parse the leading "X.Y.Z" of a version string (ignores pre-release tags). */
+export function parseSemver(v: string): [number, number, number] {
+  const m = /^\s*v?(\d+)\.(\d+)\.(\d+)/.exec(v);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : [0, 0, 0];
+}
+
+/** True when `latest` is strictly greater than `current` (by major/minor/patch). */
+export function isNewer(latest: string, current: string): boolean {
+  const a = parseSemver(latest);
+  const b = parseSemver(current);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i]! > b[i]!;
+  }
+  return false;
+}
+
+/** A version string is a plain semver we'd trust to pass to `npm install`. */
+export function isSafeVersion(v: string): boolean {
+  return /^\d+\.\d+\.\d+(?:[-.][0-9A-Za-z.-]+)?$/.test(v);
+}
+
+/** Extract the body of a CHANGELOG `## [version] …` section (markdown). */
+export function extractChangelog(md: string, version: string): string {
+  const head = new RegExp(`^##\\s*\\[${version.replace(/\./g, "\\.")}\\]`);
+  const out: string[] = [];
+  let capturing = false;
+  for (const line of md.split("\n")) {
+    if (capturing && /^##\s*\[/.test(line)) break;
+    if (capturing) {
+      out.push(line);
+      continue;
+    }
+    if (head.test(line)) capturing = true;
+  }
+  return out.join("\n").trim();
+}

package/src/bot/account-rotator.ts

@@ -0,0 +1,52 @@
+/**
+ * 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();
+  }
+}

package/src/bot/auth.ts

@@ -0,0 +1,38 @@
+/**
+ * Authorization middleware: restricts the bot to ALLOWED_USERS when configured.
+ */
+import type { Context, NextFunction } from "grammy";
+import type { AppConfig } from "../config.js";
+import { createLogger } from "../logger.js";
+
+const log = createLogger("auth");
+
+export function createAuthMiddleware(cfg: AppConfig) {
+  const allowAll = cfg.allowedUsers.size === 0;
+  if (allowAll) {
+    log.warn("ALLOWED_USERS is empty — the bot will respond to ANY Telegram user.");
+  }
+
+  return async (ctx: Context, next: NextFunction): Promise<void> => {
+    const from = ctx.from;
+    // Only a genuine USER action is subject to (and worth replying to) the auth
+    // gate. Ignore everything else silently — most importantly the bot's OWN
+    // updates: the status panel being pinned/unpinned emits a service message
+    // whose `from` is THIS bot (is_bot), and replying "⛔ Not authorized" to
+    // that (or to any service/no-`from` update) spammed the chat with false
+    // rejections. Real unauthorized users still get one clear reply below.
+    if (!from || from.is_bot) return;
+    const m = ctx.message ?? ctx.editedMessage;
+    if (m && (m.pinned_message || m.new_chat_members || m.left_chat_member)) return;
+
+    const userId = String(from.id);
+    if (allowAll || cfg.allowedUsers.has(userId)) {
+      await next();
+      return;
+    }
+    log.warn(`blocked unauthorized user ${userId}`);
+    if (ctx.chat) {
+      await ctx.reply("\u26D4 Not authorized. Ask the bot owner to add your Telegram ID.");
+    }
+  };
+}