polygram 0.4.13 → 0.5.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.4.13",
+  "version": "0.5.1",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/lib/telegram-format.js

@@ -1,36 +1,275 @@
 /**
- * Convert Claude's CommonMark output into Telegram-safe MarkdownV2.
+ * Markdown → Telegram HTML.
  *
- * Why: Claude emits standard GitHub-flavoured markdown (headings, bullets,
- * `**bold**`, fenced code). Telegram does NOT support headings or bullet
- * lists natively; `**bold**` is `*bold*` in its dialect; and MarkdownV2
- * requires escaping `_*[]()~\`>#+-=|{}.!` in non-formatted text. Sending
- * Claude's raw markdown with no parse_mode shows literal `**` and `#`
- * in chat; sending it with parse_mode: MarkdownV2 crashes with "can't
- * parse entities" the moment Claude writes a period or exclamation mark.
+ * Replaces the 0.4.x telegramify-markdown / MarkdownV2 pipeline with HTML
+ * output. Reasons for the switch:
+ *   - Native syntax highlighting via `<pre><code class="language-X">`
+ *   - `<blockquote expandable>` for collapsible long output
+ *   - Only 3 chars need escaping (`<`, `>`, `&`) vs MarkdownV2's 18
+ *   - Cleaner nesting (HTML tag pairs vs MarkdownV2's brittle ordering)
+ *   - Tables become `<pre>` blocks with column alignment, no regex hacks
  *
- * telegramify-markdown handles both concerns: downgrades unsupported
- * constructs (headings → bold, bullets → `•`) and escapes reserved chars.
- *
- * We wrap it here rather than calling it inline so:
- *   - Swapping libraries later is a one-file change.
- *   - Fallback-on-throw is centralised (if conversion explodes, we send
- *     the original text with no parse_mode — worse formatting, but the
- *     message still arrives).
+ * Implementation: `marked` parses CommonMark into tokens, our custom
+ * renderer emits Telegram-compatible HTML for each token type. The
+ * `wrapFileReferencesInHtml` post-processor (adapted from OpenClaw,
+ * MIT) wraps `README.md`-style references in `<code>` so Telegram
+ * doesn't auto-linkify them as bogus domains.
  */
 
-const telegramify = require('telegramify-markdown');
+const { Marked } = require('marked');
 
-function toTelegramMarkdown(text) {
-  if (typeof text !== 'string' || text.length === 0) {
-    return { text, parseMode: null };
+// File extensions that are ALSO TLDs and commonly appear in chat (where
+// auto-linking them as `http://README.md` would generate spam preview
+// cards). Adapted from openclaw/openclaw (MIT) src/shared/text/
+// auto-linked-file-ref.ts. Excludes `.ai`, `.io`, `.tv`, `.fm` which
+// are popular real-domain TLDs.
+const FILE_REF_EXTENSIONS = ['md', 'go', 'py', 'pl', 'sh', 'am', 'at', 'be', 'cc'];
+
+function escapeHtml(text) {
+  if (typeof text !== 'string') return '';
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+function escapeHtmlAttr(text) {
+  return escapeHtml(text).replace(/"/g, '&quot;');
+}
+
+// Trigger expandable blockquote when content exceeds either threshold.
+// `<blockquote expandable>` renders as a 3-line preview with "Show more"
+// — useful for long quoted reasoning the user usually skips.
+const EXPANDABLE_BLOCKQUOTE_CHARS = 240;
+const EXPANDABLE_BLOCKQUOTE_LINES = 4;
+
+function shouldExpandQuote(innerHtml) {
+  const plain = innerHtml.replace(/<[^>]+>/g, '');
+  return plain.length > EXPANDABLE_BLOCKQUOTE_CHARS
+      || plain.split('\n').length > EXPANDABLE_BLOCKQUOTE_LINES;
+}
+
+// Split a list item's tokens into the leading inline run and any
+// block-level tokens that follow (nested list, code block, etc.). Without
+// this split, `parser.parse(item.tokens)` glues inline text directly
+// against the nested list's first marker — "top• nested 1" with no
+// separator — because text() does not emit a trailing newline.
+const BLOCK_TYPES = new Set(['list', 'blockquote', 'code', 'table', 'paragraph', 'space', 'html', 'hr']);
+
+function splitItemTokens(tokens) {
+  const inline = [];
+  const blocks = [];
+  let crossedToBlock = false;
+  for (const tok of tokens) {
+    if (BLOCK_TYPES.has(tok.type)) {
+      crossedToBlock = true;
+      blocks.push(tok);
+    } else if (crossedToBlock) {
+      blocks.push({ type: 'paragraph', tokens: [tok] });
+    } else {
+      inline.push(tok);
+    }
   }
+  return { inline, blocks };
+}
+
+function buildRenderer() {
+  // Different bullet glyphs per nesting depth: visual hierarchy without
+  // relying on Telegram preserving leading spaces (it does for HTML
+  // mode but the cue is clearer with distinct bullets).
+  const NESTED_BULLETS = ['•', '◦', '▪', '▫'];
+  let listDepth = 0;
+  function bulletFor(d) { return NESTED_BULLETS[Math.min(d, NESTED_BULLETS.length - 1)]; }
+
+  return {
+    heading({ tokens }) {
+      return `<b>${this.parser.parseInline(tokens)}</b>\n\n`;
+    },
+    paragraph({ tokens }) {
+      return this.parser.parseInline(tokens) + '\n\n';
+    },
+    text({ tokens, text }) {
+      if (Array.isArray(tokens) && tokens.length) return this.parser.parseInline(tokens);
+      return escapeHtml(text);
+    },
+    strong({ tokens }) { return `<b>${this.parser.parseInline(tokens)}</b>`; },
+    em({ tokens })     { return `<i>${this.parser.parseInline(tokens)}</i>`; },
+    del({ tokens })    { return `<s>${this.parser.parseInline(tokens)}</s>`; },
+    codespan({ text }) { return `<code>${escapeHtml(text)}</code>`; },
+    code({ text, lang }) {
+      const langClass = lang ? ` class="language-${escapeHtmlAttr(lang)}"` : '';
+      return `<pre><code${langClass}>${escapeHtml(text)}</code></pre>\n\n`;
+    },
+    blockquote({ tokens }) {
+      const inner = this.parser.parse(tokens).trim();
+      const expandable = shouldExpandQuote(inner) ? ' expandable' : '';
+      return `<blockquote${expandable}>${inner}</blockquote>\n\n`;
+    },
+    link({ href, tokens }) {
+      return `<a href="${escapeHtmlAttr(href)}">${this.parser.parseInline(tokens)}</a>`;
+    },
+    image({ href, text }) {
+      return `<a href="${escapeHtmlAttr(href)}">${escapeHtml(text || href)}</a>`;
+    },
+    list({ items, ordered, start }) {
+      const depth = listDepth;
+      listDepth += 1;
+      const indent = '  '.repeat(depth);
+      const bullet = bulletFor(depth);
+      try {
+        const lines = items.map((item, i) => {
+          const marker = ordered ? `${(start || 1) + i}. ` : `${bullet} `;
+          const { inline, blocks } = splitItemTokens(item.tokens);
+          const leader = this.parser.parseInline(inline).trim();
+          let line = `${indent}${marker}${leader}`;
+          for (const block of blocks) {
+            const rendered = this.parser.parse([block]).replace(/\n+$/, '');
+            if (rendered) line += '\n' + rendered;
+          }
+          return line;
+        });
+        return lines.join('\n') + (depth === 0 ? '\n\n' : '');
+      } finally {
+        listDepth -= 1;
+      }
+    },
+    listitem({ tokens }) { return this.parser.parse(tokens); },
+    hr() { return '\n──────\n\n'; },
+    br() { return '\n'; },
+    table({ header, rows, align }) {
+      const headerCells = header.map((cell) => this.parser.parseInline(cell.tokens));
+      const rowCells = rows.map((row) => row.map((cell) => this.parser.parseInline(cell.tokens)));
+      const stripTags = (s) => s.replace(/<[^>]+>/g, '');
+      const widths = headerCells.map((h, col) => {
+        let maxLen = stripTags(h).length;
+        for (const r of rowCells) {
+          const cellLen = stripTags(r[col] || '').length;
+          if (cellLen > maxLen) maxLen = cellLen;
+        }
+        return maxLen;
+      });
+      const padCell = (s, col) => {
+        const len = stripTags(s).length;
+        const padding = ' '.repeat(Math.max(0, widths[col] - len));
+        if (align[col] === 'right') return padding + s;
+        return s + padding;
+      };
+      const renderRow = (cells) => '| ' + cells.map((c, i) => padCell(c, i)).join(' | ') + ' |';
+      const sep = '|' + widths.map((w) => '-'.repeat(w + 2)).join('|') + '|';
+      const lines = [renderRow(headerCells), sep, ...rowCells.map(renderRow)];
+      return `<pre>${lines.join('\n')}</pre>\n\n`;
+    },
+    html({ text }) { return escapeHtml(text); },
+  };
+}
+
+// Spoiler extension for marked. Recognises `||hidden||` inline. Telegram-
+// specific (matches OpenClaw's enableSpoilers behaviour).
+const spoilerExtension = {
+  name: 'spoiler',
+  level: 'inline',
+  start(src) { return src.indexOf('||'); },
+  tokenizer(src) {
+    const m = /^\|\|([\s\S]+?)\|\|/.exec(src);
+    if (!m) return undefined;
+    return {
+      type: 'spoiler',
+      raw: m[0],
+      text: m[1],
+      tokens: this.lexer.inlineTokens(m[1]),
+    };
+  },
+  renderer({ tokens }) {
+    return `<tg-spoiler>${this.parser.parseInline(tokens)}</tg-spoiler>`;
+  },
+};
+
+const HTML_TAG_RE = /(<\/?)([a-zA-Z][a-zA-Z0-9-]*)\b[^>]*?>/gi;
+const AUTO_LINKED_ANCHOR_RE = /<a\s+href="https?:\/\/([^"]+)"[^>]*>\1<\/a>/gi;
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+const _extPattern = FILE_REF_EXTENSIONS.map(escapeRegex).join('|');
+const FILE_REF_PATTERN = new RegExp(
+  `(^|[^a-zA-Z0-9_\\-/])([a-zA-Z0-9_.\\-./]+\\.(?:${_extPattern}))(?=$|[^a-zA-Z0-9_\\-/])`,
+  'gi',
+);
+const ORPHANED_TLD_PATTERN = new RegExp(
+  `([^a-zA-Z0-9]|^)([A-Za-z]\\.(?:${_extPattern}))(?=[^a-zA-Z0-9/]|$)`,
+  'g',
+);
+
+function isAutoLinkedFileRef(label) {
+  const dotIdx = label.lastIndexOf('.');
+  if (dotIdx < 1) return false;
+  const ext = label.slice(dotIdx + 1).toLowerCase();
+  if (!FILE_REF_EXTENSIONS.includes(ext)) return false;
+  const segments = label.split('/');
+  if (segments.length > 1) {
+    for (let i = 0; i < segments.length - 1; i += 1) {
+      if (segments[i].includes('.')) return false;
+    }
+  }
+  return true;
+}
+
+function wrapStandaloneFileRef(_match, prefix, filename) {
+  if (filename.startsWith('//')) return _match;
+  if (/https?:\/\/$/i.test(prefix)) return _match;
+  return `${prefix}<code>${escapeHtml(filename)}</code>`;
+}
+
+function wrapSegment(text, codeDepth, preDepth, anchorDepth) {
+  if (!text || codeDepth > 0 || preDepth > 0 || anchorDepth > 0) return text;
+  const w = text.replace(FILE_REF_PATTERN, wrapStandaloneFileRef);
+  return w.replace(ORPHANED_TLD_PATTERN, (m, prefix, tld) => {
+    if (prefix === '>') return m;
+    return `${prefix}<code>${escapeHtml(tld)}</code>`;
+  });
+}
+
+function wrapFileReferencesInHtml(html) {
+  AUTO_LINKED_ANCHOR_RE.lastIndex = 0;
+  const deLinkified = html.replace(AUTO_LINKED_ANCHOR_RE, (m, label) => {
+    if (!isAutoLinkedFileRef(label)) return m;
+    return `<code>${escapeHtml(label)}</code>`;
+  });
+  let codeDepth = 0, preDepth = 0, anchorDepth = 0;
+  let result = '';
+  let lastIndex = 0;
+  HTML_TAG_RE.lastIndex = 0;
+  let match;
+  while ((match = HTML_TAG_RE.exec(deLinkified)) !== null) {
+    const tagStart = match.index;
+    const tagEnd = HTML_TAG_RE.lastIndex;
+    const isClosing = match[1] === '</';
+    const tagName = match[2].toLowerCase();
+    result += wrapSegment(deLinkified.slice(lastIndex, tagStart), codeDepth, preDepth, anchorDepth);
+    if (tagName === 'code') codeDepth = isClosing ? Math.max(0, codeDepth - 1) : codeDepth + 1;
+    else if (tagName === 'pre') preDepth = isClosing ? Math.max(0, preDepth - 1) : preDepth + 1;
+    else if (tagName === 'a') anchorDepth = isClosing ? Math.max(0, anchorDepth - 1) : anchorDepth + 1;
+    result += deLinkified.slice(tagStart, tagEnd);
+    lastIndex = tagEnd;
+  }
+  result += wrapSegment(deLinkified.slice(lastIndex), codeDepth, preDepth, anchorDepth);
+  return result;
+}
+
+const _markedInstance = new Marked(
+  { gfm: true, breaks: false, renderer: buildRenderer() },
+  { extensions: [spoilerExtension] },
+);
+
+function toTelegramHtml(text) {
+  if (typeof text !== 'string' || text.length === 0) return { text, parseMode: null };
   try {
-    const converted = telegramify(text, 'escape');
-    return { text: converted, parseMode: 'MarkdownV2' };
+    const html = _markedInstance.parse(text).trimEnd();
+    const wrapped = wrapFileReferencesInHtml(html);
+    return { text: wrapped, parseMode: 'HTML' };
   } catch {
     return { text, parseMode: null };
   }
 }
 
-module.exports = { toTelegramMarkdown };
+function toTelegramMarkdown(text) { return toTelegramHtml(text); }
+
+module.exports = { toTelegramMarkdown, toTelegramHtml, wrapFileReferencesInHtml, escapeHtml };

package/lib/telegram.js

@@ -43,12 +43,12 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
-// Methods whose `text` / `caption` fields we auto-format into MarkdownV2.
+// Methods whose `text` / `caption` fields we auto-format into Telegram HTML.
 // Anything else passes through untouched (setMessageReaction, sendSticker,
 // deleteMessage, etc. have no text to format).
 const FORMATTABLE_METHODS = new Set(['sendMessage', 'editMessageText']);
 
-// Apply Claude-markdown → Telegram-MarkdownV2 conversion in-place on the
+// Apply Claude-markdown → Telegram HTML conversion in-place on the
 // params object. Skipped if:
 //   - Method doesn't carry formattable text.
 //   - Caller already set a parse_mode (respect explicit choice).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.4.13",
+  "version": "0.5.1",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc-client.js",
   "bin": {
@@ -62,6 +62,7 @@
   "dependencies": {
     "better-sqlite3": "^12.9.0",
     "grammy": "^1.42.0",
-    "telegramify-markdown": "^1.3.3"
+    "markdown-it": "^14.1.1",
+    "marked": "^18.0.2"
   }
 }

package/polygram.js

@@ -737,6 +737,29 @@ function buildApprovalKeyboard(approvalId, token) {
   };
 }
 
+// /model and /effort inline keyboard. `show` controls which row(s) appear:
+// 'model', 'effort', or 'all'. The current value gets a ✓ marker so the
+// user can see at a glance what's selected.
+const MODEL_OPTIONS = ['opus', 'sonnet', 'haiku'];
+const EFFORT_OPTIONS = ['low', 'medium', 'high', 'xhigh', 'max'];
+
+function buildConfigKeyboard(chatConfig, show = 'all') {
+  const rows = [];
+  if (show === 'model' || show === 'all') {
+    rows.push(MODEL_OPTIONS.map((m) => ({
+      text: m === chatConfig.model ? `✓ ${m}` : m,
+      callback_data: `cfg:model:${m}`,
+    })));
+  }
+  if (show === 'effort' || show === 'all') {
+    rows.push(EFFORT_OPTIONS.map((e) => ({
+      text: e === chatConfig.effort ? `✓ ${e}` : e,
+      callback_data: `cfg:effort:${e}`,
+    })));
+  }
+  return { inline_keyboard: rows };
+}
+
 function approvalCardText(row, opts = {}) {
   // No parse_mode is used on this card — tool_name/turn_id/tool_input
   // originate from the Claude subprocess and could contain Markdown special
@@ -927,6 +950,81 @@ async function handleApprovalCallback(ctx) {
   resolveApprovalWaiter(id, status);
 }
 
+// Handles taps on the /model and /effort inline keyboard buttons. Same
+// outcome as the text-typed `/model sonnet` flow: mutate chatConfig,
+// trigger graceful respawn, log config change, edit the message to show
+// the new ✓ marker.
+async function handleConfigCallback(ctx) {
+  const data = ctx.callbackQuery?.data || '';
+  const m = String(data).match(/^cfg:(model|effort):(\S+)$/);
+  if (!m) return;
+  const setting = m[1];
+  const value = m[2];
+
+  const chatId = String(ctx.callbackQuery.message?.chat?.id || '');
+  const chatConfig = config.chats[chatId];
+  if (!chatConfig) {
+    await ctx.answerCallbackQuery({ text: 'Chat not configured', show_alert: true }).catch(() => {});
+    return;
+  }
+  if (!config.bot?.allowConfigCommands) {
+    await ctx.answerCallbackQuery({ text: 'Config commands disabled', show_alert: true }).catch(() => {});
+    return;
+  }
+
+  const validValues = setting === 'model' ? MODEL_OPTIONS : EFFORT_OPTIONS;
+  if (!validValues.includes(value)) {
+    await ctx.answerCallbackQuery({ text: `Invalid ${setting}` }).catch(() => {});
+    return;
+  }
+
+  const oldValue = chatConfig[setting];
+  if (oldValue === value) {
+    await ctx.answerCallbackQuery({ text: `Already ${value}` }).catch(() => {});
+    return;
+  }
+
+  chatConfig[setting] = value;
+  const cmdUserId = ctx.callbackQuery.from?.id || null;
+  const cmdUser = ctx.callbackQuery.from?.first_name || ctx.callbackQuery.from?.username || null;
+  dbWrite(() => db.logConfigChange({
+    chat_id: chatId, thread_id: null, field: setting,
+    old_value: oldValue, new_value: value,
+    user: cmdUser, user_id: cmdUserId, source: 'inline-button',
+  }), `log ${setting} change`);
+
+  // Graceful respawn across all sessionKeys for this chat (matches the
+  // text-command flow in handleMessage).
+  const reason = setting === 'model' ? 'model-change' : 'effort-change';
+  const prefix = chatId;
+  let anyActive = false;
+  for (const key of pm.keys()) {
+    if (key === prefix || key.startsWith(prefix + ':')) {
+      const res = pm.requestRespawn(key, reason);
+      if (!res.killed) anyActive = true;
+    }
+  }
+
+  // Re-render the card with updated ✓.
+  const ver = MODEL_VERSIONS[chatConfig.model] || chatConfig.model;
+  const newInfo = `Model: ${chatConfig.model} (${ver})\nEffort: ${chatConfig.effort}\nAgent: ${chatConfig.agent}`;
+  const showRow = setting; // /model card → only model row, /effort → only effort, /config → both.
+  // Detect original card type from existing reply_markup row count.
+  const existingRows = ctx.callbackQuery.message?.reply_markup?.inline_keyboard?.length || 0;
+  const newKeyboard = buildConfigKeyboard(chatConfig, existingRows >= 2 ? 'all' : showRow);
+  try {
+    await ctx.editMessageText(newInfo, { reply_markup: newKeyboard });
+  } catch (err) {
+    // Edit may fail if message is too old or unchanged — not fatal.
+    console.error(`[${BOT_NAME}] config-card edit failed: ${err.message}`);
+  }
+
+  const ackText = anyActive
+    ? `${setting} → ${value} — switching when finished`
+    : `${setting} → ${value}`;
+  await ctx.answerCallbackQuery({ text: ackText }).catch(() => {});
+}
+
 function startApprovalSweeper(intervalMs = 30_000) {
   return setInterval(() => {
     let rows;
@@ -1006,15 +1104,24 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   const cmdUser = msg.from?.first_name || msg.from?.username || null;
   const cmdUserId = msg.from?.id || null;
 
-  const sendReply = (replyText, meta = {}) => tg(bot, 'sendMessage', {
-    chat_id: chatId, text: replyText, ...replyOpts(threadId),
-  }, { source: 'command-reply', botName: BOT_NAME, model: chatConfig.model, effort: chatConfig.effort, ...meta });
+  // sendReply accepts (text, meta?) with optional extra Telegram params
+  // pulled out via meta.params (kept separate so meta stays for DB tags).
+  const sendReply = (replyText, meta = {}) => {
+    const { params: extraParams = {}, ...metaTags } = meta;
+    return tg(bot, 'sendMessage', {
+      chat_id: chatId, text: replyText, ...replyOpts(threadId), ...extraParams,
+    }, { source: 'command-reply', botName: BOT_NAME, model: chatConfig.model, effort: chatConfig.effort, ...metaTags });
+  };
 
   if (botAllowsCommands && (text === '/model' || text === '/config' || text === '/effort')) {
     const alive = pm.has(sessionKey) && !pm.get(sessionKey).closed;
     const ver = MODEL_VERSIONS[chatConfig.model] || chatConfig.model;
     const info = `Model: ${chatConfig.model} (${ver})\nEffort: ${chatConfig.effort}\nAgent: ${chatConfig.agent}\nProcess: ${alive ? 'warm' : 'cold'}\nSession: ${getClaudeSessionId(db, sessionKey)?.slice(0, 8) || 'new'}`;
-    await sendReply(info);
+    // Inline keyboard so users tap to switch instead of typing exact
+    // names (avoids "sonet" typo problem).
+    const show = text === '/effort' ? 'effort' : text === '/model' ? 'model' : 'all';
+    const reply_markup = buildConfigKeyboard(chatConfig, show);
+    await sendReply(info, { params: { reply_markup } });
     return;
   }
   // Helper: request respawn across ALL sessionKeys owned by this chat (one
@@ -1665,7 +1772,12 @@ function createBot(token) {
 
   bot.on('callback_query:data', async (ctx) => {
     try {
-      await handleApprovalCallback(ctx);
+      const data = ctx.callbackQuery?.data || '';
+      if (data.startsWith('cfg:')) {
+        await handleConfigCallback(ctx);
+      } else {
+        await handleApprovalCallback(ctx);
+      }
     } catch (err) {
       console.error(`[${BOT_NAME}] callback_query error: ${err.message}`);
     }