openclaw-openagent 1.0.1 → 1.0.2

package/dist/src/plugin-ui/ui-extension-loader/registry-regex.js

@@ -0,0 +1,701 @@
+/**
+ * UIExtension 注册表 — 正则模式链方案（无需 source map）
+ *
+ * 用正则锚点定位注入位置，无需 source map。
+ *
+ * 验证来源：full-inject.mjs — 21 版本 × 6 扩展点，acorn 语法 100% 合法。
+ */
+import { readFileSync, writeFileSync, copyFileSync, unlinkSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { logger } from '../../util/logger.js';
+import { findFileByPrefix } from './locator.js';
+import { backupFile, restoreFile } from './backup.js';
+import { makeMarker, hasMarker } from './types.js';
+// ── 常量 ──────────────────────────────────────────────────────────────────
+const OVERRIDE_ASSET_URL = new URL('../assets/openagent-override.js', import.meta.url);
+function getOverrideAssetHash() {
+    return createHash('sha256')
+        .update(readFileSync(OVERRIDE_ASSET_URL))
+        .digest('hex')
+        .slice(0, 12);
+}
+// ── 辅助函数 ──────────────────────────────────────────────────────────────
+/** 获取 bundle 路径（不要求 source map 存在）。 */
+function resolveBundlePath(controlUiDir) {
+    const assetsDir = join(controlUiDir, 'assets');
+    const bundlePath = findFileByPrefix(assetsDir, 'index-');
+    if (!bundlePath) {
+        logger.debug('[ui-ext:regex] Main bundle not found');
+        return null;
+    }
+    return bundlePath;
+}
+/** 在 push({...}) 内找 object literal 闭合 } 的位置。 */
+function findObjectLiteralClose(code, pushParenStart) {
+    let i = pushParenStart;
+    while (i < code.length && code[i] !== '{')
+        i++;
+    if (i >= code.length)
+        return -1;
+    let depth = 1;
+    let inTemplate = false;
+    for (let j = i + 1; j < code.length; j++) {
+        const ch = code[j];
+        if (ch === '`') {
+            inTemplate = !inTemplate;
+            continue;
+        }
+        if (inTemplate)
+            continue;
+        if (ch === '{')
+            depth++;
+        if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+    }
+    return -1;
+}
+function findFunctionByAnchor(content, anchor, lookBack = 5000) {
+    const anchorIdx = content.indexOf(anchor);
+    if (anchorIdx < 0)
+        return null;
+    const searchStart = Math.max(0, anchorIdx - lookBack);
+    const regionBefore = content.substring(searchStart, anchorIdx);
+    const funcRe = /function\s+(\w+)\(([^)]*)\)\{/g;
+    let lastFunc = null;
+    let funcMatch;
+    while ((funcMatch = funcRe.exec(regionBefore)) !== null)
+        lastFunc = funcMatch;
+    if (!lastFunc)
+        return null;
+    const bodyStart = searchStart + lastFunc.index + lastFunc[0].length;
+    let braceDepth = 1;
+    let bodyEnd = bodyStart;
+    for (let i = bodyStart; i < content.length && braceDepth > 0; i++) {
+        if (content[i] === '{')
+            braceDepth++;
+        else if (content[i] === '}')
+            braceDepth--;
+        bodyEnd = i + 1;
+    }
+    if (braceDepth !== 0)
+        return null;
+    return {
+        anchorIdx,
+        funcName: lastFunc[1],
+        params: lastFunc[2],
+        bodyStart,
+        bodyEnd,
+        body: content.substring(bodyStart, bodyEnd),
+    };
+}
+// ── Extension 1: override-script ─────────────────────────────────────────
+const overrideScript = {
+    id: 'override-script',
+    version: 1,
+    alwaysApply: true,
+    apply(controlUiDir) {
+        if (!existsSync(OVERRIDE_ASSET_URL)) {
+            logger.warn('[ui-ext:regex] override-script: asset missing');
+            return false;
+        }
+        const dest = join(controlUiDir, 'openagent-override.js');
+        if (existsSync(dest)) {
+            const srcContent = readFileSync(OVERRIDE_ASSET_URL, 'utf-8');
+            const destContent = readFileSync(dest, 'utf-8');
+            if (srcContent === destContent) {
+                logger.debug('[ui-ext:regex] override-script: content unchanged, skip');
+                return true;
+            }
+        }
+        copyFileSync(OVERRIDE_ASSET_URL, dest);
+        logger.info('[ui-ext:regex] override-script: deployed openagent-override.js');
+        return true;
+    },
+    revert(controlUiDir) {
+        const dest = join(controlUiDir, 'openagent-override.js');
+        if (existsSync(dest)) {
+            unlinkSync(dest);
+            logger.info('[ui-ext:regex] override-script: removed');
+        }
+    },
+};
+// ── Extension 2: html-script-tag ─────────────────────────────────────────
+const htmlScriptTag = {
+    id: 'html-script-tag',
+    version: 4,
+    alwaysApply: true,
+    apply(controlUiDir) {
+        const indexPath = join(controlUiDir, 'index.html');
+        if (!existsSync(indexPath)) {
+            logger.warn('[ui-ext:regex] html-script-tag: index.html not found');
+            return false;
+        }
+        let html = readFileSync(indexPath, 'utf-8');
+        const htmlMarker = `<!--openagent:${this.id}-->`;
+        const overrideHash = getOverrideAssetHash();
+        const scriptTag = `${htmlMarker}<script src="./openagent-override.js?v=${overrideHash}"></script>`;
+        const markedScriptPattern = /(?:\/\*openagent:html-script-tag\*\/|<!--openagent:html-script-tag-->)<script[^>]*openagent-override[^>]*><\/script>\n?\s*/g;
+        if (html.includes(htmlMarker) || hasMarker(html, this.id)) {
+            const nextHtml = html.replace(markedScriptPattern, `${scriptTag}\n    `);
+            if (nextHtml === html) {
+                logger.debug('[ui-ext:regex] html-script-tag: already applied');
+            }
+            else {
+                writeFileSync(indexPath, nextHtml, 'utf-8');
+                logger.info(`[ui-ext:regex] html-script-tag: updated override cache-bust (${overrideHash})`);
+            }
+            return true;
+        }
+        const oldScriptPattern = /<script[^>]*openagent-override[^>]*><\/script>\n?\s*/g;
+        if (oldScriptPattern.test(html)) {
+            html = html.replace(oldScriptPattern, '');
+        }
+        const viteAnchor = '<script type="module" crossorigin src="./assets/index-';
+        const anchorIdx = html.indexOf(viteAnchor);
+        if (anchorIdx >= 0) {
+            html = html.substring(0, anchorIdx) + scriptTag + '\n    ' + html.substring(anchorIdx);
+        }
+        else {
+            html = html.replace('</head>', `${scriptTag}\n</head>`);
+        }
+        writeFileSync(indexPath, html, 'utf-8');
+        logger.info('[ui-ext:regex] html-script-tag: injected');
+        return true;
+    },
+    revert(controlUiDir) {
+        const indexPath = join(controlUiDir, 'index.html');
+        if (!existsSync(indexPath))
+            return;
+        let html = readFileSync(indexPath, 'utf-8');
+        html = html.replace(/(?:\/\*openagent:html-script-tag\*\/|<!--openagent:html-script-tag-->)<script[^>]*openagent-override[^>]*><\/script>\n?\s*/g, '');
+        writeFileSync(indexPath, html, 'utf-8');
+        logger.info('[ui-ext:regex] html-script-tag: removed');
+    },
+};
+// ── Extension 4: toolcard-render（ToolCard DOM 结构锚点定位）────────────────
+const toolcardRender = {
+    id: 'toolcard-render',
+    version: 6,
+    sharedFile: 'index-bundle',
+    apply(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (!bundlePath)
+            return false;
+        let content = readFileSync(bundlePath, 'utf-8');
+        if (hasMarker(content, this.id)) {
+            return true;
+        }
+        if (!backupFile(bundlePath))
+            return false;
+        // 用 chat-tool-card__header 做 primary anchor — 3.28/4.11/latest 均存在且唯一
+        const classAnchor = 'chat-tool-card__header';
+        const innerFn = findFunctionByAnchor(content, classAnchor);
+        if (!innerFn) {
+            logger.warn('[ui-ext:regex] toolcard-render: chat-tool-card__header anchor not found');
+            return false;
+        }
+        const funcName = innerFn.funcName;
+        const params = innerFn.params;
+        const fnBody = innerFn.body;
+        // 校验：函数体必须包含 ToolCard DOM 结构
+        if (!fnBody.includes('chat-tool-card')) {
+            logger.warn('[ui-ext:regex] toolcard-render: candidate function does not contain chat-tool-card class');
+            return false;
+        }
+        // 排除 markdown builder：如果函数体包含 markdown builder 特征，说明定位到了错误函数
+        if (fnBody.includes('### Tool output') && !fnBody.includes('chat-tool-card__header')) {
+            logger.warn('[ui-ext:regex] toolcard-render: candidate function looks like markdown builder, not ToolCard renderer');
+            return false;
+        }
+        // 找 Lit html tag: return X`...` — 只在候选函数体内搜索
+        const returnTagMatch = fnBody.match(/return\s+([a-zA-Z_$]\w*)\s*`/);
+        if (!returnTagMatch) {
+            logger.warn('[ui-ext:regex] toolcard-render: Lit html tag not found in candidate function');
+            return false;
+        }
+        const litHtmlVar = returnTagMatch[1];
+        const paramParts = params.split(',').map((s) => s.trim());
+        const cardParam = paramParts[0] || 'e';
+        const sidebarParam = paramParts[1] || undefined;
+        const sidebarArg = sidebarParam || 'undefined';
+        const marker = makeMarker(this.id);
+        const hook = `${marker}if(window.__openagentRenderToolCard){let __cl=window.__openagentRenderToolCard(${cardParam},${sidebarArg});if(__cl)return ${litHtmlVar}\`\${__cl}\`}`;
+        content = content.substring(0, innerFn.bodyStart) + hook + content.substring(innerFn.bodyStart);
+        // 4.11+ introduced an outer manual-collapse renderer. The inner ToolCard
+        // renderer above only runs after the user expands the native card, so patch
+        // the wrapper too to let OpenAgent own collapsed remote-agent cards from the
+        // first render.
+        const wrapperAnchor = 'chat-tool-msg-collapse--manual';
+        const hasManualCollapseWrapper = content.includes(wrapperAnchor);
+        let patchedWrapper = false;
+        if (hasManualCollapseWrapper) {
+            const wrapperFn = findFunctionByAnchor(content, wrapperAnchor);
+            if (!wrapperFn) {
+                logger.warn('[ui-ext:regex] toolcard-render: manual collapse wrapper function not found');
+                return false;
+            }
+            if (!wrapperFn.body.includes('chat-tool-msg-body') || !wrapperFn.body.includes('onToggleExpanded')) {
+                logger.warn('[ui-ext:regex] toolcard-render: manual collapse wrapper shape mismatch');
+                return false;
+            }
+            const wrapperReturnTagMatch = wrapperFn.body.match(/return\s+([a-zA-Z_$]\w*)\s*`/);
+            if (!wrapperReturnTagMatch) {
+                logger.warn('[ui-ext:regex] toolcard-render: manual collapse Lit html tag not found');
+                return false;
+            }
+            const wrapperHtmlVar = wrapperReturnTagMatch[1];
+            const wrapperParams = wrapperFn.params.split(',').map((s) => s.trim());
+            const wrapperCardParam = wrapperParams[0] || 'e';
+            const wrapperOptionsParam = wrapperParams[1] || '';
+            const wrapperSidebarArg = wrapperOptionsParam ? `${wrapperOptionsParam}&&${wrapperOptionsParam}.onOpenSidebar` : 'undefined';
+            const wrapperHook = `${marker}if(window.__openagentRenderToolCard){let __cl=window.__openagentRenderToolCard(${wrapperCardParam},${wrapperSidebarArg});if(__cl)return ${wrapperHtmlVar}\`\${__cl}\`}`;
+            content = content.substring(0, wrapperFn.bodyStart) + wrapperHook + content.substring(wrapperFn.bodyStart);
+            patchedWrapper = true;
+            logger.info(`[ui-ext:regex] toolcard-render: patched manual wrapper ${wrapperFn.funcName}(${wrapperFn.params.substring(0, 20)}) html=${wrapperHtmlVar}`);
+        }
+        // 4.11+ also renders tool-result messages through the grouped message
+        // renderer itself instead of nb(). That path only calls the inner ToolCard
+        // renderer after the user expands the native "Tool output" row. Patch the
+        // grouped message function so OpenAgent result cards are owned immediately.
+        const toolMessageAnchor = 'toolmsg:${';
+        let patchedToolMessageWrapper = false;
+        if (content.includes(toolMessageAnchor)) {
+            const toolMessageFn = findFunctionByAnchor(content, toolMessageAnchor, 8000);
+            if (!toolMessageFn) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message wrapper function not found');
+                return false;
+            }
+            if (!toolMessageFn.body.includes('chat-tool-msg-collapse--manual')
+                || !toolMessageFn.body.includes('chat-tool-msg-body')) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message wrapper shape mismatch');
+                return false;
+            }
+            const toolMessageReturnTagMatch = toolMessageFn.body.match(/return\s+([a-zA-Z_$]\w*)\s*`/);
+            if (!toolMessageReturnTagMatch) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message Lit html tag not found');
+                return false;
+            }
+            const toolMessageHtmlVar = toolMessageReturnTagMatch[1];
+            const singleCardMatch = toolMessageFn.body.match(/(?:let\s+|,)([a-zA-Z_$]\w*)=([a-zA-Z_$]\w*)\.length===1\?\2\[0\]:null,\w+=\1&&!([a-zA-Z_$]\w*)&&!([a-zA-Z_$]\w*)\?/);
+            if (!singleCardMatch) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message single-card guard not found');
+                return false;
+            }
+            const cardsVar = singleCardMatch[2];
+            const mediaVar = singleCardMatch[4];
+            const chatBubbleClassMatch = toolMessageFn.body.match(/[,;]([a-zA-Z_$]\w*)=\[`chat-bubble`,/);
+            if (!chatBubbleClassMatch) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message chat-bubble class var not found');
+                return false;
+            }
+            const chatBubbleClassVar = chatBubbleClassMatch[1];
+            const toolMessageParams = toolMessageFn.params.split(',').map((s) => s.trim());
+            const toolMessageSidebarArg = toolMessageParams[3] || 'undefined';
+            const toolMessageReturnIdx = toolMessageFn.body.indexOf(`return ${toolMessageHtmlVar}\``);
+            if (toolMessageReturnIdx < 0) {
+                logger.warn('[ui-ext:regex] toolcard-render: tool message return anchor not found');
+                return false;
+            }
+            const toolMessageHook = `${marker}let __openagentToolMsgCard=null;if(!${mediaVar}&&window.__openagentRenderToolCard){for(let __openagentI=${cardsVar}.length-1;__openagentI>=0&&!__openagentToolMsgCard;__openagentI--){let __openagentCandidate=${cardsVar}[__openagentI];if(__openagentCandidate&&(__openagentCandidate.outputText||__openagentCandidate.text))__openagentToolMsgCard=window.__openagentRenderToolCard(__openagentCandidate,${toolMessageSidebarArg})}for(let __openagentI=0;__openagentI<${cardsVar}.length&&!__openagentToolMsgCard;__openagentI++){__openagentToolMsgCard=window.__openagentRenderToolCard(${cardsVar}[__openagentI],${toolMessageSidebarArg})}}if(__openagentToolMsgCard)return ${toolMessageHtmlVar}\`<div class="\${${chatBubbleClassVar}}">\${__openagentToolMsgCard}</div>\`;`;
+            const toolMessageInsertAt = toolMessageFn.bodyStart + toolMessageReturnIdx;
+            content = content.substring(0, toolMessageInsertAt) + toolMessageHook + content.substring(toolMessageInsertAt);
+            patchedToolMessageWrapper = true;
+            logger.info(`[ui-ext:regex] toolcard-render: patched tool message wrapper ${toolMessageFn.funcName}(${toolMessageFn.params.substring(0, 20)}) html=${toolMessageHtmlVar}`);
+        }
+        writeFileSync(bundlePath, content, 'utf-8');
+        logger.info(`[ui-ext:regex] toolcard-render: patched ${funcName}(${params.substring(0, 20)}) html=${litHtmlVar}${patchedWrapper ? ' + wrapper' : ''}${patchedToolMessageWrapper ? ' + tool-message' : ''}`);
+        return true;
+    },
+    revert(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (bundlePath) {
+            restoreFile(bundlePath);
+        }
+    },
+};
+// ── Extension 5: toolcallid-propagate（正则定位，双规则锚点）──────────────
+const toolcallidPropagate = {
+    id: 'toolcallid-propagate',
+    version: 4,
+    sharedFile: 'index-bundle',
+    apply(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (!bundlePath)
+            return false;
+        let content = readFileSync(bundlePath, 'utf-8');
+        if (hasMarker(content, this.id)) {
+            return true;
+        }
+        if (!backupFile(bundlePath))
+            return false;
+        // 双规则锚点定位 extractToolCards
+        const ruleV4 = /\[`toolcall`,`tool_call`,`tooluse`,`tool_use`\]\.includes\(\w+\)/;
+        const ruleV3 = /(\w+)\.push\(\{kind:`call`,name:/;
+        const anchorMatch = content.match(ruleV4) || content.match(ruleV3);
+        if (!anchorMatch) {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: anchor not found');
+            return false;
+        }
+        // 向前找函数声明（支持多参数+默认值）
+        const anchorPos = anchorMatch.index;
+        const lookBack = content.substring(Math.max(0, anchorPos - 3000), anchorPos);
+        const funcDeclRe = /function\s+(\w+)\(([^)]+)\)\{/g;
+        let lastFuncDecl = null;
+        let fm;
+        while ((fm = funcDeclRe.exec(lookBack)) !== null)
+            lastFuncDecl = fm;
+        if (!lastFuncDecl) {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: function decl not found');
+            return false;
+        }
+        const funcStartGlobal = Math.max(0, anchorPos - 3000) + lastFuncDecl.index;
+        const msgParam = lastFuncDecl[2].split(',')[0].trim();
+        const bodyStart = funcStartGlobal + lastFuncDecl[0].length;
+        // 找函数结束
+        let braceDepth = 1;
+        let funcEnd = -1;
+        for (let i = bodyStart; i < content.length && i < bodyStart + 5000; i++) {
+            if (content[i] === '{')
+                braceDepth++;
+            if (content[i] === '}') {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    funcEnd = i + 1;
+                    break;
+                }
+            }
+        }
+        if (funcEnd < 0) {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: function end not found');
+            return false;
+        }
+        const funcBody = content.substring(bodyStart, funcEnd);
+        // 提取变量名
+        const mVarMatch = funcBody.match(/let\s+(\w+)\s*=\s*\w+\s*,/);
+        if (!mVarMatch) {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: message alias not found');
+            return false;
+        }
+        const mVar = mVarMatch[1];
+        const cardsMatch = funcBody.match(/,(\w+)=\[\](?:;|,)/);
+        if (!cardsMatch) {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: cards array not found');
+            return false;
+        }
+        const cardsVar = cardsMatch[1];
+        // 循环变量：for-of 或 for-index
+        const forOfMatches = [...funcBody.matchAll(/for\(let\s+(\w+)\s+of\s+\w+\)/g)];
+        let callLoopVar, resultLoopVar;
+        if (forOfMatches.length > 0) {
+            callLoopVar = forOfMatches[0]?.[1] ?? null;
+            resultLoopVar = forOfMatches[1]?.[1] ?? forOfMatches[0]?.[1] ?? null;
+        }
+        else {
+            const indexLoopMatch = funcBody.match(/for\(let\s+(\w+)=0;\1<(\w+)\.length;\1\+\+\)/);
+            if (indexLoopMatch) {
+                const loopBodyStart = funcBody.indexOf(indexLoopMatch[0]) + indexLoopMatch[0].length;
+                const loopBody = funcBody.substring(loopBodyStart, loopBodyStart + 100);
+                const elemMatch = loopBody.match(/\{let\s+(\w+)=/);
+                callLoopVar = elemMatch ? elemMatch[1] : null;
+                resultLoopVar = callLoopVar;
+            }
+            else {
+                callLoopVar = null;
+                resultLoopVar = null;
+            }
+        }
+        logger.debug(`[ui-ext:regex] toolcallid-propagate: mVar=${mVar} cards=${cardsVar} callLoop=${callLoopVar} resultLoop=${resultLoopVar}`);
+        // 计算注入内容
+        const marker = makeMarker(this.id);
+        const tcidCapture = `${marker}var __tcid=(typeof ${mVar}.toolCallId==='string'&&${mVar}.toolCallId)||(typeof ${mVar}.tool_call_id==='string'&&${mVar}.tool_call_id)||'';`;
+        const inlinePatchCall = callLoopVar
+            ? `,toolCallId:__tcid||${callLoopVar}.id||${callLoopVar}.toolCallId||${callLoopVar}.tool_call_id||''`
+            : `,toolCallId:__tcid`;
+        const inlinePatchResult = resultLoopVar
+            ? `,toolCallId:__tcid||${resultLoopVar}.tool_use_id||''`
+            : `,toolCallId:__tcid`;
+        const inlinePatchFallback = `,toolCallId:${mVar}.toolCallId||${mVar}.tool_call_id||''`;
+        // 找 cards 数组初始化位置
+        const arrInitPattern = `,${cardsVar}=[];`;
+        let arrInitIdx = funcBody.indexOf(arrInitPattern);
+        if (arrInitIdx < 0) {
+            // v4.11+: 可能是 ,i=[]（后接分号或逗号之前的位置不同）
+            const altPattern = `,${cardsVar}=[]`;
+            arrInitIdx = funcBody.indexOf(altPattern);
+            if (arrInitIdx < 0) {
+                logger.warn('[ui-ext:regex] toolcallid-propagate: cards init not found');
+                return false;
+            }
+            // 找到 ] 后面的分隔符位置
+            arrInitIdx += altPattern.length;
+            // captureInsertOffset 在 ; 或 , 之后
+        }
+        else {
+            arrInitIdx += arrInitPattern.length;
+        }
+        const captureInsertOffset = bodyStart + arrInitIdx;
+        // 找 push 位置（支持 kind: 前缀和无前缀）
+        let pushAnchor = `${cardsVar}.push({kind:`;
+        if (funcBody.indexOf(pushAnchor) < 0) {
+            pushAnchor = `${cardsVar}.push({`;
+        }
+        const literalCloseOffsets = [];
+        let searchPos = 0;
+        while (literalCloseOffsets.length < 4) {
+            const idx = funcBody.indexOf(pushAnchor, searchPos);
+            if (idx < 0)
+                break;
+            const pushParenStart = bodyStart + idx + `${cardsVar}.push`.length;
+            const objClose = findObjectLiteralClose(content, pushParenStart);
+            if (objClose < 0) {
+                logger.warn(`[ui-ext:regex] toolcallid-propagate: object literal close not found at ${idx}`);
+                return false;
+            }
+            literalCloseOffsets.push(objClose);
+            searchPos = idx + pushAnchor.length;
+        }
+        if (literalCloseOffsets.length < 2) {
+            logger.warn(`[ui-ext:regex] toolcallid-propagate: expected >=2 push sites, found ${literalCloseOffsets.length}`);
+            return false;
+        }
+        // guard 扩展 — P0: guard patch 必须成功，否则 result card 无法识别 message-level tool result
+        // Shape A (old): &&!cards.some(...)
+        // Shape B (4.11/latest): &&cards.length===0
+        const guardAnchorA = `&&!${cardsVar}.some(`;
+        const guardAnchorB = `&&${cardsVar}.length===0`;
+        const guardIdxA = funcBody.indexOf(guardAnchorA);
+        const guardIdxB = funcBody.indexOf(guardAnchorB);
+        let guardPatch = null;
+        if (guardIdxA >= 0) {
+            // Shape A: if(<original> && !cards.some(...)) { ... }
+            let ifStart = guardIdxA - 1;
+            while (ifStart > 0 && funcBody.substring(ifStart, ifStart + 3) !== 'if(')
+                ifStart--;
+            if (funcBody.substring(ifStart, ifStart + 3) !== 'if(') {
+                logger.warn('[ui-ext:regex] toolcallid-propagate: Shape A guard if() not found');
+                return false;
+            }
+            const originalGuard = funcBody.substring(ifStart + 3, guardIdxA);
+            const expandedGuard = `(${originalGuard}||typeof ${mVar}.toolCallId==\`string\`||typeof ${mVar}.tool_call_id==\`string\`||typeof ${mVar}.toolName==\`string\`||typeof ${mVar}.tool_name==\`string\`)`;
+            guardPatch = [bodyStart + ifStart + 3, originalGuard, expandedGuard];
+            logger.debug('[ui-ext:regex] toolcallid-propagate: using Shape A guard');
+        }
+        else if (guardIdxB >= 0) {
+            // Shape B: if((<original>) && cards.length===0) { ... }
+            let ifStart = guardIdxB - 1;
+            // Shape B may have extra parens: if((...) && cards.length===0)
+            // Walk back past closing paren to find the if(
+            while (ifStart > 0 && funcBody.substring(ifStart, ifStart + 3) !== 'if(')
+                ifStart--;
+            if (funcBody.substring(ifStart, ifStart + 3) !== 'if(') {
+                logger.warn('[ui-ext:regex] toolcallid-propagate: Shape B guard if() not found');
+                return false;
+            }
+            // The original condition is between if( and &&cards.length===0
+            // It might be wrapped: if((<cond>)&&cards.length===0)
+            let originalGuard = funcBody.substring(ifStart + 3, guardIdxB);
+            // Strip outer parens if present: (expr) → expr
+            if (originalGuard.startsWith('(') && originalGuard.endsWith(')')) {
+                originalGuard = originalGuard.substring(1, originalGuard.length - 1);
+            }
+            const expandedGuard = `(${originalGuard}||typeof ${mVar}.toolCallId==\`string\`||typeof ${mVar}.tool_call_id==\`string\`||typeof ${mVar}.toolName==\`string\`||typeof ${mVar}.tool_name==\`string\`)`;
+            guardPatch = [bodyStart + ifStart + 3, funcBody.substring(ifStart + 3, guardIdxB), expandedGuard];
+            logger.debug('[ui-ext:regex] toolcallid-propagate: using Shape B guard');
+        }
+        else {
+            logger.warn('[ui-ext:regex] toolcallid-propagate: neither Shape A nor Shape B guard found — refusing to patch');
+            return false;
+        }
+        // 从后往前插入
+        const insertions = [];
+        if (literalCloseOffsets.length >= 3) {
+            insertions.push([literalCloseOffsets[2], inlinePatchFallback]);
+        }
+        if (literalCloseOffsets.length >= 2) {
+            insertions.push([literalCloseOffsets[1], inlinePatchResult]);
+        }
+        insertions.push([literalCloseOffsets[0], inlinePatchCall]);
+        insertions.push([captureInsertOffset, tcidCapture]);
+        if (guardPatch) {
+            const [offset, oldText, newText] = guardPatch;
+            const globalGuardIdx = content.indexOf(oldText, offset);
+            if (globalGuardIdx >= 0 && globalGuardIdx < offset + oldText.length + 10) {
+                content = content.substring(0, globalGuardIdx) + newText + content.substring(globalGuardIdx + oldText.length);
+                const delta = newText.length - oldText.length;
+                for (let i = 0; i < insertions.length; i++) {
+                    if (insertions[i][0] > globalGuardIdx) {
+                        insertions[i] = [insertions[i][0] + delta, insertions[i][1]];
+                    }
+                }
+            }
+        }
+        for (const [offset, text] of insertions) {
+            content = content.substring(0, offset) + text + content.substring(offset);
+        }
+        writeFileSync(bundlePath, content, 'utf-8');
+        const pushCount = literalCloseOffsets.length;
+        const patchCount = (guardPatch ? 1 : 0) + pushCount + 1;
+        logger.info(`[ui-ext:regex] toolcallid-propagate: patched ${patchCount} injection points (pushes=${pushCount})`);
+        return true;
+    },
+    revert(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (bundlePath) {
+            restoreFile(bundlePath);
+        }
+    },
+};
+// ── Extension 6: remote-agent-message-short-circuit（三策略 A/B/C）───────
+const remoteAgentMessageShortCircuit = {
+    id: 'remote-agent-message-short-circuit',
+    version: 2,
+    sharedFile: 'index-bundle',
+    apply(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (!bundlePath)
+            return false;
+        let content = readFileSync(bundlePath, 'utf-8');
+        if (hasMarker(content, this.id)) {
+            return true;
+        }
+        if (!backupFile(bundlePath))
+            return false;
+        // 找 showToolCalls 赋值 → 提取 toolCardsVar / hasToolCardsVar
+        const assignRe = /(\w+)=\w+\.showToolCalls[^;]*\(\w+(?:,\w+)?\)\s*:\s*\[\]\s*,\s*(\w+)\s*=\s*\1\.length\s*>\s*0/;
+        const assignMatch = content.match(assignRe);
+        if (!assignMatch) {
+            logger.warn('[ui-ext:regex] remote-agent-msg: showToolCalls assignment not found');
+            return false;
+        }
+        const toolCardsVar = assignMatch[1];
+        const hasToolCardsVar = assignMatch[2];
+        const marker = makeMarker(this.id);
+        // 策略A (v3.23~v4.10): if(!markdown&&hasToolCards&&isToolResult)
+        const ifReA = new RegExp(`if\\(!(\\w+)&&${hasToolCardsVar}&&(\\w+)\\)`);
+        const ifMatchA = content.match(ifReA);
+        if (ifMatchA) {
+            const markdownVar = ifMatchA[1];
+            const isToolResultVar = ifMatchA[2];
+            const patched = `if(${marker}(!${markdownVar}||window.__openagentOwnsToolCards&&window.__openagentOwnsToolCards(${toolCardsVar}))&&${hasToolCardsVar}&&${isToolResultVar})`;
+            content = content.substring(0, ifMatchA.index) + patched + content.substring(ifMatchA.index + ifMatchA[0].length);
+            writeFileSync(bundlePath, content, 'utf-8');
+            logger.info(`[ui-ext:regex] remote-agent-msg: patched (strategy A, md=${markdownVar})`);
+            return true;
+        }
+        // 策略C (2026.4.x): if(!VAR.showToolCalls&&...toolresult...)continue
+        // 直接匹配 continue 跳过语句，注入 openagentOwnsToolCards 条件
+        const continueRe = /if\(!(\w+)\.showToolCalls&&(\w+)\.role\.toLowerCase\(\)===`toolresult`\)continue/;
+        const continueMatch = content.match(continueRe);
+        if (continueMatch) {
+            const scVar = continueMatch[1];
+            const roleVar = continueMatch[2];
+            const patched = `if(!${scVar}.showToolCalls&&!window.__openagentOwnsToolCards?.(${toolCardsVar})&&${roleVar}.role.toLowerCase()===\`toolresult\`)continue`;
+            content = content.substring(0, continueMatch.index) + marker + patched + content.substring(continueMatch.index + continueMatch[0].length);
+            writeFileSync(bundlePath, content, 'utf-8');
+            logger.info(`[ui-ext:regex] remote-agent-msg: patched (strategy C, sc=${scVar})`);
+            return true;
+        }
+        // 策略B (v4.11~v4.1x fallback): compound = hasToolCards && (showToolCalls ?? !0)
+        const compoundRe = new RegExp(`(\\w+)=${hasToolCardsVar}&&\\(\\w+\\.showToolCalls\\?\\?!0\\)`);
+        const compoundMatch = content.match(compoundRe);
+        if (!compoundMatch) {
+            logger.warn('[ui-ext:regex] remote-agent-msg: all strategies (A/C/B) failed');
+            return false;
+        }
+        const compoundVar = compoundMatch[1];
+        const ifReB = new RegExp(`if\\(!(\\w+)&&!${compoundVar}&&`);
+        const ifMatchB = content.match(ifReB);
+        if (!ifMatchB) {
+            logger.warn(`[ui-ext:regex] remote-agent-msg: compound var ${compoundVar} found but if not matched`);
+            return false;
+        }
+        const markdownVarB = ifMatchB[1];
+        const patchedCond = `if(${marker}(!${markdownVarB}||window.__openagentOwnsToolCards&&window.__openagentOwnsToolCards(${toolCardsVar}))&&!${compoundVar}&&`;
+        content = content.substring(0, ifMatchB.index) + patchedCond + content.substring(ifMatchB.index + ifMatchB[0].length);
+        writeFileSync(bundlePath, content, 'utf-8');
+        logger.info(`[ui-ext:regex] remote-agent-msg: patched (strategy B, md=${markdownVarB}, compound=${compoundVar})`);
+        return true;
+    },
+    revert(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (bundlePath) {
+            restoreFile(bundlePath);
+        }
+    },
+};
+// ── Extension 7: mention-hooks ───────────────────────────────────────────
+const mentionHooks = {
+    id: 'mention-hooks',
+    version: 2,
+    sharedFile: 'index-bundle',
+    apply(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (!bundlePath)
+            return false;
+        let content = readFileSync(bundlePath, 'utf-8');
+        if (hasMarker(content, this.id)) {
+            return true;
+        }
+        if (!backupFile(bundlePath))
+            return false;
+        // 注入点 A: handleKeyDown
+        // 匹配 return;if(key===Enter&&!shiftKey){if(isComposing 结构
+        // 兼容 2026.4.x: return;if (无 }) 和旧版 ;return}if (有 })
+        const keydownRe = /;return\}?if\(([a-zA-Z_$][a-zA-Z0-9_$]*)\.key===`Enter`&&!\1\.shiftKey\)\{if\(\1\.isComposing/;
+        const keydownMatch = content.match(keydownRe);
+        if (!keydownMatch) {
+            logger.warn('[ui-ext:regex] mention-hooks: keydown anchor not found');
+            return false;
+        }
+        const eventParam = keydownMatch[1];
+        const keydownInsertIdx = content.indexOf(keydownMatch[0]) + keydownMatch[0].indexOf('if(');
+        const markerA = makeMarker(this.id);
+        const hookA = `${markerA}if(window.__clMention?.onKeyDown(${eventParam}))return;`;
+        content = content.substring(0, keydownInsertIdx) + hookA + content.substring(keydownInsertIdx);
+        // 注入点 B: handleInput — 支持两种形态
+        // Shape A (old): .onDraftChange(target.value)}}
+        // Shape B (4.11/latest): .onDraftChange(target.value)  (在 arrow function 内，无 }})
+        const inputReA = /\.onDraftChange\(([a-zA-Z_$][a-zA-Z0-9_$]*)\.value\)\}\}/;
+        const inputReB = /\.onDraftChange\(([a-zA-Z_$][a-zA-Z0-9_$]*)\.value\)/;
+        let inputMatch = content.match(inputReA);
+        let inputShape = 'A';
+        if (!inputMatch) {
+            inputMatch = content.match(inputReB);
+            inputShape = 'B';
+        }
+        if (!inputMatch) {
+            logger.warn('[ui-ext:regex] mention-hooks: input anchor not found (neither Shape A nor B)');
+            return false;
+        }
+        const targetVar = inputMatch[1];
+        const inputAnchorIdx = content.indexOf(inputMatch[0]);
+        // 计算 onDraftChange(x.value) 调用结束位置
+        const draftCallEnd = inputShape === 'A'
+            ? inputAnchorIdx + inputMatch[0].length - 2 // 在 }} 之前
+            : inputAnchorIdx + inputMatch[0].length; // 在 ) 之后
+        const hookB = `;window.__clMention?.onInput?.(${targetVar})`;
+        content = content.substring(0, draftCallEnd) + hookB + content.substring(draftCallEnd);
+        writeFileSync(bundlePath, content, 'utf-8');
+        logger.info(`[ui-ext:regex] mention-hooks: injected (event=${eventParam}, target=${targetVar})`);
+        return true;
+    },
+    revert(controlUiDir) {
+        const bundlePath = resolveBundlePath(controlUiDir);
+        if (bundlePath) {
+            restoreFile(bundlePath);
+        }
+    },
+};
+// ── Registry ─────────────────────────────────────────────────────────────
+export const UI_EXTENSIONS = [
+    overrideScript,
+    htmlScriptTag,
+    toolcardRender,
+    toolcallidPropagate,
+    remoteAgentMessageShortCircuit,
+    mentionHooks,
+];