grok-telegram-bot 2.3.1 → 2.4.0

package/src/render/truncate.ts

@@ -0,0 +1,85 @@
+/**
+ * Display-only truncation helpers.
+ *
+ * Long tool outputs, diffs, and reasoning are shortened for Telegram so messages
+ * stay readable and under size limits. Session history / agent context is
+ * unaffected — these helpers never touch what is stored on disk for context.
+ */
+
+/** Ellipsis used in truncated regions (single character). */
+const ELLIPSIS = "\u2026";
+
+/**
+ * Keep the start of `text` when longer than `max` (classic head truncate).
+ * Prefer {@link truncateMiddle} for long command/diff/reasoning bodies.
+ */
+export function truncateHead(text: string, max: number): string {
+  if (max <= 0) return "";
+  if (text.length <= max) return text;
+  if (max === 1) return ELLIPSIS;
+  return text.slice(0, max - 1) + ELLIPSIS;
+}
+
+/**
+ * Keep both ends of a long string, cutting the middle with an explicit note.
+ * Head ~40% / tail ~60% of the budget so recent terminal output stays visible.
+ */
+export function truncateMiddle(text: string, max: number): string {
+  if (max <= 0) return "";
+  if (text.length <= max) return text;
+  if (max <= 24) return truncateHead(text, max);
+
+  const omitted = text.length;
+  const marker = `\n${ELLIPSIS} (${omitted.toLocaleString("en-US")} chars total; middle omitted) ${ELLIPSIS}\n`;
+  const budget = max - marker.length;
+  if (budget < 8) return truncateHead(text, max);
+
+  const headLen = Math.max(4, Math.floor(budget * 0.4));
+  const tailLen = Math.max(4, budget - headLen);
+  // Avoid overlapping when max is only slightly under length.
+  if (headLen + tailLen >= text.length) return text;
+  return text.slice(0, headLen) + marker + text.slice(text.length - tailLen);
+}
+
+/**
+ * Middle-truncate a multi-line block by whole lines when possible (better for
+ * diffs and command output). Falls back to character middle-truncate.
+ */
+export function truncateMiddleLines(text: string, maxLines: number, maxChars = 12_000): string {
+  const lines = text.split("\n");
+  let body: string;
+  if (lines.length <= maxLines) {
+    body = text;
+  } else {
+    const headN = Math.max(1, Math.floor(maxLines * 0.45));
+    const tailN = Math.max(1, maxLines - headN);
+    const omitted = lines.length - headN - tailN;
+    body = [
+      ...lines.slice(0, headN),
+      `${ELLIPSIS} (${omitted} lines omitted) ${ELLIPSIS}`,
+      ...lines.slice(lines.length - tailN),
+    ].join("\n");
+  }
+  return truncateMiddle(body, maxChars);
+}
+
+/**
+ * Live terminal display: keep the first output line + the last `tailLines`
+ * lines so long command runs update in place without spamming new blocks.
+ * Display-only — full text stays in the agent session / tool snapshot.
+ */
+export function formatLiveTerminalOutput(full: string, tailLines = 12, maxChars = 3500): string {
+  const normalized = full.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const lines = normalized.split("\n");
+  // Drop trailing empty lines for a cleaner tail.
+  while (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  if (lines.length === 0) return "";
+  if (lines.length <= tailLines + 1) {
+    return truncateMiddle(lines.join("\n"), maxChars);
+  }
+  const first = lines[0]!;
+  const tail = lines.slice(-tailLines);
+  const omitted = lines.length - 1 - tailLines;
+  const body = [first, `${ELLIPSIS} (${omitted} lines omitted; live tail) ${ELLIPSIS}`, ...tail].join("\n");
+  return truncateMiddle(body, maxChars);
+}

package/src/service/windows.ts

@@ -168,20 +168,32 @@ function entryOf(spec: LaunchSpec): string {
 }
 
 function vbsLauncher(spec: LaunchSpec): string {
+  // Forever-restart loop: wait for the bot process to exit, pause, relaunch.
+  // Prevents silent death when the node process crashes. GROK_TG_SUPERVISED=1
+  // tells the bot a supervisor will relaunch it (auto-update exits cleanly).
   const cmd = `""${spec.nodePath}"" ${spec.args.map((a) => `""${a}""`).join(" ")}`;
   return [
     'Set sh = CreateObject("WScript.Shell")',
     `sh.CurrentDirectory = "${spec.cwd}"`,
-    `sh.Run "${cmd}", 0, False`,
+    'Set env = sh.Environment("PROCESS")',
+    'env("GROK_TG_SUPERVISED") = "1"',
+    "Do",
+    `  sh.Run "${cmd}", 0, True`,
+    "  WScript.Sleep 3000",
+    "Loop",
   ].join("\r\n");
 }
 
 function killScript(entry: string): string {
   const safe = entry.replace(/'/g, "''");
+  // Kill the forever-restart VBS host *before* node, otherwise the 3s loop
+  // respawns the bot right after "stop". Targets our service / Startup launchers.
   return [
+    `$vbs = Get-CimInstance Win32_Process -Filter "Name='wscript.exe' OR Name='cscript.exe'" | Where-Object { $_.CommandLine -like '*GrokTelegramBot.vbs*' -or $_.CommandLine -like '*run-service.vbs*' };`,
+    `$vbs | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue };`,
     `$p = Get-CimInstance Win32_Process -Filter "Name='node.exe'" | Where-Object { $_.CommandLine -like '*${safe}*' };`,
     `$p | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue };`,
-    `"killed " + (@($p).Count)`,
+    `"killed " + (@($p).Count) + " node, " + (@($vbs).Count) + " vbs"`,
   ].join(" ");
 }
 

package/src/sessions/history.ts

@@ -46,6 +46,48 @@ export function jsonlMtimeMs(jsonlPath: string): number {
   }
 }
 
+/**
+ * Best-effort card blurb from the tail of a session log: last assistant prose
+ * (what was solved), else last user prompt. Skips import-confirm noise.
+ */
+export function readLastCardSummary(jsonlPath: string, maxEntries = 30): string {
+  const entries = readHistory(jsonlPath, maxEntries);
+  if (entries.length === 0) return "";
+  // Walk newest → oldest for a useful assistant conclusion.
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]!;
+    if (e.role === "assistant" && e.text.trim()) {
+      const t = cleanCardProse(e.text);
+      if (t.length >= 20) return t;
+    }
+  }
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i]!;
+    if (e.role === "user" && e.text.trim()) {
+      const t = cleanCardProse(e.text);
+      if (t && !/session import complete/i.test(t)) return t;
+    }
+  }
+  return "";
+}
+
+function cleanCardProse(raw: string, max = 200): string {
+  let t = extractProgress(raw).cleaned;
+  t = t.replace(/```[\s\S]*?```/g, " ");
+  t = t.replace(/^COMPLEXITY \(decide yourself[\s\S]*?User task:\s*/i, "");
+  t = t.replace(/^TASK COMPLEXITY:[\s\S]*?User task:\s*/i, "");
+  if (/^Session status update \(meta only\)/i.test(t.trim())) return "";
+  t = t.replace(/\s+/g, " ").trim();
+  if (t.length <= max) return t;
+  // Prefer the ending (conclusions).
+  if (t.length > max + 40) {
+    const tail = t.slice(-max + 1);
+    const sp = tail.indexOf(" ");
+    return "\u2026" + (sp > 0 && sp < 30 ? tail.slice(sp + 1) : tail);
+  }
+  return t.slice(0, max - 1) + "\u2026";
+}
+
 /** The first user prompt in a session log (read from the start), or "". */
 export function readFirstPrompt(jsonlPath: string, maxBytes = 256 * 1024): string {
   let size: number;
@@ -163,6 +205,21 @@ function cleanStoredText(text: string): string {
   let t = extractProgress(text).cleaned;
   if (t.includes(PROGRESS_DIRECTIVE)) t = t.split(PROGRESS_DIRECTIVE).join("").trim();
   if (t.includes(IMAGE_OUTPUT_DIRECTIVE)) t = t.split(IMAGE_OUTPUT_DIRECTIVE).join("").trim();
+  // Strip first-prompt auto-complexity steering (and legacy forced-complex wrapper)
+  // so history / cards show the real user task, not bot plumbing.
+  const taskMarker = "User task:";
+  const ti = t.lastIndexOf(taskMarker);
+  if (
+    ti !== -1 &&
+    (/^COMPLEXITY \(decide yourself/i.test(t) || /^TASK COMPLEXITY:/i.test(t))
+  ) {
+    t = t.slice(ti + taskMarker.length).trim();
+  }
+  // Drop removed/quiet meta-prompts if they landed in history.
+  if (/^Session status update \(meta only\)/i.test(t.trim())) t = "";
+  if (/^FOLLOW-UP SUGGESTIONS \(meta only\)/i.test(t.trim())) t = "";
+  if (/^SELF-RECHECK DECISION \(meta only\)/i.test(t.trim())) t = "";
+  if (/^SELF-RECHECK \(automatic quality pass/i.test(t.trim())) t = "";
   return t;
 }
 

package/src/sessions/store.ts

@@ -17,6 +17,7 @@ interface RawSessionJson {
   created_at?: string;
   updated_at?: string;
   session_created_reason?: string;
+  comment?: string;
 }
 
 interface RawLock {
@@ -93,6 +94,7 @@ export class SessionStore {
       /* no history yet */
     }
 
+    const comment = (raw.comment || "").trim();
     return {
       sessionId,
       cwd: raw.cwd || "",
@@ -103,6 +105,7 @@ export class SessionStore {
       lockPid,
       active,
       historyBytes,
+      comment: comment || undefined,
     };
   }
 

package/src/sessions/types.ts

@@ -13,6 +13,11 @@ export interface SessionMeta {
   active: boolean;
   /** Size of the .jsonl history in bytes (proxy for conversation length). */
   historyBytes: number;
+  /**
+   * Short status line for cards: current step while working, or chat summary
+   * when idle (persisted by the bot after turns).
+   */
+  comment?: string;
 }
 
 export type HistoryRole = "user" | "assistant" | "tool" | "system";

package/src/stream/streamer.ts

@@ -15,15 +15,19 @@ 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 { truncateMiddle } from "../render/truncate.js";
 import { safeEdit, safeSend } from "../bot/telegram-io.js";
 
 const SOFT_LIMIT = 3500;
-const THINK_TAIL = 500;
+/** Display budget for a thinking block (middle-truncated; session context keeps all). */
+const THINK_DISPLAY_MAX = 2800;
 
 type SegKind = "out" | "think" | "tool";
 interface Seg {
   kind: SegKind;
   text: string;
+  /** When set, later tool updates replace this segment instead of appending. */
+  toolId?: string;
 }
 
 export class ResponseStreamer {
@@ -44,6 +48,11 @@ export class ResponseStreamer {
   private toolCalls = 0;
   private outChars = 0;
   private thoughtChars = 0;
+  /**
+   * Active plan board (ACP sessionUpdate "plan"). Always rendered just above
+   * the progress bar when set — done / in-progress / pending steps.
+   */
+  private planMarkdown: string | undefined;
 
   constructor(
     private readonly api: Api,
@@ -134,6 +143,10 @@ export class ResponseStreamer {
     this.schedule();
   }
 
+  /**
+   * Append a one-shot tool card (no live updates). Prefer {@link upsertTool}
+   * for ACP tool calls that stream progress/output under a stable toolCallId.
+   */
   addTool(rawMarkdown: string): void {
     if (!rawMarkdown) return;
     this.toolCalls += 1;
@@ -141,6 +154,45 @@ export class ResponseStreamer {
     this.schedule();
   }
 
+  /**
+   * Insert or replace a tool card keyed by toolCallId so one command/edit stays
+   * a single Telegram block that auto-updates (no spam of new code sections).
+   * Full tool results remain in the agent session; this is display-only.
+   */
+  /** Replace the live plan board (or clear with empty/undefined). */
+  setPlan(markdown: string | undefined): void {
+    const next = markdown?.trim() ? markdown.trim() : undefined;
+    if (next === this.planMarkdown) return;
+    this.planMarkdown = next;
+    this.schedule();
+  }
+
+  upsertTool(toolId: string | undefined, rawMarkdown: string): void {
+    if (!rawMarkdown) return;
+    const id = (toolId || "").trim();
+    if (id) {
+      // Replace any existing segment with this id (newest first; includes rare
+      // sealed-region matches so we don't keep stale text in the segs model).
+      for (let i = this.segs.length - 1; i >= 0; i--) {
+        const s = this.segs[i]!;
+        if (s.kind === "tool" && s.toolId === id) {
+          if (s.text === rawMarkdown) return;
+          s.text = rawMarkdown;
+          // If the card lives only in a sealed bubble, also ensure a live copy
+          // so the user sees the latest output on the current message.
+          if (i < this.sealedIdx) {
+            this.segs.push({ kind: "tool", text: rawMarkdown, toolId: id });
+          }
+          this.schedule();
+          return;
+        }
+      }
+    }
+    this.toolCalls += 1;
+    this.segs.push({ kind: "tool", text: rawMarkdown, toolId: id || undefined });
+    this.schedule();
+  }
+
   get hasOutput(): boolean {
     return this.liveId !== undefined || this.segs.some((s) => s.text.trim().length > 0);
   }
@@ -182,13 +234,15 @@ export class ResponseStreamer {
       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];
+      // Never send an empty / progress-only bubble. Plan alone is allowed so the
+      // board is visible as soon as the agent publishes steps.
+      if (!base.trim() && !this.planMarkdown) return;
+      // Live bubble: body → plan (always above progress) → progress bar → footer.
+      const parts: string[] = [];
+      if (base.trim()) parts.push(base);
+      if (this.planMarkdown) parts.push(this.planMarkdown);
       if (this.progress !== undefined) parts.push(progressBar(this.progress));
+      if (parts.length === 0) return;
       const src = `${parts.join("\n\n")}${this.footerSuffix()}`;
       const rendered = toTelegramMarkdown(src);
       const chunks = chunkMarkdown(rendered);
@@ -255,7 +309,17 @@ function renderSegs(segs: Seg[]): string {
 function quoteThought(text: string): string {
   const t = text.trim();
   if (!t) return "";
-  const short = t.length > THINK_TAIL ? "…" + t.slice(-THINK_TAIL) : t;
+  // Keep both ends of long reasoning so early investigation is not lost in the UI.
+  // Truncation is display-only — the agent session retains every thought token.
+  // Neutralize fence markers and half-open emphasis so thinking never breaks
+  // MarkdownV2 parsing of the surrounding live message.
+  const safe = t
+    .replace(/```+/g, "'''")
+    .replace(/\*\*/g, "")
+    .replace(/__/g, "")
+    .replace(/~~/g, "");
+  const short = truncateMiddle(safe, THINK_DISPLAY_MAX);
   const lines = short.split("\n");
-  return lines.map((l, i) => (i === 0 ? `> 💭 *thinking:* ${l}` : `> ${l}`)).join("\n");
+  // Plain "thinking:" (no nested *bold*) — nested markers break mid-stream.
+  return lines.map((l, i) => (i === 0 ? `> \u{1F4AD} thinking: ${l}` : `> ${l}`)).join("\n");
 }

package/src/tasks/runner.ts

@@ -6,7 +6,7 @@
 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 { contentText, type SessionUpdate } from "../grok/types.js";
 import { createLogger } from "../logger.js";
 import { sendMarkdownDoc } from "../bot/telegram-io.js";
 import type { Task } from "./types.js";
@@ -29,8 +29,9 @@ export class TaskRunner {
 
     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;
+      if (u.sessionUpdate === "agent_message_chunk") {
+        const t = contentText(u.content);
+        if (t) text += t;
       } else if (u.sessionUpdate === "tool_call") {
         const id = u.toolCallId || u.title || String(tools);
         if (!seen.has(id)) {