grok-telegram-bot 2.3.0 → 2.4.0

package/src/import/list-running.ts

@@ -0,0 +1,100 @@
+/**
+ * List the sessions a sibling telegram-bot currently treats as /running
+ * (controlledSessions in its data/settings.json), enriched with on-disk meta
+ * and first-prompt titles when available.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { createLogger } from "../logger.js";
+import { type ForeignSessionMeta, resolveForeignMeta } from "./history-readers.js";
+import type { ImportSource } from "./sources.js";
+
+const log = createLogger("import:list");
+
+export interface ImportableSession extends ForeignSessionMeta {
+  /** Source tool id (kiro / opencode / …). */
+  sourceId: string;
+  /** True when listed from that bot's controlledSessions (/running). */
+  fromRunning: boolean;
+}
+
+interface RawControlled {
+  sessionId?: string;
+  projectPath?: string;
+  projectName?: string;
+}
+
+interface RawChatSettings {
+  controlledSessions?: RawControlled[];
+  sessionId?: string;
+  projectPath?: string;
+  projectName?: string;
+  foregroundSessionId?: string;
+}
+
+/**
+ * Sessions currently controlled by the source bot (its /running list).
+ * When `chatId` is set, prefer that chat's controlled list; otherwise union
+ * every chat's controlled sessions (deduped by session id).
+ */
+export function listRunningFromSource(
+  src: ImportSource,
+  chatId?: number,
+): ImportableSession[] {
+  const controlled = readControlled(src, chatId);
+  const out: ImportableSession[] = [];
+  const seen = new Set<string>();
+
+  for (const c of controlled) {
+    if (!c.sessionId || seen.has(c.sessionId)) continue;
+    seen.add(c.sessionId);
+    const meta = resolveForeignMeta(src.format, src.sessionsRoot, c.sessionId, {
+      cwd: c.projectPath,
+      projectName: c.projectName || (c.projectPath ? basename(c.projectPath) : undefined),
+    });
+    if (!meta.cwd && c.projectPath) meta.cwd = c.projectPath;
+    if (!meta.projectName) {
+      meta.projectName = c.projectName || (meta.cwd ? basename(meta.cwd) : undefined);
+    }
+    out.push({ ...meta, sourceId: src.id, fromRunning: true });
+  }
+
+  return out;
+}
+
+function readControlled(src: ImportSource, chatId?: number): RawControlled[] {
+  if (!existsSync(src.settingsPath)) {
+    log.warn(`settings missing for ${src.id}: ${src.settingsPath}`);
+    return [];
+  }
+  let raw: Record<string, RawChatSettings>;
+  try {
+    raw = JSON.parse(readFileSync(src.settingsPath, "utf-8")) as Record<string, RawChatSettings>;
+  } catch (e) {
+    log.warn(`cannot parse settings for ${src.id}:`, (e as Error).message);
+    return [];
+  }
+
+  const collect = (s: RawChatSettings | undefined): RawControlled[] => {
+    if (!s) return [];
+    const list = [...(s.controlledSessions ?? [])];
+    // Also include the single-session fields if controlledSessions is empty.
+    if (list.length === 0 && s.sessionId) {
+      list.push({
+        sessionId: s.sessionId,
+        projectPath: s.projectPath,
+        projectName: s.projectName,
+      });
+    }
+    return list;
+  };
+
+  if (chatId !== undefined) {
+    const key = String(chatId);
+    if (raw[key]) return collect(raw[key]);
+  }
+
+  const all: RawControlled[] = [];
+  for (const s of Object.values(raw)) all.push(...collect(s));
+  return all;
+}

package/src/import/sources.ts

@@ -0,0 +1,78 @@
+/**
+ * Foreign session sources that can be imported into Grok: the four sibling
+ * Telegram bots on this machine. Each source has a bot root (for settings /
+ * /running controlled sessions) and a tool session store (history on disk).
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export type ImportSourceId = "kiro" | "opencode" | "claude" | "codex";
+
+/** How history is stored for a source tool. */
+export type HistoryFormat = "acp-jsonl" | "codex-rollout" | "opencode-storage";
+
+export interface ImportSource {
+  id: ImportSourceId;
+  /** Short label shown in the source picker. */
+  label: string;
+  /** Absolute path to the sibling telegram-bot project root. */
+  botRoot: string;
+  /** Path to that bot's settings.json (holds controlledSessions /running). */
+  settingsPath: string;
+  /**
+   * Tool session store root:
+   *  - acp-jsonl: dir of `<id>.json` + `<id>.jsonl`
+   *  - codex-rollout: `$CODEX_HOME/sessions` tree of rollouts
+   *  - opencode-storage: `~/.local/share/opencode` (storage/ under it)
+   */
+  sessionsRoot: string;
+  format: HistoryFormat;
+}
+
+const DOMAINS = "H:\\Lucru\\Domains";
+
+/** Built-in import sources (fixed paths as requested). */
+export const IMPORT_SOURCES: readonly ImportSource[] = [
+  {
+    id: "kiro",
+    label: "Kiro",
+    botRoot: join(DOMAINS, "kiro-telegram-bot"),
+    settingsPath: join(DOMAINS, "kiro-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".kiro", "sessions", "cli"),
+    format: "acp-jsonl",
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    botRoot: join(DOMAINS, "opencode-telegram-bot"),
+    settingsPath: join(DOMAINS, "opencode-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".local", "share", "opencode"),
+    format: "opencode-storage",
+  },
+  {
+    id: "claude",
+    label: "Claude",
+    botRoot: join(DOMAINS, "claude-telegram-bot"),
+    settingsPath: join(DOMAINS, "claude-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(DOMAINS, "claude-telegram-bot", "data", "sessions"),
+    format: "acp-jsonl",
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    botRoot: join(DOMAINS, "codex-telegram-bot"),
+    settingsPath: join(DOMAINS, "codex-telegram-bot", "data", "settings.json"),
+    sessionsRoot: join(homedir(), ".codex", "sessions"),
+    format: "codex-rollout",
+  },
+] as const;
+
+export function getImportSource(id: string): ImportSource | undefined {
+  return IMPORT_SOURCES.find((s) => s.id === id);
+}
+
+/** True when the bot root exists on disk. */
+export function sourceAvailable(src: ImportSource): boolean {
+  return existsSync(src.botRoot);
+}

package/src/index.ts

@@ -2,12 +2,21 @@
  * Grok Telegram Bot — entry point.
  * Starts the Grok ACP bridge (`grok agent stdio`), the Telegram bot, and wires
  * graceful shutdown between them.
+ *
+ * Lifetime rules (critical):
+ *  - Prefer staying up over clean-but-dead exits.
+ *  - Uncaught errors are logged; the process keeps polling Telegram.
+ *  - grammY long-poll is restarted on transport/network death.
+ *  - Supervised launches (GROK_TG_SUPERVISED=1 / service) may exit for relaunch;
+ *    bare/manual runs re-exec when possible rather than dying silently.
  */
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import type { Bot } from "grammy";
 import { GrokClient } from "./grok/client.js";
 import { createBot } from "./bot/bot.js";
-import { CANONICAL_DIR, loadConfig } from "./config.js";
+import { CANONICAL_DIR, INSTANCE_DIR, loadConfig } from "./config.js";
 import { InstanceLock } from "./app/instance-lock.js";
-import { join } from "node:path";
 import { createLogger, enableFileLogging, setLogLevel } from "./logger.js";
 
 async function main(): Promise<void> {
@@ -21,9 +30,10 @@ async function main(): Promise<void> {
   // Single-instance guard: kill any ghost/duplicate already polling this token.
   const lock = new InstanceLock(cfg.token, join(CANONICAL_DIR, "locks"), process.env.GROK_TG_SUPERVISED === "1");
   if (cfg.singleInstance && !(await lock.acquire())) {
-    process.stdout.write(
-      "\u26D4 Another Grok Telegram Bot is already running for this token (a background service). Use `grok-tg restart`, or `grok-tg stop` first.\n",
-    );
+    const msg =
+      "Another Grok Telegram Bot is already running for this token (a background service). Use `grok-tg restart`, or `grok-tg stop` first.";
+    log.warn(msg);
+    process.stdout.write(`\u26D4 ${msg}\n`);
     process.exit(0);
   }
 
@@ -33,6 +43,19 @@ async function main(): Promise<void> {
   log.info(`sessions:  ${cfg.sessionsDir}`);
   log.info(`log file:  ${cfg.logFile}`);
 
+  // Never die silently from stray exceptions — a dead bot is worse than a
+  // partially inconsistent one. Registering these handlers overrides Node's
+  // default "print and exit" for uncaughtException.
+  process.on("uncaughtException", (err) => {
+    log.error("uncaughtException (process stays up):", err);
+  });
+  process.on("unhandledRejection", (reason) => {
+    log.error(
+      "unhandledRejection (process stays up):",
+      reason instanceof Error ? reason : String(reason),
+    );
+  });
+
   const grok = new GrokClient({
     grokCliPath: cfg.grokCliPath,
     workspace: cfg.workspace,
@@ -44,20 +67,62 @@ async function main(): Promise<void> {
     promptIdleTimeoutMs: cfg.promptIdleMs,
   });
 
-  await grok.start();
-  const { bot, registry, scheduler, updater } = await createBot(cfg, grok);
-  scheduler.start();
-  await updater.start();
+  // Retry ACP connect — agent crash at boot should not kill the Telegram bot.
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await grok.start();
+      break;
+    } catch (e) {
+      const wait = Math.min(60_000, 1000 * 2 ** Math.min(attempt, 5));
+      log.error(`Grok ACP start failed (attempt ${attempt}): ${(e as Error).message}; retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  }
+
+  // createBot can fail on transient Telegram API issues — retry rather than die.
+  let bot: Bot;
+  let registry: Awaited<ReturnType<typeof createBot>>["registry"];
+  let scheduler: Awaited<ReturnType<typeof createBot>>["scheduler"];
+  let updater: Awaited<ReturnType<typeof createBot>>["updater"];
+  for (let attempt = 1; ; attempt++) {
+    try {
+      const bundle = await createBot(cfg, grok);
+      bot = bundle.bot;
+      registry = bundle.registry;
+      scheduler = bundle.scheduler;
+      updater = bundle.updater;
+      break;
+    } catch (e) {
+      const wait = Math.min(60_000, 1000 * 2 ** Math.min(attempt, 5));
+      log.error(`createBot failed (attempt ${attempt}): ${(e as Error).message}; retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  }
+
+  scheduler!.start();
+  await updater!.start();
 
   let shuttingDown = false;
   const shutdown = (code: number): void => {
     if (shuttingDown) return;
     shuttingDown = true;
     log.info("shutting down…");
-    scheduler.stop();
-    updater.stop();
-    registry.disposeAll();
-    void bot.stop().catch(() => {});
+    try {
+      scheduler!.stop();
+    } catch {
+      /* ignore */
+    }
+    try {
+      updater!.stop();
+    } catch {
+      /* ignore */
+    }
+    try {
+      registry!.disposeAll();
+    } catch {
+      /* ignore */
+    }
+    void bot!.stop().catch(() => {});
     grok.stop();
     lock.release();
     setTimeout(() => process.exit(code), 500);
@@ -67,18 +132,108 @@ async function main(): Promise<void> {
 
   process.on("SIGINT", () => shutdown(0));
   process.on("SIGTERM", () => shutdown(0));
-  process.on("uncaughtException", (err) => log.error("uncaughtException:", err));
-  process.on("unhandledRejection", (err) => log.error("unhandledRejection:", err));
-
-  await bot.start({
-    onStart: (info) => {
-      log.info(`bot online as @${info.username}`);
-      process.stdout.write(`\u2705 Online as @${info.username}. Send it a message on Telegram.\n`);
-    },
-  });
+
+  // Refresh the single-instance lock periodically so a long-running process
+  // stays clearly "alive" on disk (start time + pid).
+  const lockHeartbeat = setInterval(() => {
+    try {
+      if (!shuttingDown) lock.touch();
+    } catch {
+      /* non-fatal */
+    }
+  }, 60_000);
+  lockHeartbeat.unref?.();
+
+  // Keep long-polling forever. On network / 409 / grammY fatal, wait and restart
+  // the poller instead of ending the process (silent death was a critical bug).
+  // If the inner loop still returns without shutdown, attempt self-relaunch; if
+  // that fails, resume polling rather than dying.
+  while (!shuttingDown) {
+    await runPollingForever(bot!, log, () => shuttingDown);
+    if (shuttingDown) break;
+    log.error("Telegram polling loop exited unexpectedly; attempting self-relaunch");
+    const replaced = await selfRelaunch(cfg.projectRoot, log);
+    if (replaced) {
+      clearInterval(lockHeartbeat);
+      shutdown(1);
+      return;
+    }
+    log.error("self-relaunch failed; resuming Telegram polling in 5s");
+    await sleep(5000);
+  }
+  clearInterval(lockHeartbeat);
+}
+
+/** grammY start with automatic recovery. */
+async function runPollingForever(
+  bot: Bot,
+  log: ReturnType<typeof createLogger>,
+  isShuttingDown: () => boolean,
+): Promise<void> {
+  let attempt = 0;
+  while (!isShuttingDown()) {
+    try {
+      attempt = 0;
+      await bot.start({
+        onStart: (info) => {
+          log.info(`bot online as @${info.username}`);
+          process.stdout.write(`\u2705 Online as @${info.username}. Send it a message on Telegram.\n`);
+        },
+      });
+      // bot.start resolves when polling is stopped (bot.stop).
+      if (isShuttingDown()) return;
+      log.warn("bot.start resolved without shutdown; restarting polling in 2s");
+      await sleep(2000);
+    } catch (e) {
+      attempt++;
+      const wait = Math.min(60_000, 2000 * 2 ** Math.min(attempt, 5));
+      log.error(
+        `Telegram polling failed (attempt ${attempt}): ${(e as Error).message}; retry in ${wait}ms`,
+      );
+      try {
+        await bot.stop();
+      } catch {
+        /* ignore */
+      }
+      await sleep(wait);
+    }
+  }
+}
+
+/**
+ * Spawn a fresh bot process then let the caller exit (manual / non-supervised).
+ * Returns true when a replacement was started (or supervised exit is expected).
+ */
+async function selfRelaunch(projectRoot: string, log: ReturnType<typeof createLogger>): Promise<boolean> {
+  if (process.env.GROK_TG_SUPERVISED === "1") {
+    log.info("supervised mode — exiting for external relaunch");
+    return true;
+  }
+  try {
+    const child = spawn(
+      process.execPath,
+      ["--import", "tsx", join(projectRoot, "src", "index.ts"), "--instance", INSTANCE_DIR],
+      { detached: true, stdio: "ignore", cwd: projectRoot, env: process.env },
+    );
+    child.unref();
+    if (!child.pid) {
+      log.error("self-relaunch spawn produced no pid — staying alive");
+      return false;
+    }
+    log.info(`spawned replacement pid ${child.pid}`);
+    return true;
+  } catch (e) {
+    log.error(`self-relaunch failed: ${(e as Error).message} — staying alive`);
+    return false;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
 }
 
 main().catch((err) => {
-  console.error("Fatal:", err instanceof Error ? err.message : err);
-  process.exit(1);
+  console.error("Fatal:", err instanceof Error ? err.stack || err.message : err);
+  // Delay exit so logs flush; VBS restart loop / supervisor can bring us back.
+  setTimeout(() => process.exit(1), 1000);
 });

package/src/render/diff.ts

@@ -38,11 +38,20 @@ export function renderUnifiedDiff(input: DiffInput): DiffResult {
   }
   if (lines.length === 0) return { block: "", added, removed };
 
+  // Display-only: keep head + tail so long edits still show both the start and
+  // the end of the change. Full content remains in the agent session context.
   let shown = lines;
   let note = "";
   if (lines.length > input.maxLines) {
-    shown = lines.slice(0, input.maxLines);
-    note = `\n… +${lines.length - input.maxLines} more lines`;
+    const headN = Math.max(1, Math.floor(input.maxLines * 0.45));
+    const tailN = Math.max(1, input.maxLines - headN);
+    const omitted = lines.length - headN - tailN;
+    shown = [
+      ...lines.slice(0, headN),
+      `… (${omitted} lines omitted) …`,
+      ...lines.slice(lines.length - tailN),
+    ];
+    note = "";
   }
   return { block: "```diff\n" + shown.join("\n") + note + "\n```", added, removed };
 }

package/src/render/file-summary.ts

@@ -25,7 +25,14 @@ export function fileOpFromUpdate(u: SessionUpdate): { path: string; op: FileOp }
   const raw = (u.rawInput || {}) as Record<string, unknown>;
   const diff = findDiff(u);
   const path =
-    str(diff?.path) || str(raw.path) || str(raw.file_path) || str(raw.filename) || pathFromTitle(u.title);
+    str(diff?.path) ||
+    str(raw.path) ||
+    str(raw.file_path) ||
+    str(raw.filePath) ||
+    str(raw.target_file) ||
+    str(raw.targetFile) ||
+    str(raw.filename) ||
+    pathFromTitle(u.title);
   if (!path) return undefined;
 
   if (kind === "delete") return { path, op: "deleted" };
@@ -71,6 +78,29 @@ export function summarizeFileOpsShort(ops: Map<string, FileOp>): string {
   return ops.size === 0 ? "\u{1F4C4} No files modified" : `\u{1F4DD} ${countsLine(ops)}`;
 }
 
+/**
+ * Split Done body: first-turn edits vs self-recheck edits (when a recheck ran).
+ * Each section uses the same compact list format as {@link summarizeFileOps}.
+ */
+export function summarizeFileOpsSplit(
+  firstTurn: Map<string, FileOp>,
+  recheck: Map<string, FileOp>,
+  cwd: string,
+  maxList = 15,
+): string {
+  const a = summarizeFileOps(firstTurn, cwd, maxList);
+  const b = summarizeFileOps(recheck, cwd, maxList);
+  return (
+    `\u{1F4C1} After first turn\n${a}` +
+    `\n\n\u{1F50D} After self-recheck\n${b}`
+  );
+}
+
+/** Clone a file-ops map (for freezing first-turn edits before recheck). */
+export function cloneFileOps(ops: Map<string, FileOp>): Map<string, FileOp> {
+  return new Map(ops);
+}
+
 /** "+2 created · ~3 edited · −1 deleted" — only the non-zero buckets. */
 function countsLine(ops: Map<string, FileOp>): string {
   const counts: Record<FileOp, number> = { created: 0, edited: 0, deleted: 0, moved: 0 };