/**
 * 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';
import type { UIExtension } from './types.js';

// ── 常量 ──────────────────────────────────────────────────────────────────

const OVERRIDE_ASSET_URL = new URL('../assets/clawlink-override.js', import.meta.url);

function getOverrideAssetHash(): string {
  return createHash('sha256')
    .update(readFileSync(OVERRIDE_ASSET_URL))
    .digest('hex')
    .slice(0, 12);
}

// ── 辅助函数 ──────────────────────────────────────────────────────────────

/** 获取 bundle 路径（不要求 source map 存在）。 */
function resolveBundlePath(controlUiDir: string): string | null {
  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: string, pushParenStart: number): number {
  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: string,
  anchor: string,
  lookBack = 5000,
): {
  anchorIdx: number;
  funcName: string;
  params: string;
  bodyStart: number;
  bodyEnd: number;
  body: string;
} | null {
  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: RegExpExecArray | null = null;
  let funcMatch: RegExpExecArray | null;
  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: UIExtension = {
  id: 'override-script',
  version: 1,
  alwaysApply: true,

  apply(controlUiDir: string): boolean {
    if (!existsSync(OVERRIDE_ASSET_URL)) {
      logger.warn('[ui-ext:regex] override-script: asset missing');
      return false;
    }
    const dest = join(controlUiDir, 'clawlink-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 clawlink-override.js');
    return true;
  },

  revert(controlUiDir: string): void {
    const dest = join(controlUiDir, 'clawlink-override.js');
    if (existsSync(dest)) {
      unlinkSync(dest);
      logger.info('[ui-ext:regex] override-script: removed');
    }
  },
};

// ── Extension 2: html-script-tag ─────────────────────────────────────────

const htmlScriptTag: UIExtension = {
  id: 'html-script-tag',
  version: 4,
  alwaysApply: true,

  apply(controlUiDir: string): boolean {
    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 = `<!--clawlink:${this.id}-->`;
    const overrideHash = getOverrideAssetHash();
    const scriptTag = `${htmlMarker}<script src="./clawlink-override.js?v=${overrideHash}"></script>`;
    const markedScriptPattern = /(?:\/\*clawlink:html-script-tag\*\/|<!--clawlink:html-script-tag-->)<script[^>]*clawlink-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[^>]*clawlink-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: string): void {
    const indexPath = join(controlUiDir, 'index.html');
    if (!existsSync(indexPath)) return;
    let html = readFileSync(indexPath, 'utf-8');
    html = html.replace(/(?:\/\*clawlink:html-script-tag\*\/|<!--clawlink:html-script-tag-->)<script[^>]*clawlink-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: UIExtension = {
  id: 'toolcard-render',
  version: 6,
  sharedFile: 'index-bundle',

  apply(controlUiDir: string): boolean {
    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: string) => 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.__clawlinkRenderToolCard){let __cl=window.__clawlinkRenderToolCard(${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 ClawLink 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: string) => s.trim());
      const wrapperCardParam = wrapperParams[0] || 'e';
      const wrapperOptionsParam = wrapperParams[1] || '';
      const wrapperSidebarArg = wrapperOptionsParam ? `${wrapperOptionsParam}&&${wrapperOptionsParam}.onOpenSidebar` : 'undefined';
      const wrapperHook = `${marker}if(window.__clawlinkRenderToolCard){let __cl=window.__clawlinkRenderToolCard(${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 ClawLink 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: string) => 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 __clawlinkToolMsgCard=null;if(!${mediaVar}&&window.__clawlinkRenderToolCard){for(let __clawlinkI=${cardsVar}.length-1;__clawlinkI>=0&&!__clawlinkToolMsgCard;__clawlinkI--){let __clawlinkCandidate=${cardsVar}[__clawlinkI];if(__clawlinkCandidate&&(__clawlinkCandidate.outputText||__clawlinkCandidate.text))__clawlinkToolMsgCard=window.__clawlinkRenderToolCard(__clawlinkCandidate,${toolMessageSidebarArg})}for(let __clawlinkI=0;__clawlinkI<${cardsVar}.length&&!__clawlinkToolMsgCard;__clawlinkI++){__clawlinkToolMsgCard=window.__clawlinkRenderToolCard(${cardsVar}[__clawlinkI],${toolMessageSidebarArg})}}if(__clawlinkToolMsgCard)return ${toolMessageHtmlVar}\`<div class="\${${chatBubbleClassVar}}">\${__clawlinkToolMsgCard}</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: string): void {
    const bundlePath = resolveBundlePath(controlUiDir);
    if (bundlePath) { restoreFile(bundlePath); }
  },
};


// ── Extension 5: toolcallid-propagate（正则定位，双规则锚点）──────────────

const toolcallidPropagate: UIExtension = {
  id: 'toolcallid-propagate',
  version: 4,
  sharedFile: 'index-bundle',

  apply(controlUiDir: string): boolean {
    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: RegExpExecArray | null = null;
    let fm: RegExpExecArray | null;
    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: string | null, resultLoopVar: string | null;
    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: number[] = [];
    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: [number, string, string] | null = 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: Array<[number, string]> = [];
    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: string): void {
    const bundlePath = resolveBundlePath(controlUiDir);
    if (bundlePath) { restoreFile(bundlePath); }
  },
};


// ── Extension 6: remote-agent-message-short-circuit（正则定位，双策略A+B）─

const remoteAgentMessageShortCircuit: UIExtension = {
  id: 'remote-agent-message-short-circuit',
  version: 2,
  sharedFile: 'index-bundle',

  apply(controlUiDir: string): boolean {
    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 赋值
    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 pattern 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.__clawlinkOwnsToolCards&&window.__clawlinkOwnsToolCards(${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;
    }

    // 策略B (v4.11+): 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: both strategies 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.__clawlinkOwnsToolCards&&window.__clawlinkOwnsToolCards(${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: string): void {
    const bundlePath = resolveBundlePath(controlUiDir);
    if (bundlePath) { restoreFile(bundlePath); }
  },
};

// ── Extension 7: mention-hooks ───────────────────────────────────────────

const mentionHooks: UIExtension = {
  id: 'mention-hooks',
  version: 2,
  sharedFile: 'index-bundle',

  apply(controlUiDir: string): boolean {
    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
    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]) + ';return}'.length;
    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' | 'B' = '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: string): void {
    const bundlePath = resolveBundlePath(controlUiDir);
    if (bundlePath) { restoreFile(bundlePath); }
  },
};

// ── Registry ─────────────────────────────────────────────────────────────

export const UI_EXTENSIONS: UIExtension[] = [
  overrideScript,
  htmlScriptTag,
  toolcardRender,
  toolcallidPropagate,
  remoteAgentMessageShortCircuit,
  mentionHooks,
];