pi-telegram-plus 0.0.1 → 0.0.3

package/lib/telegram-ui.ts

@@ -1,5 +1,6 @@
 import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { encodeUiCallback } from "./callback-protocol.ts";
+import { bridgeCustomDialog } from "./custom-dialogs.ts";
 import { escapeHtml } from "./html.ts";
 import type { CapturedAgentSession, PendingInputResolver, TelegramTransport } from "./types.ts";
 
@@ -84,14 +85,29 @@ export function createTelegramUiRuntime(deps: {
 
   return {
     create(chatId) {
-      const base = deps.getSession()?.extensionRunner.getUIContext?.();
+      // base is the real TUI UI context (create() is called BEFORE runWithTelegramUi
+      // swaps the UI context, so this is the genuine TUI context). We forward persistent
+      // /stateful methods to base so the TUI stays accurate even when the trigger came
+      // from Telegram. Interactive modals stay Telegram-only; editor ops are no-ops.
+      const base = deps.getSession()?.extensionRunner.getUIContext?.() as ExtensionUIContext | undefined;
+
+      const notifyFn = (message: string, level: "info" | "warning" | "error" = "info") => {
+        const fid = activeFlowByChat.get(chatId);
+        void sendOrReplaceText(chatId, `<b>${escapeHtml(String(level))}</b>\n${escapeHtml(message)}`, fid);
+      };
+
       return {
-        ...(base as ExtensionUIContext),
         chatId,
-        notify: (message, level = "info") => {
-          const flowId = activeFlowByChat.get(chatId);
-          void sendOrReplaceText(chatId, `<b>${escapeHtml(String(level))}</b>\n${escapeHtml(message)}`, flowId);
-        },
+
+        // ---- Interactive modals: Telegram-only (do NOT forward to base) ----
+        // Plan Layer A: "谁触发的 turn 就给谁". A Telegram-triggered turn must NOT
+        // also pop the modal in the local TUI, because ExtensionUIContext.custom and
+        // the other modals expose no external cancel handle — once the Telegram side
+        // resolves, any TUI-side component we mounted could never be dismissed, so
+        // the local TUI would stay "stuck at the selection". Local TUI turns never
+        // enter runWithTelegramUi, so they keep using the real TUI UIContext and are
+        // completely unaffected by this Telegram-only path.
+        notify: notifyFn,
         confirm: async (title, message) => {
           const flowId = beginFlow();
           activeFlowByChat.set(chatId, flowId);
@@ -100,6 +116,7 @@ export function createTelegramUiRuntime(deps: {
           ]], flowId);
           const value = await waitInput(chatId, flowId, false, false, sent.message_id);
           activeFlowByChat.delete(chatId);
+          void deps.transport.removeInlineKeyboard(chatId, sent.message_id);
           return value === true || value === "yes";
         },
         input: async (title, placeholder) => {
@@ -108,6 +125,7 @@ export function createTelegramUiRuntime(deps: {
           const sent = await sendOrReplaceButtons(chatId, `<b>${escapeHtml(title)}</b>${placeholder ? `\n${escapeHtml(placeholder)}` : ""}`, [[{ text: "Cancel", value: cb(flowId, "cancel") }]], flowId);
           const value = await waitInput(chatId, flowId, false, true, sent.message_id);
           activeFlowByChat.delete(chatId);
+          void deps.transport.removeInlineKeyboard(chatId, sent.message_id);
           return typeof value === "string" ? value : undefined;
         },
         inputSecret: async (title: string, placeholder?: string) => {
@@ -116,6 +134,7 @@ export function createTelegramUiRuntime(deps: {
           const sent = await sendOrReplaceButtons(chatId, `<b>${escapeHtml(title)}</b>${placeholder ? `\n${escapeHtml(placeholder)}` : ""}`, [[{ text: "Cancel", value: cb(flowId, "cancel") }]], flowId);
           const value = await waitInput(chatId, flowId, true, true, sent.message_id);
           activeFlowByChat.delete(chatId);
+          void deps.transport.removeInlineKeyboard(chatId, sent.message_id);
           return typeof value === "string" ? value : undefined;
         },
         editor: async (title, prefill) => {
@@ -124,6 +143,7 @@ export function createTelegramUiRuntime(deps: {
           const sent = await sendOrReplaceButtons(chatId, `<b>${escapeHtml(title)}</b>${prefill ? `\n${escapeHtml(prefill)}` : ""}`, [[{ text: "Cancel", value: cb(flowId, "cancel") }]], flowId);
           const value = await waitInput(chatId, flowId, false, true, sent.message_id);
           activeFlowByChat.delete(chatId);
+          void deps.transport.removeInlineKeyboard(chatId, sent.message_id);
           return typeof value === "string" ? value : undefined;
         },
         select: async (title, options) => {
@@ -140,15 +160,74 @@ export function createTelegramUiRuntime(deps: {
             const suffix = pageCount > 1 ? ` (${page + 1}/${pageCount})` : "";
             const sent = await sendOrReplaceButtons(chatId, `<b>${escapeHtml(title + suffix)}</b>`, rows, flowId);
             const value = await waitInput(chatId, flowId, false, false, sent.message_id);
-            if (typeof value !== "string") { activeFlowByChat.delete(chatId); return undefined; }
-            if (value === "cancel") { activeFlowByChat.delete(chatId); return undefined; }
+            if (typeof value !== "string") { activeFlowByChat.delete(chatId); void deps.transport.removeInlineKeyboard(chatId, sent.message_id); return undefined; }
+            if (value === "cancel") { activeFlowByChat.delete(chatId); void deps.transport.removeInlineKeyboard(chatId, sent.message_id); return undefined; }
             if (value.startsWith("p:")) { const next = parseInt(value.slice(2), 10); if (next >= 0 && next < pageCount) page = next; continue; }
-            if (value.startsWith("s:")) { const idx = parseInt(value.slice(2), 10); activeFlowByChat.delete(chatId); return idx >= 0 && idx < options.length ? options[idx] : undefined; }
-            if (options.includes(value)) { activeFlowByChat.delete(chatId); return value; }
+            if (value.startsWith("s:")) { const idx = parseInt(value.slice(2), 10); activeFlowByChat.delete(chatId); void deps.transport.removeInlineKeyboard(chatId, sent.message_id); return idx >= 0 && idx < options.length ? options[idx] : undefined; }
+            if (options.includes(value)) { activeFlowByChat.delete(chatId); void deps.transport.removeInlineKeyboard(chatId, sent.message_id); return value; }
             activeFlowByChat.delete(chatId);
+            void deps.transport.removeInlineKeyboard(chatId, sent.message_id);
             return undefined;
           }
         },
+        // custom: bridge pi-goal dialogs to Telegram buttons (Layer B). Does NOT
+        // forward to base — see the modals comment above for why racing the TUI is
+        // structurally un-dismissible and would leave the local TUI stuck.
+        custom: async <T>(factory: (tui: any, theme: any, keybindings: any, done: (result: T) => void) => any | Promise<any>, _options?: any): Promise<T> => {
+          const flowId = beginFlow();
+          activeFlowByChat.set(chatId, flowId);
+          let promptMessageId: number | undefined;
+          const result = await bridgeCustomDialog<T>({
+            factory,
+            theme: base?.theme,
+            width: 80,
+            sendButtons: async (text, rows) => {
+              const encodedRows = rows.map((row) => row.map((btn) => ({ text: btn.text, value: cb(flowId, btn.value) })));
+              const sent = await sendOrReplaceButtons(chatId, text, encodedRows, flowId);
+              promptMessageId = sent.message_id;
+              return sent;
+            },
+            waitInput: (acceptsText = false, sensitive = false) =>
+              waitInput(chatId, flowId, sensitive, acceptsText, promptMessageId),
+            notify: notifyFn,
+            removeKeyboard: async () => { if (promptMessageId) await deps.transport.removeInlineKeyboard(chatId, promptMessageId); },
+          });
+          activeFlowByChat.delete(chatId);
+          // pi-goal accesses result.cancelled/answers without an undefined-guard, so
+          // never resolve undefined: fall back to a structured cancelled result.
+          return (result ?? ({ questions: [], answers: [], cancelled: true } as unknown as T)) as T;
+        },
+
+        // ---- Persistent/stateful UI: forward to TUI base (keeps TUI accurate) ----
+        setStatus: (key: string, text: string | undefined) => { base?.setStatus?.(key, text); },
+        setWorkingMessage: (message?: string) => { base?.setWorkingMessage?.(message); },
+        setWorkingVisible: (visible: boolean) => { base?.setWorkingVisible?.(visible); },
+        setWorkingIndicator: (options?: { frames?: string[]; intervalMs?: number }) => { base?.setWorkingIndicator?.(options); },
+        setHiddenThinkingLabel: (label?: string) => { base?.setHiddenThinkingLabel?.(label); },
+        setWidget: ((key: string, content: unknown, options?: unknown) => { base?.setWidget?.(key as string, content as any, options as any); }) as ExtensionUIContext["setWidget"],
+        setFooter: (factory: unknown) => { base?.setFooter?.(factory as any); },
+        setHeader: (factory: unknown) => { base?.setHeader?.(factory as any); },
+        setTitle: (title: string) => { base?.setTitle?.(title); },
+        setToolsExpanded: (expanded: boolean) => { base?.setToolsExpanded?.(expanded); },
+        getToolsExpanded: () => base?.getToolsExpanded?.() ?? false,
+        setTheme: (theme: string | unknown) => base?.setTheme?.(theme as any) ?? { success: false, error: "UI not available" },
+        getTheme: (name: string) => base?.getTheme?.(name),
+        getAllThemes: () => base?.getAllThemes?.() ?? [],
+
+        // ---- Editor/terminal: no-ops (remote turns must not touch local editor) ----
+        onTerminalInput: () => () => {},
+        pasteToEditor: () => {},
+        setEditorText: () => {},
+        getEditorText: () => "",
+        setEditorComponent: () => {},
+        getEditorComponent: () => undefined,
+        addAutocompleteProvider: () => {},
+
+        // ---- Theme getter: delegate to base (factory needs theme.fg/bg) ----
+        // base is always defined when create() runs (create() is called before the
+        // runWithTelegramUi UI swap, per plan §2.1). The non-null assertion makes
+        // this precondition explicit instead of hiding it behind a cast.
+        get theme() { return base!.theme; },
       };
     },
     resolveInput(chatId, raw, replyToMessageId, fromCallback = false) {

package/lib/text-split.ts

@@ -1,6 +1,12 @@
 /**
  * Split text for Telegram's 4096-byte message limit.
  * Handles UTF-8 boundaries safely and prefers word/newline breaks.
+ *
+ * `splitTelegramText` is the legacy byte-level splitter (kept for the
+ * single-chunk `[0]` path used by edit/buttons). `splitTelegramHtml` is the
+ * semantic splitter used for multi-message sends: it cuts at block boundaries
+ * so every chunk is independently valid Telegram HTML (no unbalanced
+ * <pre>/<blockquote> that would force a plain-text fallback).
  */
 
 const TELEGRAM_TEXT_LIMIT = 4096;
@@ -56,4 +62,213 @@ export function splitTelegramText(text: string): string[] {
   }
   if (rest) chunks.push(rest);
   return chunks;
-}
+}
+
+// ── Semantic HTML splitter ───────────────────────────────────────────────────
+// Protects atomic blocks (<pre>, <blockquote>) so a cut never lands inside
+// one and produces unbalanced tags. Oversized atomic blocks are split along
+// their internal line boundaries into multiple complete blocks.
+
+/** Split rendered Telegram HTML into <= maxBytes chunks, each valid HTML. */
+export function splitTelegramHtml(html: string, maxBytes: number = SAFE_TEXT_CHUNK): string[] {
+  if (byteLength(html) <= maxBytes) return [html];
+  const blocks = splitHtmlBlocks(html);
+  const chunks: string[] = [];
+  let cur = "";
+  const flush = () => {
+    const t = cur.trim();
+    if (t) chunks.push(t);
+    cur = "";
+  };
+  for (const block of blocks) {
+    if (byteLength(block) > maxBytes) {
+      flush();
+      for (const piece of splitOversizedBlock(block, maxBytes)) chunks.push(piece);
+      continue;
+    }
+    if (byteLength(cur) + 2 + byteLength(block) > maxBytes) flush();
+    cur = cur ? `${cur}\n\n${block}` : block;
+  }
+  flush();
+  return chunks.length ? chunks : [html];
+}
+
+/** Tokenize HTML into top-level blocks (atomic tags stay intact). */
+function splitHtmlBlocks(html: string): string[] {
+  const atoms: string[] = [];
+  const placeholder = (atom: string) => {
+    atoms.push(atom);
+    return `\x00ATOM${atoms.length - 1}\x00`;
+  };
+  // Wrap each atomic block in blank lines so \n\n splitting isolates it.
+  // <pre> never contains a literal </pre> (code content is HTML-escaped),
+  // and our blockquotes don't nest, so non-greedy match is safe.
+  const protectedHtml = html
+    .replace(/<pre>[\s\S]*?<\/pre>/g, (m) => `\n\n${placeholder(m)}\n\n`)
+    .replace(/<blockquote[^>]*>[\s\S]*?<\/blockquote>/g, (m) => `\n\n${placeholder(m)}\n\n`);
+  const blocks: string[] = [];
+  for (const part of protectedHtml.split(/\n\n+/)) {
+    const t = part.trim();
+    if (!t) continue;
+    blocks.push(t.replace(/\x00ATOM(\d+)\x00/g, (_m, idx) => atoms[Number(idx)] ?? ""));
+  }
+  return blocks;
+}
+
+/** Split a single oversized block along its internal structure. */
+function splitOversizedBlock(block: string, maxBytes: number): string[] {
+  // <pre>...</pre> (code or box-table): split content by lines into multiple
+  // complete <pre> chunks.
+  const preMatch = /^(<pre>)(<code[^>]*>)?([\s\S]*)(<\/code>)?(<\/pre>)$/.exec(block);
+  if (preMatch) {
+    const [, preOpen, codeOpen, content, codeClose, preClose] = preMatch;
+    const open = (preOpen ?? "") + (codeOpen ?? "");
+    const close = (codeClose ?? "") + (preClose ?? "");
+    const lines = content.replace(/\n$/, "").split("\n");
+    // Box-drawing table: content starts with the top border ┌ and ends with the
+    // bottom border └. Splitting mid-table would drop the header row in
+    // continuation chunks (inconsistent), so repeat top border + header row +
+    // separator at the start of every chunk and the bottom border at the end —
+    // each chunk renders as a complete, consistent mini-table.
+    if (lines[0]?.startsWith("┌") && lines[lines.length - 1]?.startsWith("└")) {
+      return splitBoxPreTable(lines, maxBytes, open, close);
+    }
+    return packLines(lines, maxBytes, open, close);
+  }
+  // <blockquote...>...</blockquote>: split inner content, re-wrap each piece.
+  const bqMatch = /^(<blockquote[^>]*>)([\s\S]*)(<\/blockquote>)$/.exec(block);
+  if (bqMatch) {
+    const [, open, inner, close] = bqMatch;
+    const budget = maxBytes - byteLength(open) - byteLength(close);
+    return packLines(inner.replace(/\n$/, "").split("\n"), Math.max(50, budget), open, close);
+  }
+  // Card table (has a "──" header/row separator): repeat the header in each chunk.
+  const lines = block.split("\n");
+  const sepIdx = lines.indexOf("──");
+  if (sepIdx > 0) {
+    const header = lines.slice(0, sepIdx + 1).join("\n");
+    const rows = lines.slice(sepIdx + 1);
+    const headerOverhead = byteLength(header) + 1;
+    const pieces = packLines(rows, Math.max(50, maxBytes - headerOverhead), "", "");
+    return pieces.map((p) => `${header}\n${p}`);
+  }
+  // Transposed record (every line is `<b>label</b>: value`): keep each chunk's
+  // labels so a huge cell value is never separated from its column context.
+  if (lines.length > 0 && lines.every((l) => /^<b>.*<\/b>:/.test(l))) {
+    return splitTransposeRecord(lines, maxBytes);
+  }
+  // Plain paragraph / list: byte-split at newline/space boundaries.
+  return splitPlainBytes(block, maxBytes);
+}
+
+/** Split a transposed `label: value` record, repeating a label across a byte-
+ *  split huge value so every chunk keeps its column context (same style). */
+function splitTransposeRecord(lines: string[], maxBytes: number): string[] {
+  const chunks: string[] = [];
+  let cur = "";
+  for (const line of lines) {
+    if (byteLength(line) <= maxBytes) {
+      const candidate = cur ? `${cur}\n${line}` : line;
+      if (byteLength(candidate) > maxBytes && cur) { chunks.push(cur); cur = line; }
+      else cur = candidate;
+      continue;
+    }
+    // Huge value line: byte-split the value, repeating the `label:` prefix.
+    if (cur) { chunks.push(cur); cur = ""; }
+    const m = /^(<b>.*?<\/b>:)\s*/.exec(line);
+    const label = m ? m[1] : "";
+    const value = m ? line.slice(m[0].length) : line;
+    const valueBudget = Math.max(50, maxBytes - byteLength(label) - 1);
+    for (const piece of splitPlainBytes(value, valueBudget)) chunks.push(`${label} ${piece}`);
+  }
+  if (cur) chunks.push(cur);
+  return chunks.length ? chunks : [lines.join("\n")];
+}
+
+/** Pack string lines into chunks `open + lines + close`, each <= maxBytes. */
+function packLines(lines: string[], maxBytes: number, open: string, close: string): string[] {
+  const overhead = byteLength(open) + byteLength(close);
+  const budget = Math.max(50, maxBytes - overhead);
+  const chunks: string[] = [];
+  let cur = "";
+  for (const line of lines) {
+    if (cur) {
+      const candidate = `${cur}\n${line}`;
+      if (byteLength(candidate) > budget) {
+        chunks.push(`${open}${cur}${close}`);
+        cur = "";
+      } else {
+        cur = candidate;
+        continue;
+      }
+    }
+    // cur is empty: start a new chunk with `line`. If the line alone exceeds
+    // budget, byte-split it as a last-resort guard so no chunk ever overflows
+    // maxBytes and triggers a per-chunk plain-text fallback (which would mix
+    // styles within the same table).
+    if (byteLength(line) > budget) {
+      for (const piece of splitPlainBytes(line, budget)) chunks.push(`${open}${piece}${close}`);
+    } else {
+      cur = line;
+    }
+  }
+  if (cur) chunks.push(`${open}${cur}${close}`);
+  return chunks.length ? chunks : [`${open}${lines.join("\n")}${close}`];
+}
+
+/**
+ * Split an oversized box-drawing table (inside <pre>) so every chunk is a
+ * complete mini-table: top border + header row + separator + N data rows +
+ * bottom border. This keeps the same style and header context in every chunk
+ * (a naive line-split would drop the header row in continuation chunks).
+ */
+function splitBoxPreTable(lines: string[], maxBytes: number, open: string, close: string): string[] {
+  const topBorder = lines[0];
+  const headerRow = lines[1];
+  const separator = lines[2];
+  const bottomBorder = lines[lines.length - 1];
+  const dataRows = lines.slice(3, -1);
+  const header = [topBorder, headerRow, separator].join("\n");
+  const overhead = byteLength(open) + byteLength(close) + byteLength(header) + 1 + byteLength(bottomBorder) + 1;
+  const budget = Math.max(50, maxBytes - overhead);
+  const chunks: string[] = [];
+  let cur: string[] = [];
+  let curBytes = 0;
+  const flush = () => {
+    if (cur.length) {
+      chunks.push(`${open}${header}\n${cur.join("\n")}\n${bottomBorder}${close}`);
+      cur = []; curBytes = 0;
+    }
+  };
+  for (const row of dataRows) {
+    const rowBytes = byteLength(row) + 1;
+    if (curBytes + rowBytes > budget && cur.length) flush();
+    // Single row alone exceeds budget: byte-split it so no chunk overflows.
+    if (byteLength(row) > budget) {
+      flush();
+      for (const piece of splitPlainBytes(row, budget)) {
+        chunks.push(`${open}${header}\n${piece}\n${bottomBorder}${close}`);
+      }
+      continue;
+    }
+    cur.push(row); curBytes += rowBytes;
+  }
+  flush();
+  return chunks.length ? chunks : [`${open}${header}\n${dataRows.join("\n")}\n${bottomBorder}${close}`];
+}
+
+/** Byte-aware split at newline/space; fallback for plain text. */
+function splitPlainBytes(text: string, maxBytes: number): string[] {
+  if (byteLength(text) <= maxBytes) return [text];
+  const chunks: string[] = [];
+  let rest = text;
+  while (byteLength(rest) > maxBytes) {
+    const { head } = takeUtf8Prefix(rest, maxBytes);
+    let cut = Math.max(head.lastIndexOf("\n"), head.lastIndexOf(" "));
+    if (cut <= 0) cut = head.length;
+    chunks.push(rest.slice(0, cut));
+    rest = rest.slice(cut).replace(/^\s+/, "");
+  }
+  if (rest) chunks.push(rest);
+  return chunks;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "pi-telegram-plus",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Full Telegram control of pi coding agent — commands, menus, interactive UI, model management, and more",
   "keywords": [
     "pi-package",