grok-telegram-bot 2.0.0

package/src/sessions/store.ts

@@ -0,0 +1,133 @@
+/**
+ * Session store — reads ~/.grok/sessions/cli to discover existing Grok CLI
+ * sessions, sorts them by recency, and detects which ones are currently
+ * running on this PC (a .lock file whose PID is alive).
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "../logger.js";
+import type { SessionMeta } from "./types.js";
+
+const log = createLogger("sessions:store");
+
+interface RawSessionJson {
+  session_id?: string;
+  cwd?: string;
+  title?: string;
+  created_at?: string;
+  updated_at?: string;
+  session_created_reason?: string;
+}
+
+interface RawLock {
+  pid?: number;
+  started_at?: string;
+}
+
+export class SessionStore {
+  constructor(private readonly dir: string) {}
+
+  /** Returns true once the sessions directory exists. */
+  available(): boolean {
+    try {
+      return statSync(this.dir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /** List all sessions, most recently updated first. */
+  list(limit = 50): SessionMeta[] {
+    if (!this.available()) return [];
+    let files: string[];
+    try {
+      files = readdirSync(this.dir).filter((f) => f.endsWith(".json"));
+    } catch (e) {
+      log.warn("cannot read sessions dir:", (e as Error).message);
+      return [];
+    }
+
+    const metas: SessionMeta[] = [];
+    for (const file of files) {
+      const meta = this.readMeta(file);
+      if (meta) metas.push(meta);
+    }
+    // Active sessions first, then most-recently-updated.
+    metas.sort(
+      (a, b) => Number(b.active) - Number(a.active) || b.updatedAt.localeCompare(a.updatedAt),
+    );
+    return metas.slice(0, limit);
+  }
+
+  /** List only sessions currently running on this PC. */
+  listActive(): SessionMeta[] {
+    return this.list(200).filter((s) => s.active);
+  }
+
+  get(sessionId: string): SessionMeta | undefined {
+    return this.readMeta(`${sessionId}.json`);
+  }
+
+  jsonlPath(sessionId: string): string {
+    return join(this.dir, `${sessionId}.jsonl`);
+  }
+
+  private readMeta(file: string): SessionMeta | undefined {
+    const full = join(this.dir, file);
+    let raw: RawSessionJson;
+    let mtime = new Date(0).toISOString();
+    try {
+      raw = JSON.parse(readFileSync(full, "utf-8")) as RawSessionJson;
+      mtime = statSync(full).mtime.toISOString();
+    } catch {
+      return undefined;
+    }
+    const sessionId = raw.session_id || file.replace(/\.json$/, "");
+    const base = sessionId;
+
+    const { lockPid, active } = this.checkLock(base);
+    let historyBytes = 0;
+    try {
+      historyBytes = statSync(join(this.dir, `${base}.jsonl`)).size;
+    } catch {
+      /* no history yet */
+    }
+
+    return {
+      sessionId,
+      cwd: raw.cwd || "",
+      title: (raw.title || "").trim() || "(untitled)",
+      createdAt: raw.created_at || mtime,
+      updatedAt: raw.updated_at || mtime,
+      reason: raw.session_created_reason,
+      lockPid,
+      active,
+      historyBytes,
+    };
+  }
+
+  private checkLock(base: string): { lockPid?: number; active: boolean } {
+    try {
+      const lock = JSON.parse(readFileSync(join(this.dir, `${base}.lock`), "utf-8")) as RawLock;
+      if (typeof lock.pid === "number") {
+        return { lockPid: lock.pid, active: isPidAlive(lock.pid) };
+      }
+    } catch {
+      /* no lock => not active */
+    }
+    return { active: false };
+  }
+}
+
+/** Cross-platform "is this process still running?" check. */
+export function isPidAlive(pid: number): boolean {
+  if (!pid || pid <= 0) return false;
+  try {
+    // Signal 0 does not kill; it only checks for existence/permission.
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM means the process exists but we can't signal it => still alive.
+    return (e as NodeJS.ErrnoException).code === "EPERM";
+  }
+}

package/src/sessions/tail.ts

@@ -0,0 +1,86 @@
+/**
+ * TailWatcher — follows a session's .jsonl event log and emits newly appended
+ * entries. Polling (not fs.watch) is used because it is reliable for appends
+ * across platforms and network drives.
+ */
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { createLogger } from "../logger.js";
+import { parseEventLine } from "./history.js";
+import type { HistoryEntry } from "./types.js";
+
+const log = createLogger("sessions:tail");
+
+export class TailWatcher {
+  private pos = 0;
+  private remainder = "";
+  private timer: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly path: string,
+    private readonly onEntries: (entries: HistoryEntry[]) => void,
+    private readonly intervalMs = 1500,
+  ) {}
+
+  /** Start watching. From the current end of file by default (only new events). */
+  start(fromEnd = true): void {
+    if (this.timer) return;
+    try {
+      this.pos = fromEnd ? statSync(this.path).size : 0;
+    } catch {
+      this.pos = 0;
+    }
+    this.timer = setInterval(() => this.poll(), this.intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  get running(): boolean {
+    return this.timer !== undefined;
+  }
+
+  private poll(): void {
+    let size: number;
+    try {
+      size = statSync(this.path).size;
+    } catch {
+      return;
+    }
+    if (size === this.pos) return;
+    if (size < this.pos) {
+      // File rotated/truncated — restart from the beginning.
+      this.pos = 0;
+      this.remainder = "";
+    }
+
+    const length = size - this.pos;
+    let chunk = "";
+    const fd = openSync(this.path, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      readSync(fd, buf, 0, length, this.pos);
+      chunk = buf.toString("utf-8");
+    } catch (e) {
+      log.debug("tail read failed:", (e as Error).message);
+      return;
+    } finally {
+      closeSync(fd);
+    }
+    this.pos = size;
+
+    const text = this.remainder + chunk;
+    const lines = text.split("\n");
+    this.remainder = lines.pop() ?? ""; // keep last partial line
+
+    const entries: HistoryEntry[] = [];
+    for (const line of lines) {
+      const entry = parseEventLine(line);
+      if (entry) entries.push(entry);
+    }
+    if (entries.length > 0) this.onEntries(entries);
+  }
+}

package/src/sessions/types.ts

@@ -0,0 +1,26 @@
+/** Types for discovered Grok CLI sessions on disk. */
+
+export interface SessionMeta {
+  sessionId: string;
+  cwd: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  reason?: string;
+  /** PID holding the .lock file, if any. */
+  lockPid?: number;
+  /** True when lockPid refers to a live process => running on this PC. */
+  active: boolean;
+  /** Size of the .jsonl history in bytes (proxy for conversation length). */
+  historyBytes: number;
+}
+
+export type HistoryRole = "user" | "assistant" | "tool" | "system";
+
+export interface HistoryEntry {
+  role: HistoryRole;
+  text: string;
+  /** Optional tool name for tool entries. */
+  tool?: string;
+  timestamp?: number;
+}

package/src/stream/streamer.ts

@@ -0,0 +1,261 @@
+/**
+ * ResponseStreamer — renders a whole agent turn into as FEW Telegram messages as
+ * possible, edited at most once per throttle window (anti-spam, avoids 429s).
+ *
+ * The turn is modelled as ordered segments so the transcript reads clearly:
+ *   • plain prose      = the agent talking to you
+ *   • > 💭 quoted block = the agent's thinking
+ *   • 🔧 + code block   = tool calls / terminal commands / diffs
+ *
+ * A single "live" message is edited as content grows; only when it would exceed
+ * Telegram's size limit is it sealed and a new live message started.
+ */
+import type { Api } from "grammy";
+import { chunkMarkdown } from "../render/chunk.js";
+import { toTelegramMarkdown } from "../render/markdown.js";
+import { extractProgress, progressBar } from "../render/progress.js";
+import { estimateProgress } from "../render/progress-estimate.js";
+import { safeEdit, safeSend } from "../bot/telegram-io.js";
+
+const SOFT_LIMIT = 3500;
+const THINK_TAIL = 500;
+
+type SegKind = "out" | "think" | "tool";
+interface Seg {
+  kind: SegKind;
+  text: string;
+}
+
+export class ResponseStreamer {
+  private readonly segs: Seg[] = [];
+  private sealedIdx = 0;
+  private liveId: number | undefined;
+  private timer: NodeJS.Timeout | undefined;
+  private dirty = false;
+  private flushing = false;
+  private closed = false;
+  /** Latest task-progress % parsed from the agent's `{progress: N%}` markers
+   *  (sticky across flushes; rendered as a bar on the live message). */
+  private progress: number | undefined;
+  /** True once the agent emitted a real `{progress}` marker — from then on its
+   *  values are authoritative and the bot fallback stops contributing. */
+  private agentReported = false;
+  /** Real work signals for the fallback estimate (monotonic within a turn). */
+  private toolCalls = 0;
+  private outChars = 0;
+  private thoughtChars = 0;
+
+  constructor(
+    private readonly api: Api,
+    private readonly chatId: number,
+    private readonly throttleMs: number,
+    private replyTo?: number,
+    private footer?: string,
+    private readonly onProgress?: (pct: number) => void,
+    /** Show a bot-computed bar when the agent emits no marker. */
+    private readonly fallbackEnabled = false,
+    /** Turn start time, used by the fallback's elapsed-time signal. */
+    private readonly turnStartedAt = Date.now(),
+  ) {}
+
+  /** Replace the hashtag footer (used after a logical fork swaps the session id
+   *  mid-turn, so the streamed response carries the NEW session's tags). */
+  setFooter(footer: string): void {
+    this.footer = footer;
+  }
+
+  /** "\n\n<footer>" appended to every finished message bubble (e.g. hashtags). */
+  private footerSuffix(): string {
+    return this.footer ? `\n\n${this.footer}` : "";
+  }
+
+  /** Strip `{progress: N%}` markers from rendered text, remembering the latest
+   *  value (sticky across flushes) and notifying the owner when it changes. */
+  private captureProgress(text: string): string {
+    const { value, cleaned } = extractProgress(text);
+    if (value !== undefined) this.setProgressValue(value, true);
+    return cleaned;
+  }
+
+  /** Record a progress value, enforcing global monotonicity (never decreases)
+   *  and notifying the owner on change. Agent markers are authoritative: once
+   *  one arrives, the bot fallback stops contributing. */
+  private setProgressValue(pct: number, fromAgent: boolean): void {
+    if (fromAgent) this.agentReported = true;
+    const next = Math.max(this.progress ?? 0, Math.round(pct));
+    if (next === this.progress) return;
+    this.progress = next;
+    try {
+      this.onProgress?.(next);
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  /** Advance the fallback estimate from real activity signals, but only while
+   *  the agent itself hasn't reported a value. No-op when fallback is off. */
+  private applyFallback(): void {
+    if (!this.fallbackEnabled || this.agentReported) return;
+    const est = estimateProgress({
+      toolCalls: this.toolCalls,
+      outputChars: this.outChars,
+      thoughtChars: this.thoughtChars,
+      elapsedMs: Date.now() - this.turnStartedAt,
+    });
+    if (est > 0) this.setProgressValue(est, false);
+  }
+
+  /** Called when the turn finishes successfully: if the agent never reported
+   *  its own progress, fill the fallback bar to 100. No-op otherwise. */
+  completeFallback(): void {
+    if (!this.fallbackEnabled || this.agentReported) return;
+    this.setProgressValue(100, false);
+  }
+
+  /** reply_parameters threading EVERY message of the turn to the user's prompt,
+   *  so the whole response (all bubbles, tool calls and continuations) stays in
+   *  one thread — not just the first message. */
+  private replyExtra(): Record<string, unknown> {
+    if (this.replyTo === undefined) return {};
+    return { reply_parameters: { message_id: this.replyTo, allow_sending_without_reply: true } };
+  }
+
+  appendOutput(text: string): void {
+    if (!text) return;
+    this.outChars += text.length;
+    this.merge("out", text);
+    this.schedule();
+  }
+
+  appendThought(text: string): void {
+    if (!text) return;
+    this.thoughtChars += text.length;
+    this.merge("think", text);
+    this.schedule();
+  }
+
+  addTool(rawMarkdown: string): void {
+    if (!rawMarkdown) return;
+    this.toolCalls += 1;
+    this.segs.push({ kind: "tool", text: rawMarkdown });
+    this.schedule();
+  }
+
+  get hasOutput(): boolean {
+    return this.liveId !== undefined || this.segs.some((s) => s.text.trim().length > 0);
+  }
+
+  async finalize(): Promise<void> {
+    this.closed = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    await this.flush(true);
+  }
+
+  // ── internals ──────────────────────────────────────────────────────────────
+
+  private merge(kind: SegKind, text: string): void {
+    const last = this.segs.at(-1);
+    if (last && last.kind === kind) last.text += text;
+    else this.segs.push({ kind, text });
+  }
+
+  private schedule(): void {
+    if (this.closed) return;
+    this.dirty = true;
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.flush(false);
+    }, this.throttleMs);
+  }
+
+  private async flush(final: boolean): Promise<void> {
+    if (this.flushing) {
+      if (!final) this.schedule();
+      return;
+    }
+    if (!this.dirty && !final) return;
+    this.flushing = true;
+    this.dirty = false;
+    try {
+      await this.sealOverflow();
+      const base = this.captureProgress(renderSegs(this.segs.slice(this.sealedIdx)));
+      this.applyFallback();
+      // Never send an empty / progress-only bubble. The bar is appended only to
+      // real streamed content; the live status panel shows the standalone bar.
+      if (!base.trim()) return;
+      // The live (still-streaming) bubble carries the hashtag footer AND a fresh
+      // progress bar at the bottom (sealed bubbles below get neither bar).
+      const parts: string[] = [base];
+      if (this.progress !== undefined) parts.push(progressBar(this.progress));
+      const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
+      const rendered = toTelegramMarkdown(src);
+      const chunks = chunkMarkdown(rendered);
+      const plain = chunkMarkdown(src);
+      if (chunks.length <= 1) {
+        const mdv2 = chunks[0] ?? rendered;
+        if (this.liveId === undefined) this.liveId = await safeSend(this.api, this.chatId, mdv2, src, this.replyExtra());
+        else await safeEdit(this.api, this.chatId, this.liveId, mdv2, src);
+      } else {
+        // Remainder no longer fits one message: flush all, last stays live.
+        for (let i = 0; i < chunks.length; i++) {
+          const mdv2 = chunks[i]!;
+          const p = plain[i] ?? mdv2;
+          if (i === 0 && this.liveId !== undefined) await safeEdit(this.api, this.chatId, this.liveId, mdv2, p);
+          else if (i < chunks.length - 1) await safeSend(this.api, this.chatId, mdv2, p, this.replyExtra());
+          else this.liveId = await safeSend(this.api, this.chatId, mdv2, p, this.replyExtra());
+        }
+        this.sealedIdx = this.segs.length; // everything before the live tail is sealed
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+
+  /** Seal leading segments into finalized messages while the live view is too big. */
+  private async sealOverflow(): Promise<void> {
+    let live = this.segs.slice(this.sealedIdx);
+    while (live.length > 1 && toTelegramMarkdown(renderSegs(live)).length > SOFT_LIMIT) {
+      const headCount = live.length - 1;
+      await this.seal(this.sealedIdx, this.sealedIdx + headCount);
+      this.sealedIdx += headCount;
+      this.liveId = undefined;
+      live = this.segs.slice(this.sealedIdx);
+    }
+  }
+
+  private async seal(from: number, to: number): Promise<void> {
+    const base = this.captureProgress(renderSegs(this.segs.slice(from, to)));
+    if (!base.trim()) return;
+    // A sealed bubble is finished, so it carries the footer (hashtags).
+    const src = `${base}${this.footerSuffix()}`;
+    const chunks = chunkMarkdown(toTelegramMarkdown(src));
+    const plain = chunkMarkdown(src);
+    for (let i = 0; i < chunks.length; i++) {
+      const mdv2 = chunks[i]!;
+      const p = plain[i] ?? mdv2;
+      if (i === 0 && this.liveId !== undefined) await safeEdit(this.api, this.chatId, this.liveId, mdv2, p);
+      else await safeSend(this.api, this.chatId, mdv2, p, this.replyExtra());
+    }
+  }
+}
+
+function renderSegs(segs: Seg[]): string {
+  return segs
+    .map((s) => {
+      if (s.kind === "out") return s.text.trim();
+      if (s.kind === "think") return quoteThought(s.text);
+      return s.text.trim();
+    })
+    .filter((x) => x.length > 0)
+    .join("\n\n");
+}
+
+function quoteThought(text: string): string {
+  const t = text.trim();
+  if (!t) return "";
+  const short = t.length > THINK_TAIL ? "…" + t.slice(-THINK_TAIL) : t;
+  const lines = short.split("\n");
+  return lines.map((l, i) => (i === 0 ? `> 💭 *thinking:* ${l}` : `> ${l}`)).join("\n");
+}

package/src/tasks/runner.ts

@@ -0,0 +1,82 @@
+/**
+ * Executes a scheduled task: opens a fresh session in the task's project,
+ * sends the prompt, collects the response, and delivers it to the chat.
+ * Runs independently of the user's interactive session.
+ */
+import type { Api } from "grammy";
+import { basename } from "node:path";
+import type { GrokClient } from "../grok/client.js";
+import type { SessionUpdate } from "../grok/types.js";
+import { createLogger } from "../logger.js";
+import { sendMarkdownDoc } from "../bot/telegram-io.js";
+import type { Task } from "./types.js";
+
+const log = createLogger("task-runner");
+
+export class TaskRunner {
+  constructor(
+    private readonly api: Api,
+    private readonly acp: GrokClient,
+  ) {}
+
+  /** Run a task; resolves true on success, false on error. */
+  async run(task: Task): Promise<boolean> {
+    log.info(`running task "${task.name}" in ${task.projectPath}`);
+    let sessionId = "";
+    let text = "";
+    let tools = 0;
+    const seen = new Set<string>();
+
+    const listener = (sid: string, u: SessionUpdate): void => {
+      if (sid !== sessionId) return;
+      if (u.sessionUpdate === "agent_message_chunk" && typeof u.content?.text === "string") {
+        text += u.content.text;
+      } else if (u.sessionUpdate === "tool_call") {
+        const id = u.toolCallId || u.title || String(tools);
+        if (!seen.has(id)) {
+          seen.add(id);
+          tools++;
+        }
+      }
+    };
+
+    try {
+      sessionId = await this.acp.newSession(task.projectPath);
+      if (task.agent) {
+        try {
+          await this.acp.setMode(sessionId, task.agent);
+        } catch {
+          /* best-effort */
+        }
+      }
+      this.acp.on("session-update", listener);
+      await this.acp.prompt(sessionId, [{ type: "text", text: task.prompt }]);
+      this.acp.off("session-update", listener);
+      await this.deliver(task, text, tools);
+      return true;
+    } catch (err) {
+      this.acp.off("session-update", listener);
+      await this.deliverError(task, (err as Error).message);
+      log.error(`task "${task.name}" failed:`, (err as Error).message);
+      return false;
+    }
+  }
+
+  private async deliver(task: Task, text: string, tools: number): Promise<void> {
+    const project = task.projectName || basename(task.projectPath);
+    const body = text.trim() || "_(no text output)_";
+    const footer = tools > 0 ? `\n\n\u{1F527} ${tools} tool call(s)` : "";
+    const header = `\u23F0 **Task: ${task.name}** \u00B7 ${project}`;
+    await sendMarkdownDoc(this.api, task.chatId, `${header}\n\n${body}${footer}`, { loud: true });
+  }
+
+  private async deliverError(task: Task, message: string): Promise<void> {
+    try {
+      await this.api.sendMessage(task.chatId, `\u274C Task "${task.name}" failed: ${message}`, {
+        disable_notification: false,
+      });
+    } catch {
+      /* non-fatal */
+    }
+  }
+}