@foxden-app/foxclaw 0.5.33 → 0.5.34

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.5.34 - 2026-06-17
+
+### 中文
+- 普通 Codex 输出接入 Telegram RichMessage：流式阶段继续稳定发送纯文本，segment 完成后自动把已发消息编辑为富文本，支持标题、列表、引用、代码块、行内 code、粗体和安全链接。
+- draft 流式路径优先使用官方 `sendRichMessageDraft`，发送失败时对当前 turn 自动熔断回原纯文本 draft，避免影响实时输出。
+- 新增 Markdown 到 RichMessage HTML 的安全转换与回归测试，保留 Telegram/微信 fallback：RichMessage 失败时不会破坏原纯文本输出，微信继续使用原 HTML/plain 降级通道。
+
+### English
+- Wired normal Codex output into Telegram RichMessage: live streaming still sends stable plain text, then completed segments are edited into rich text with headings, lists, quotes, fenced code, inline code, bold text, and safe links.
+- Draft streaming now prefers the official `sendRichMessageDraft` API and automatically disables rich drafts for the current turn if it fails, preserving the previous plain draft behavior.
+- Added a safe Markdown-to-RichMessage HTML renderer with regression coverage while preserving Telegram/Weixin fallbacks so RichMessage failures do not break existing output.
+
 ## 0.5.33 - 2026-06-16
 
 ### 中文

package/dist/channels/bridge_messaging_router.d.ts

@@ -23,6 +23,7 @@ export declare class BridgeMessagingRouter {
     sendTypingInScope(scopeId: string): Promise<void>;
     clearInlineKeyboard(scopeId: string, messageId: number): Promise<void>;
     sendDraft(scopeId: string, draftId: number, text: string): Promise<void>;
+    sendRichDraft(scopeId: string, draftId: number, html: string, fallbackText: string): Promise<void>;
     answerCallback(callbackQueryId: string, text: string): Promise<void>;
     getFile(fileId: string): Promise<TelegramRemoteFile>;
     downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;

package/dist/channels/bridge_messaging_router.js

@@ -85,6 +85,12 @@ export class BridgeMessagingRouter {
         }
         return this.telegram.sendDraft(scopeId, draftId, text);
     }
+    sendRichDraft(scopeId, draftId, html, fallbackText) {
+        if (this.isWeixinScope(scopeId)) {
+            return this.requireWeixinTransport(scopeId).sendDraft(scopeId, draftId, fallbackText);
+        }
+        return this.telegram.sendRichDraft(scopeId, draftId, html);
+    }
     answerCallback(callbackQueryId, text) {
         return this.telegram.answerCallback(callbackQueryId, text);
     }

package/dist/channels/telegram/telegram_messaging_port.d.ts

@@ -21,6 +21,7 @@ export declare class TelegramMessagingPort implements ChannelPort {
     sendTypingInScope(bridgeScopeId: string): Promise<void>;
     clearInlineKeyboard(bridgeScopeId: string, messageId: number): Promise<void>;
     sendDraft(bridgeScopeId: string, draftId: number, text: string): Promise<void>;
+    sendRichDraft(bridgeScopeId: string, draftId: number, html: string): Promise<void>;
     answerCallback(callbackQueryId: string, text: string): Promise<void>;
     getFile(fileId: string): Promise<TelegramRemoteFile>;
     downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;

package/dist/channels/telegram/telegram_messaging_port.js

@@ -48,6 +48,10 @@ export class TelegramMessagingPort {
         const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
         await this.gateway.sendMessageDraft(target.chatId, draftId, text, target.topicId);
     }
+    async sendRichDraft(bridgeScopeId, draftId, html) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.sendRichMessageDraft(target.chatId, draftId, telegramRichHtml(html, { skipEntityDetection: true }), target.topicId);
+    }
     answerCallback(callbackQueryId, text) {
         return this.gateway.answerCallback(callbackQueryId, text);
     }

package/dist/controller/controller.d.ts

@@ -228,6 +228,7 @@ export declare class BridgeSessionCore {
     private sendMessage;
     private sendHtmlMessage;
     private sendRichHtmlMessage;
+    private sendRichMarkdownMessage;
     private editMessage;
     private editHtmlMessage;
     private editRichHtmlMessage;
@@ -439,6 +440,7 @@ export declare class BridgeSessionCore {
     private forgetPreviewRecord;
     private clearMessageButtons;
     private sendDraft;
+    private sendRichDraft;
     private renderActiveStatus;
     private dismissTurnPreview;
     private ensureStatusMessage;
@@ -459,5 +461,7 @@ export declare class BridgeSessionCore {
     private findActiveTurnByThreadId;
     private findActiveTurnsByThreadId;
     private syncSegmentTimeline;
+    private shouldPromoteSegmentToRich;
+    private promoteSegmentMessagesToRich;
 }
 export { BridgeSessionCore as BridgeController };

package/dist/controller/controller.js

@@ -11,6 +11,7 @@ import { TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, buildAttachmentPrompt, isNativeI
 import { TELEGRAM_MESSAGE_LIMIT, chunkTelegramMessage, chunkTelegramStreamMessage, clipTelegramDraftMessage, } from '../telegram/text.js';
 import { escapeTelegramHtml, telegramBold, telegramDetails, telegramExpandableBlockquote, telegramPre, telegramPreCode, } from '../telegram/html.js';
 import { TELEGRAM_RICH_MESSAGE_TEXT_LIMIT } from '../telegram/rich.js';
+import { renderTelegramMarkdownRichHtml } from '../telegram/rich_markdown.js';
 import { isDefaultTelegramScope, resolveTelegramAddressing } from '../telegram/addressing.js';
 import { BRIDGE_SCOPE_WEIXIN_PREFIX, parseTelegramTargetFromBridgeScope, parseWeixinBridgeScope } from '../core/bridge_scope.js';
 import { resolveTelegramRenderRoute } from '../telegram/rendering.js';
@@ -2930,6 +2931,7 @@ export class BridgeSessionCore {
             previewActive: previewMessageId > 0,
             draftId: null,
             draftText: null,
+            richDraftDisabled: false,
             buffer: '',
             finalText: null,
             interruptRequested: false,
@@ -3133,7 +3135,7 @@ export class BridgeSessionCore {
                 const fallbackKey = active.interruptRequested ? 'interrupted' : 'completed';
                 const finalChunks = chunkTelegramMessage(active.finalText || active.buffer, undefined, t(locale, fallbackKey));
                 for (const chunk of finalChunks) {
-                    await this.sendMessage(active.scopeId, chunk);
+                    await this.sendRichMarkdownMessage(active.scopeId, chunk);
                 }
             }
             shouldMarkPartialOutput = active.interruptRequested
@@ -3372,6 +3374,9 @@ export class BridgeSessionCore {
             return this.sendHtmlMessage(scopeId, fallbackHtml, inlineKeyboard);
         }
     }
+    async sendRichMarkdownMessage(scopeId, text, inlineKeyboard) {
+        return this.sendRichHtmlMessage(scopeId, renderTelegramMarkdownRichHtml(text), escapeTelegramHtml(text), inlineKeyboard);
+    }
     async editMessage(scopeId, messageId, text, inlineKeyboard) {
         await this.messaging.editPlain(scopeId, messageId, text, inlineKeyboard);
     }
@@ -7619,6 +7624,9 @@ export class BridgeSessionCore {
     async sendDraft(scopeId, draftId, text) {
         await this.messaging.sendDraft(scopeId, draftId, text);
     }
+    async sendRichDraft(scopeId, draftId, html, fallbackText) {
+        await this.messaging.sendRichDraft(scopeId, draftId, html, fallbackText);
+    }
     renderActiveStatus(active) {
         const locale = this.localeForChat(active.scopeId);
         return renderActiveTurnStatus(locale, {
@@ -7864,12 +7872,34 @@ export class BridgeSessionCore {
             active.draftId = crypto.randomInt(1, 2_147_483_647);
         }
         try {
-            await this.sendDraft(active.scopeId, active.draftId, draftText);
+            if (active.richDraftDisabled) {
+                await this.sendDraft(active.scopeId, active.draftId, draftText);
+            }
+            else {
+                await this.sendRichDraft(active.scopeId, active.draftId, renderTelegramMarkdownRichHtml(draftText), draftText);
+            }
             active.draftText = draftText;
         }
         catch (error) {
+            let finalError = error;
+            if (!active.richDraftDisabled) {
+                active.richDraftDisabled = true;
+                this.logger.warn('telegram.rich_draft_send_failed', {
+                    error: String(finalError),
+                    turnId: active.turnId,
+                    draftId: active.draftId,
+                });
+                try {
+                    await this.sendDraft(active.scopeId, active.draftId, draftText);
+                    active.draftText = draftText;
+                    return;
+                }
+                catch (fallbackError) {
+                    finalError = fallbackError;
+                }
+            }
             this.logger.warn('telegram.draft_send_failed', {
-                error: String(error),
+                error: String(finalError),
                 turnId: active.turnId,
                 draftId: active.draftId,
             });
@@ -7904,7 +7934,7 @@ export class BridgeSessionCore {
             if (!existing) {
                 try {
                     const messageId = await this.sendMessage(active.scopeId, chunk);
-                    segment.messages.push({ messageId, text: chunk });
+                    segment.messages.push({ messageId, text: chunk, richHtml: null, richFailedForText: null });
                     active.statusNeedsRebase = true;
                 }
                 catch (error) {
@@ -7927,6 +7957,8 @@ export class BridgeSessionCore {
             try {
                 await this.editMessage(active.scopeId, existing.messageId, chunk);
                 existing.text = chunk;
+                existing.richHtml = null;
+                existing.richFailedForText = null;
                 index += 1;
             }
             catch (error) {
@@ -7964,6 +7996,47 @@ export class BridgeSessionCore {
                 }
             }
         }
+        if (this.shouldPromoteSegmentToRich(active, segment)) {
+            await this.promoteSegmentMessagesToRich(active, segment, chunks);
+        }
+    }
+    shouldPromoteSegmentToRich(active, segment) {
+        return !active.scopeId.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX)
+            && segment.completed
+            && segment.outputKind !== 'error'
+            && Boolean(segment.text.trim());
+    }
+    async promoteSegmentMessagesToRich(active, segment, chunks) {
+        for (let index = 0; index < chunks.length; index += 1) {
+            const chunk = chunks[index];
+            const existing = segment.messages[index];
+            if (!existing || !chunk.trim()) {
+                continue;
+            }
+            const richHtml = renderTelegramMarkdownRichHtml(chunk);
+            if (existing.richHtml === richHtml || existing.richFailedForText === chunk) {
+                continue;
+            }
+            try {
+                await this.messaging.editRichHtml(active.scopeId, existing.messageId, richHtml, escapeTelegramHtml(chunk));
+                existing.richHtml = richHtml;
+                existing.richFailedForText = null;
+            }
+            catch (error) {
+                if (isTelegramMessageGone(error)) {
+                    segment.messages.splice(index);
+                    return;
+                }
+                existing.richFailedForText = chunk;
+                this.logger.warn('telegram.stream_rich_edit_failed', {
+                    error: String(error),
+                    turnId: active.turnId,
+                    itemId: segment.itemId,
+                    messageId: existing.messageId,
+                    chunkIndex: index,
+                });
+            }
+        }
     }
 }
 function ensureTurnSegment(active, itemId, phase, outputKind, isPlan) {

package/dist/telegram/rich_markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function renderTelegramMarkdownRichHtml(markdown: string): string;
+export declare function renderInlineRichHtml(markdown: string): string;

package/dist/telegram/rich_markdown.js

@@ -0,0 +1,115 @@
+import { escapeTelegramHtml, telegramPreCode } from './html.js';
+const SAFE_LINK_SCHEMES = /^(https?:|mailto:|tg:)/i;
+export function renderTelegramMarkdownRichHtml(markdown) {
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (!line.trim()) {
+            index += 1;
+            continue;
+        }
+        const fence = line.match(/^```([A-Za-z0-9_+-]*)\s*$/);
+        if (fence) {
+            const codeLines = [];
+            index += 1;
+            while (index < lines.length && !/^```\s*$/.test(lines[index])) {
+                codeLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length) {
+                index += 1;
+            }
+            blocks.push(telegramPreCode(codeLines.join('\n'), sanitizeCodeLanguage(fence[1] ?? '')));
+            continue;
+        }
+        const heading = line.match(/^(#{1,4})\s+(.+?)\s*#*\s*$/);
+        if (heading) {
+            const level = Math.min(4, Math.max(2, heading[1].length + 1));
+            blocks.push(`<h${level}>${renderInlineRichHtml(heading[2])}</h${level}>`);
+            index += 1;
+            continue;
+        }
+        if (/^\s*[-*+]\s+/.test(line)) {
+            const items = [];
+            while (index < lines.length && /^\s*[-*+]\s+/.test(lines[index])) {
+                items.push(stripListMarker(lines[index], false));
+                index += 1;
+            }
+            blocks.push(`<ul>${items.map(item => `<li>${renderInlineRichHtml(item)}</li>`).join('')}</ul>`);
+            continue;
+        }
+        if (/^\s*\d+[.)]\s+/.test(line)) {
+            const items = [];
+            while (index < lines.length && /^\s*\d+[.)]\s+/.test(lines[index])) {
+                items.push(stripListMarker(lines[index], true));
+                index += 1;
+            }
+            blocks.push(`<ol>${items.map(item => `<li>${renderInlineRichHtml(item)}</li>`).join('')}</ol>`);
+            continue;
+        }
+        if (/^\s*>\s?/.test(line)) {
+            const quoteLines = [];
+            while (index < lines.length && /^\s*>\s?/.test(lines[index])) {
+                quoteLines.push(lines[index].replace(/^\s*>\s?/, ''));
+                index += 1;
+            }
+            blocks.push(`<blockquote>${quoteLines.map(renderInlineRichHtml).join('<br>')}</blockquote>`);
+            continue;
+        }
+        const paragraphLines = [line.trimEnd()];
+        index += 1;
+        while (index < lines.length
+            && lines[index].trim()
+            && !/^```/.test(lines[index])
+            && !/^(#{1,4})\s+/.test(lines[index])
+            && !/^\s*[-*+]\s+/.test(lines[index])
+            && !/^\s*\d+[.)]\s+/.test(lines[index])
+            && !/^\s*>\s?/.test(lines[index])) {
+            paragraphLines.push(lines[index].trimEnd());
+            index += 1;
+        }
+        blocks.push(`<p>${renderInlineRichHtml(paragraphLines.join('\n'))}</p>`);
+    }
+    return blocks.join('\n') || '<p></p>';
+}
+export function renderInlineRichHtml(markdown) {
+    const tokens = [];
+    const protectedText = markdown.replace(/`([^`\n]+)`/g, (_match, code) => {
+        const token = `{{FOXCLAW_RICH_CODE_${tokens.length}}}`;
+        tokens.push(`<code>${escapeTelegramHtml(code)}</code>`);
+        return token;
+    });
+    let html = escapeTelegramHtml(protectedText);
+    html = html.replace(/\[([^\]\n]+)\]\(((?:[^()\s]+|\([^)\s]*\))+)\)/g, (_match, label, url) => {
+        const normalizedUrl = unescapeHtmlAttribute(url);
+        if (!SAFE_LINK_SCHEMES.test(normalizedUrl)) {
+            return label;
+        }
+        return `<a href="${escapeTelegramHtmlAttribute(normalizedUrl)}">${label}</a>`;
+    });
+    html = html.replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, '<b>$1</b>');
+    html = html.replace(/__([^_\n][\s\S]*?[^_\n])__/g, '<b>$1</b>');
+    html = html.replace(/\{\{FOXCLAW_RICH_CODE_(\d+)}}/g, (_match, tokenIndex) => tokens[Number(tokenIndex)] ?? '');
+    return html.replaceAll('\n', '<br>');
+}
+function stripListMarker(line, ordered) {
+    return ordered
+        ? line.replace(/^\s*\d+[.)]\s+/, '')
+        : line.replace(/^\s*[-*+]\s+/, '');
+}
+function sanitizeCodeLanguage(language) {
+    const normalized = language.trim().replace(/[^A-Za-z0-9_+-]/g, '');
+    return normalized || undefined;
+}
+function escapeTelegramHtmlAttribute(value) {
+    return escapeTelegramHtml(value).replaceAll('"', '&quot;');
+}
+function unescapeHtmlAttribute(value) {
+    return value
+        .replaceAll('&amp;', '&')
+        .replaceAll('&lt;', '<')
+        .replaceAll('&gt;', '>')
+        .replaceAll('&quot;', '"');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.33",
+  "version": "0.5.34",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",