@szc-ft/mcp-szcd-client 0.27.2 → 0.27.3

package/lib/browser-engine.js

@@ -145,11 +145,14 @@ export class BrowserEngine {
         const startTime = Date.now();
         try {
             const result = await this._dispatchStep(step, context);
+            if (step.type === "apiCapture" || step.type === "api-capture") {
+                context.lastApiCapture = result;
+            }
             return {
                 ...result,
                 step: step.type,
                 duration: Date.now() - startTime,
-                status: "PASS",
+                status: result?.passed === false ? "FAIL" : "PASS",
             };
         } catch (err) {
             return {
@@ -215,6 +218,10 @@ export class BrowserEngine {
 
     async act(options = {}) {
         const targetFrame = await this._resolveObserveFrame(options);
+        if (options.menuPath) {
+            return this._actMenuPath(targetFrame, options);
+        }
+
         const index = options.index !== undefined ? Number.parseInt(options.index, 10) : undefined;
         const selector = this._resolveSelector(options.selector || options.click || options.hover);
         const typeText = options.typeText ?? options.text;
@@ -373,6 +380,160 @@ export class BrowserEngine {
         };
     }
 
+    async _actMenuPath(targetFrame, options = {}) {
+        const menuPath = Array.isArray(options.menuPath)
+            ? options.menuPath
+            : String(options.menuPath).split("/").map((item) => item.trim()).filter(Boolean);
+        const waitAfterEach = Number.parseInt(options.waitAfterEach ?? 300, 10);
+
+        if (menuPath.length === 0) {
+            throw new Error("menuPath is empty");
+        }
+
+        const result = await targetFrame.frame.evaluate(async (pathItems, waitMs) => {
+            function sleep(ms) {
+                return new Promise((resolve) => setTimeout(resolve, ms));
+            }
+
+            function textOf(el) {
+                return (el.innerText || el.textContent || "").replace(/\s+/g, " ").trim();
+            }
+
+            function classText(el) {
+                return typeof el.className === "string" ? el.className : "";
+            }
+
+            function isVisible(el) {
+                const rect = el.getBoundingClientRect();
+                const style = window.getComputedStyle(el);
+                return rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden";
+            }
+
+            function menuCandidates() {
+                return Array.from(document.querySelectorAll([
+                    "[role='menuitem']",
+                    ".ant-menu-item",
+                    ".ant-menu-submenu-title",
+                    "li[class*='menu']",
+                    "a",
+                    "button",
+                    "[class*='menu-item']",
+                    "[class*='submenu']",
+                ].join(","))).filter(isVisible);
+            }
+
+            function scoreCandidate(el, text, level) {
+                const actual = textOf(el);
+                if (!actual) return -1;
+                let score = -1;
+                if (actual === text) score = 100;
+                else if (actual.includes(text)) score = 70;
+                else if (text.includes(actual)) score = 50;
+                if (score < 0) return -1;
+                const cls = classText(el);
+                const role = el.getAttribute("role") || "";
+                if (role === "menuitem") score += 10;
+                if (cls.includes("ant-menu-submenu-title")) score += level < pathItems.length - 1 ? 20 : -5;
+                if (cls.includes("ant-menu-item")) score += level === pathItems.length - 1 ? 20 : 0;
+                if (cls.includes("ant-menu-item-selected")) score += 5;
+                return score;
+            }
+
+            function findMenuItem(text, level) {
+                return menuCandidates()
+                    .map((el) => ({ el, score: scoreCandidate(el, text, level), text: textOf(el) }))
+                    .filter((item) => item.score >= 0)
+                    .sort((a, b) => b.score - a.score)[0] || null;
+            }
+
+            function elementSnapshot(el) {
+                const rect = el.getBoundingClientRect();
+                return {
+                    tagName: el.tagName,
+                    text: textOf(el).slice(0, 120),
+                    role: el.getAttribute("role") || null,
+                    className: classText(el),
+                    ariaExpanded: el.getAttribute("aria-expanded"),
+                    bbox: {
+                        x: Math.round(rect.x),
+                        y: Math.round(rect.y),
+                        width: Math.round(rect.width),
+                        height: Math.round(rect.height),
+                    },
+                };
+            }
+
+            const steps = [];
+
+            for (let i = 0; i < pathItems.length; i++) {
+                const text = pathItems[i];
+                let match = findMenuItem(text, i);
+                if (!match && i > 0) {
+                    await sleep(waitMs * 2);
+                    match = findMenuItem(text, i);
+                }
+                if (!match) {
+                    return { found: false, failedAt: text, steps };
+                }
+
+                const el = match.el;
+                el.scrollIntoView({ block: "center", inline: "center" });
+                const beforeUrl = location.href;
+                const beforeText = document.body?.innerText || "";
+                const isLast = i === pathItems.length - 1;
+                const before = elementSnapshot(el);
+
+                el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true }));
+                el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true }));
+                el.click();
+                await sleep(waitMs);
+
+                const afterClass = classText(el);
+                const afterExpanded = el.getAttribute("aria-expanded");
+                steps.push({
+                    text,
+                    action: isLast ? "click" : "expand",
+                    status: "PASS",
+                    matchedText: match.text,
+                    before,
+                    after: {
+                        className: afterClass,
+                        ariaExpanded: afterExpanded,
+                        urlChanged: location.href !== beforeUrl,
+                        textChanged: (document.body?.innerText || "") !== beforeText,
+                        selected: afterClass.includes("selected") || afterClass.includes("active"),
+                    },
+                });
+            }
+
+            return {
+                found: true,
+                performed: true,
+                steps,
+                currentUrl: location.href,
+                title: document.title,
+            };
+        }, menuPath, waitAfterEach);
+
+        if (!result.found) {
+            throw new Error(`Menu path item not found: ${result.failedAt}`);
+        }
+
+        return {
+            acted: true,
+            action: "menuPath",
+            menuPath,
+            target: {
+                frameId: targetFrame.frameId,
+                frameUrl: targetFrame.frame.url(),
+                matchedBy: targetFrame.matchedBy,
+            },
+            steps: result.steps,
+            currentUrl: result.currentUrl,
+            title: result.title,
+        };
+    }
+
     async assert(options = {}) {
         const targetFrame = await this._resolveObserveFrame(options);
         const previousFrame = this._activeFrame;
@@ -417,6 +578,237 @@ export class BrowserEngine {
         }
     }
 
+    async captureApi(options = {}) {
+        const wait = Number.parseInt(options.wait ?? options.timeout ?? 15000, 10);
+        const includeRequestBody = options.includeRequestBody !== false;
+        const includeResponseBody = Boolean(options.includeResponseBody);
+        const methodFilter = options.method ? String(options.method).toUpperCase() : null;
+        const urlPattern = options.urlPattern || options.urlIncludes || "";
+        const targetFrame = await this._resolveObserveFrame(options).catch(() => null);
+        const requests = new Map();
+        const sessions = [];
+        const targets = [];
+        const pendingBodies = [];
+        const startedAt = Date.now();
+
+        const matchesUrl = (url = "") => !urlPattern || url.includes(urlPattern);
+        const matchesMethod = (method = "") => !methodFilter || method.toUpperCase() === methodFilter;
+        const normalizeHeaders = (headers = {}) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]));
+
+        const addSession = async (session, targetInfo) => {
+            await session.send("Network.enable").catch(() => null);
+            sessions.push(session);
+            targets.push(targetInfo);
+
+            session.on("Network.requestWillBeSent", (event) => {
+                const request = event.request || {};
+                if (!matchesUrl(request.url) || !matchesMethod(request.method)) return;
+                requests.set(`${targetInfo.id}:${event.requestId}`, {
+                    id: event.requestId,
+                    targetId: targetInfo.id,
+                    targetType: targetInfo.type,
+                    targetUrl: targetInfo.url,
+                    frameId: event.frameId,
+                    url: request.url,
+                    method: request.method,
+                    requestHeaders: normalizeHeaders(request.headers),
+                    requestBody: includeRequestBody ? request.postData || null : undefined,
+                    status: null,
+                    responseHeaders: null,
+                    responseBody: null,
+                    responseBodyBase64Encoded: null,
+                    errorText: null,
+                    startTime: Date.now(),
+                    endTime: null,
+                    duration: null,
+                });
+            });
+
+            session.on("Network.responseReceived", (event) => {
+                const item = requests.get(`${targetInfo.id}:${event.requestId}`);
+                if (!item) return;
+                const response = event.response || {};
+                item.status = response.status;
+                item.mimeType = response.mimeType;
+                item.responseHeaders = normalizeHeaders(response.headers);
+                item.responseUrl = response.url;
+            });
+
+            session.on("Network.loadingFinished", async (event) => {
+                const item = requests.get(`${targetInfo.id}:${event.requestId}`);
+                if (!item) return;
+                item.endTime = Date.now();
+                item.duration = item.endTime - item.startTime;
+                if (includeResponseBody) {
+                    const bodyTask = session.send("Network.getResponseBody", { requestId: event.requestId })
+                        .then((body) => {
+                            item.responseBody = body.body;
+                            item.responseBodyBase64Encoded = body.base64Encoded;
+                        })
+                        .catch((err) => {
+                            item.responseBodyError = err.message;
+                        });
+                    pendingBodies.push(bodyTask);
+                }
+            });
+
+            session.on("Network.loadingFailed", (event) => {
+                const item = requests.get(`${targetInfo.id}:${event.requestId}`);
+                if (!item) return;
+                item.endTime = Date.now();
+                item.duration = item.endTime - item.startTime;
+                item.errorText = event.errorText || "loadingFailed";
+            });
+        };
+
+        const pageSession = await this.page.target().createCDPSession();
+        await addSession(pageSession, {
+            id: "page",
+            type: "page",
+            url: this.page.url(),
+            matchedBy: "currentPage",
+        });
+
+        const pageTarget = this.page.target();
+        const attachCandidates = this.browser.targets().filter((target) => {
+            if (target === pageTarget) return false;
+            if (!["iframe", "page"].includes(target.type())) return false;
+            const targetUrl = target.url() || "";
+            if (options.targetUrlContains && !targetUrl.includes(options.targetUrlContains)) return false;
+            if (targetFrame?.frame && targetUrl && targetFrame.frame.url() && targetUrl !== targetFrame.frame.url() && !targetUrl.includes(targetFrame.frame.url())) {
+                return options.includeAllTargets === true;
+            }
+            return true;
+        });
+
+        for (const target of attachCandidates) {
+            const session = await target.createCDPSession().catch(() => null);
+            if (!session) continue;
+            await addSession(session, {
+                id: target.url() || `${target.type()}-${targets.length}`,
+                type: target.type(),
+                url: target.url() || "",
+                matchedBy: "browser.targets",
+            });
+        }
+
+        if (options.reload) {
+            await this.page.reload({ waitUntil: options.waitUntil || "domcontentloaded", timeout: options.reloadTimeout || 30000 }).catch(() => null);
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, wait));
+        await Promise.allSettled(pendingBodies);
+
+        await Promise.all(sessions.map((session) => session.send("Network.disable").catch(() => null)));
+
+        const requestList = Array.from(requests.values()).sort((a, b) => a.startTime - b.startTime);
+        const title = await this.page.title().catch(() => "");
+        const failed = requestList.filter((item) => item.errorText || (item.status && item.status >= 400));
+
+        return {
+            type: "apiCapture",
+            page: {
+                url: this.page.url(),
+                title,
+            },
+            target: targetFrame ? {
+                frameId: targetFrame.frameId,
+                frameUrl: targetFrame.frame.url(),
+                matchedBy: targetFrame.matchedBy,
+            } : null,
+            targets,
+            requests: requestList,
+            summary: {
+                total: requestList.length,
+                success: requestList.length - failed.length,
+                failed: failed.length,
+                targets: targets.length,
+                duration: Date.now() - startedAt,
+            },
+        };
+    }
+
+    assertApi(captureResult, options = {}) {
+        if (!captureResult || !Array.isArray(captureResult.requests)) {
+            throw new Error("assertApi requires an apiCapture result");
+        }
+
+        const requests = captureResult.requests;
+        const expect = options.expect || options;
+        const checks = {};
+        let passed = true;
+
+        if (expect.maxFailed !== undefined) {
+            const actual = requests.filter((item) => item.errorText || (item.status && item.status >= 400)).length;
+            checks.maxFailed = {
+                expected: Number.parseInt(expect.maxFailed, 10),
+                actual,
+                passed: actual <= Number.parseInt(expect.maxFailed, 10),
+            };
+            if (!checks.maxFailed.passed) passed = false;
+        }
+
+        if (expect.forbidStatusGte !== undefined) {
+            const threshold = Number.parseInt(expect.forbidStatusGte, 10);
+            const violations = requests
+                .filter((item) => item.status && item.status >= threshold)
+                .map((item) => ({ url: item.url, method: item.method, status: item.status }));
+            checks.forbidStatusGte = {
+                expected: threshold,
+                violations,
+                passed: violations.length === 0,
+            };
+            if (!checks.forbidStatusGte.passed) passed = false;
+        }
+
+        if (expect.requiredUrls !== undefined) {
+            const requiredUrls = Array.isArray(expect.requiredUrls) ? expect.requiredUrls : [expect.requiredUrls];
+            checks.requiredUrls = requiredUrls.map((url) => {
+                const matched = requests.filter((item) => item.url?.includes(url));
+                return {
+                    url,
+                    matched: matched.length,
+                    passed: matched.length > 0,
+                };
+            });
+            if (checks.requiredUrls.some((item) => !item.passed)) passed = false;
+        }
+
+        if (expect.requiredMethods !== undefined) {
+            const requiredMethods = Array.isArray(expect.requiredMethods) ? expect.requiredMethods : [expect.requiredMethods];
+            checks.requiredMethods = requiredMethods.map((method) => {
+                const normalized = String(method).toUpperCase();
+                const matched = requests.filter((item) => item.method === normalized);
+                return {
+                    method: normalized,
+                    matched: matched.length,
+                    passed: matched.length > 0,
+                };
+            });
+            if (checks.requiredMethods.some((item) => !item.passed)) passed = false;
+        }
+
+        if (expect.minTotal !== undefined) {
+            const expected = Number.parseInt(expect.minTotal, 10);
+            checks.minTotal = {
+                expected,
+                actual: requests.length,
+                passed: requests.length >= expected,
+            };
+            if (!checks.minTotal.passed) passed = false;
+        }
+
+        return {
+            type: "assertApi",
+            passed,
+            checks,
+            summary: captureResult?.summary || {
+                total: requests.length,
+                failed: requests.filter((item) => item.errorText || (item.status && item.status >= 400)).length,
+            },
+        };
+    }
+
     async _resolveObserveFrame(options = {}) {
         const frames = this.page.frames();
         const mainFrame = this.page.mainFrame();
@@ -613,6 +1005,10 @@ export class BrowserEngine {
             case "observe":      return this.observe(step);
             case "act":          return this.act(step);
             case "assert":       return this.assert(step);
+            case "apiCapture":   return this.captureApi(step);
+            case "api-capture":  return this.captureApi(step);
+            case "assertApi":    return this.assertApi(step.captureResult || context.lastApiCapture, step);
+            case "assert-api":   return this.assertApi(step.captureResult || context.lastApiCapture, step);
             case "navigate":     return this._navigate(step);
             case "screenshot":   return this._screenshot(step, context);
             case "compare":      return this._compare(step, context);

package/local-browser-executor.js

@@ -5,11 +5,14 @@
  * 用法：
  *   node local-browser-executor.js --action observe --output /tmp/observe.json
  *   node local-browser-executor.js --action act --index 1 --observe-after
+ *   node local-browser-executor.js --action act --menu-path "目录管理/数据集目录" --observe-after
+ *   node local-browser-executor.js --action api-capture --wait 15000 --include-response-body
+ *   node local-browser-executor.js --action assert-api --capture-file /tmp/browser-api-capture.json --max-failed 0
  *   node local-browser-executor.js --plan '<JSON>' --output /tmp/result.json
  *   node local-browser-executor.js --plan-file /path/to/plan.json --output /tmp/result.json
  *
  * 参数：
- *   --action     直接执行动作，当前支持 observe/act/assert
+ *   --action     直接执行动作，当前支持 observe/act/assert/api-capture
  *   --plan       测试计划 JSON 字符串
  *   --plan-file  测试计划 JSON 文件路径（与 --plan 二选一）
  *   --output     结果输出文件路径（默认 stdout）
@@ -93,6 +96,12 @@ function parseArgs() {
             case "--hover":
                 parsed.hover = args[++i];
                 break;
+            case "--menu-path":
+                parsed.menuPath = args[++i];
+                break;
+            case "--wait-after-each":
+                parsed.waitAfterEach = args[++i];
+                break;
             case "--observe-after":
                 parsed.observeAfter = true;
                 break;
@@ -111,6 +120,51 @@ function parseArgs() {
             case "--has-text":
                 parsed.hasText = args[++i];
                 break;
+            case "--wait":
+                parsed.wait = args[++i];
+                break;
+            case "--method":
+                parsed.method = args[++i];
+                break;
+            case "--url-pattern":
+                parsed.urlPattern = args[++i];
+                break;
+            case "--target-url-contains":
+                parsed.targetUrlContains = args[++i];
+                break;
+            case "--include-request-body":
+                parsed.includeRequestBody = true;
+                break;
+            case "--no-request-body":
+                parsed.includeRequestBody = false;
+                break;
+            case "--include-response-body":
+                parsed.includeResponseBody = true;
+                break;
+            case "--reload":
+                parsed.reload = true;
+                break;
+            case "--include-all-targets":
+                parsed.includeAllTargets = true;
+                break;
+            case "--capture-file":
+                parsed.captureFile = args[++i];
+                break;
+            case "--max-failed":
+                parsed.maxFailed = args[++i];
+                break;
+            case "--forbid-status-gte":
+                parsed.forbidStatusGte = args[++i];
+                break;
+            case "--required-url":
+                parsed.requiredUrls = [...(parsed.requiredUrls || []), args[++i]];
+                break;
+            case "--required-method":
+                parsed.requiredMethods = [...(parsed.requiredMethods || []), args[++i]];
+                break;
+            case "--min-total":
+                parsed.minTotal = args[++i];
+                break;
             case "--base-url":
                 parsed.baseUrl = args[++i];
                 break;
@@ -133,12 +187,15 @@ function printHelp() {
 用法:
   node local-browser-executor.js --action observe [options]
   node local-browser-executor.js --action act --index 1 --observe-after [options]
+  node local-browser-executor.js --action act --menu-path "目录管理/数据集目录" --observe-after [options]
   node local-browser-executor.js --action assert --selector ".ant-table" --expect-visible [options]
+  node local-browser-executor.js --action api-capture --wait 15000 --include-response-body [options]
+  node local-browser-executor.js --action assert-api --capture-file /tmp/browser-api-capture.json --max-failed 0 [options]
   node local-browser-executor.js --plan '<JSON>' [options]
   node local-browser-executor.js --plan-file <path> [options]
 
 选项:
-  --action <name>                    直接执行动作，当前支持 observe/act/assert
+  --action <name>                    直接执行动作，当前支持 observe/act/assert/api-capture
   --plan <json>                      测试计划 JSON 字符串
   --plan-file <path>                 测试计划 JSON 文件路径
   --output <path>                    结果输出文件路径（默认 stdout）
@@ -156,12 +213,29 @@ function printHelp() {
   --type <text>                      act 时输入文本
   --clear                            act 输入前清空目标
   --hover <selector>                 act 时悬停 selector/text=/role=/~ 目标
+  --menu-path <a/b>                  act 时按菜单路径展开并点击，如 "目录管理/数据集目录"
+  --wait-after-each <ms>             menu-path 每步点击后的等待时间（默认 300）
   --observe-after                    act 后再次 observe，返回 before/act/after 闭环结果
   --url-contains-assert <text>       assert 当前 URL 包含文本
   --text-contains <text>             assert 页面文本包含内容
   --expect-visible                   assert selector 可见
   --min-count <n>                    assert selector 数量下限
   --has-text <text>                  assert selector 文本包含内容
+  --wait <ms>                        api-capture 监听时长（默认 15000）
+  --method <GET|POST>                api-capture 按请求方法过滤
+  --url-pattern <text>               api-capture 按 URL 片段过滤
+  --target-url-contains <text>       api-capture 按 target URL 过滤 iframe/page target
+  --include-request-body             api-capture 包含请求体（默认包含）
+  --no-request-body                  api-capture 不包含请求体
+  --include-response-body            api-capture 调用 Network.getResponseBody 获取响应体
+  --reload                           api-capture 开始监听后刷新页面触发请求
+  --include-all-targets              api-capture 不限制到匹配 frame，监听所有 page/iframe targets
+  --capture-file <path>              assert-api 读取 api-capture JSON 结果
+  --max-failed <n>                   assert-api 允许失败请求数上限
+  --forbid-status-gte <n>            assert-api 禁止出现大于等于该状态码的响应
+  --required-url <text>              assert-api 要求出现的 URL 片段，可重复传入
+  --required-method <GET|POST>       assert-api 要求出现的请求方法，可重复传入
+  --min-total <n>                    assert-api 要求捕获请求总数下限
   --allow-launch                     action 模式允许无 CDP 时启动 headless Chrome
   --base-url <url>                   基础 URL，替换计划中的 {{baseUrl}} 占位符
   -h, --help                         显示帮助
@@ -269,6 +343,25 @@ async function executePlan(plan, options) {
 
 // ==================== 主流程 ====================
 
+function executeAssertApiAction(args) {
+    if (!args.captureFile) {
+        return {
+            error: "必须提供 --capture-file 参数",
+            errorCode: "CAPTURE_FILE_REQUIRED",
+        };
+    }
+
+    const captureResult = JSON.parse(fs.readFileSync(args.captureFile, "utf8"));
+    const engine = new BrowserEngine();
+    return engine.assertApi(captureResult, {
+        maxFailed: args.maxFailed,
+        forbidStatusGte: args.forbidStatusGte,
+        requiredUrls: args.requiredUrls,
+        requiredMethods: args.requiredMethods,
+        minTotal: args.minTotal,
+    });
+}
+
 async function executeAction(args) {
     const engine = new BrowserEngine();
     const startedAt = new Date().toISOString();
@@ -308,6 +401,8 @@ async function executeAction(args) {
                     selector: args.selector,
                     click: args.click,
                     hover: args.hover,
+                    menuPath: args.menuPath,
+                    waitAfterEach: args.waitAfterEach,
                     typeText: args.typeText,
                     clear: args.clear,
                     frameUrlContains: args.frameUrlContains,
@@ -342,11 +437,28 @@ async function executeAction(args) {
                 });
                 return { type: "assert", ...result, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
             }
+            case "api-capture":
+            case "apiCapture": {
+                const result = await engine.captureApi({
+                    wait: args.wait,
+                    method: args.method,
+                    urlPattern: args.urlPattern,
+                    targetUrlContains: args.targetUrlContains,
+                    includeRequestBody: args.includeRequestBody,
+                    includeResponseBody: args.includeResponseBody,
+                    reload: args.reload,
+                    includeAllTargets: args.includeAllTargets,
+                    frameUrlContains: args.frameUrlContains,
+                    frameContentContains: args.frameContentContains,
+                    frameIndex: args.frameIndex,
+                });
+                return { ...result, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
+            }
             default:
                 return {
                     error: `未知 action: ${args.action}`,
                     errorCode: "UNKNOWN_ACTION",
-                    supportedActions: ["observe", "act", "assert"],
+                    supportedActions: ["observe", "act", "assert", "api-capture"],
                     startTime: startedAt,
                     endTime: new Date().toISOString(),
                 };
@@ -367,6 +479,21 @@ async function executeAction(args) {
 async function main() {
     const args = parseArgs();
 
+    if (args.action === "assert-api" || args.action === "assertApi") {
+        try {
+            const results = executeAssertApiAction(args);
+            outputResult(results, args.output);
+            process.exit(results.error ? 2 : results.passed === false ? 1 : 0);
+        } catch (err) {
+            const errorResult = {
+                error: err.message,
+                errorCode: "ASSERT_API_FAILED",
+            };
+            outputResult(errorResult, args.output);
+            process.exit(2);
+        }
+    }
+
     if (args.action) {
         const results = await executeAction(args);
         outputResult(results, args.output);

package/opencode-extension/skills/local-browser-test/SKILL.md

@@ -79,8 +79,10 @@ AI 直接构造测试计划 JSON：
 | type | 功能 | 参数 | 返回 |
 |------|------|------|------|
 | observe | 结构化观察 | `selector`, `depth`, `frameContentContains`, `maxInteractiveElements` | `{ frames, tree, interactiveElements[] }` |
-| act | 按 index/selector 交互 | `index` 或 `selector/click/hover`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element }` |
+| act | 按 index/selector/menuPath 交互 | `index` 或 `selector/click/hover` 或 `menuPath`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element/steps }` |
 | assert | 轻量断言 | `selector`, `expect`, `urlContains`, `textContains` | `{ passed, checks }` |
+| apiCapture | API 请求/响应捕获 | `wait`, `urlPattern`, `method`, `includeResponseBody`, `frameContentContains` | `{ targets, requests, summary }` |
+| assertApi | API 捕获结果断言 | `maxFailed`, `requiredUrls`, `forbidStatusGte`, `minTotal` | `{ passed, checks, summary }` |
 | navigate | 导航到 URL | `url`, `waitUntil` | `{ url, title, loadTime }` |
 | screenshot | 页面截图 | `fullPage`, `clip`, `filename` | `{ filepath, width, height }` |
 | compare | 设计稿对比 | `designImagePath`, `threshold`, `regions[]` | `{ fidelity, diffPixels, diffImagePath, regions[] }` |
@@ -236,6 +238,18 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-act-observe.json
 ```
 
+### 左侧菜单路径稳定点击
+```bash
+node {client_path}/local-browser-executor.js \
+  --action act \
+  --url-contains "platform.aicityos.com" \
+  --menu-path "目录管理/数据集目录" \
+  --observe-after \
+  --output /tmp/browser-menu-act.json
+```
+
+`--menu-path` 会按路径逐级匹配菜单项，非末级优先执行展开，末级执行点击；匹配优先考虑 `role=menuitem`、`.ant-menu-item`、`.ant-menu-submenu-title` 和文本精确/包含匹配。
+
 ### 轻量 DOM 断言
 ```bash
 node {client_path}/local-browser-executor.js \
@@ -247,6 +261,34 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-assert.json
 ```
 
+### API 请求/响应捕获（真实浏览器 + 微前端）
+```bash
+node {client_path}/local-browser-executor.js \
+  --action api-capture \
+  --url-contains "platform.aicityos.com" \
+  --frame-content-contains "数据集目录" \
+  --url-pattern "/api/" \
+  --wait 15000 \
+  --include-response-body \
+  --reload \
+  --output /tmp/browser-api-capture.json
+```
+
+`api-capture` 使用 CDP `Network.*` 事件监听主页面和可 attach 的 page/iframe target，不使用 `setRequestInterception`，避免阻断真实请求。wujie/qiankun 场景优先传 `--frame-content-contains` 锁定业务 iframe；如需监听全部 target，追加 `--include-all-targets`。
+
+### API 捕获结果断言
+```bash
+node {client_path}/local-browser-executor.js \
+  --action assert-api \
+  --capture-file /tmp/browser-api-capture.json \
+  --max-failed 0 \
+  --forbid-status-gte 400 \
+  --required-url "/list" \
+  --output /tmp/browser-api-assert.json
+```
+
+计划内可直接在 `apiCapture` 后追加 `{ "type": "assertApi", "maxFailed": 0, "forbidStatusGte": 400 }`，会自动读取上一步捕获结果。
+
 ### 快速诊断（过渡兼容）
 ```bash
 NODE_PATH=~/.szcd-mcp/deps/node_modules node {skill_path}/local-browser-executor.cjs \

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@szc-ft/mcp-szcd-client",
-    "version": "0.27.2",
+    "version": "0.27.3",
     "description": "MCP client for szcd component library - auto-configures AI coding tools with MCP server, skills, agents and commands",
     "keywords": [
         "mcp",

package/qwen-extension/qwen-extension.json

@@ -1,6 +1,6 @@
 {
     "name": "szcd-component-helper",
-    "version": "0.27.2",
+    "version": "0.27.3",
     "description": "szcd 组件库 MCP 助手 — 查询组件信息、匹配需求、生成代码",
     "mcpServers": {
         "szcd-component-helper": {

package/qwen-extension/skills/local-browser-test/SKILL.md

@@ -79,8 +79,10 @@ AI 直接构造测试计划 JSON：
 | type | 功能 | 参数 | 返回 |
 |------|------|------|------|
 | observe | 结构化观察 | `selector`, `depth`, `frameContentContains`, `maxInteractiveElements` | `{ frames, tree, interactiveElements[] }` |
-| act | 按 index/selector 交互 | `index` 或 `selector/click/hover`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element }` |
+| act | 按 index/selector/menuPath 交互 | `index` 或 `selector/click/hover` 或 `menuPath`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element/steps }` |
 | assert | 轻量断言 | `selector`, `expect`, `urlContains`, `textContains` | `{ passed, checks }` |
+| apiCapture | API 请求/响应捕获 | `wait`, `urlPattern`, `method`, `includeResponseBody`, `frameContentContains` | `{ targets, requests, summary }` |
+| assertApi | API 捕获结果断言 | `maxFailed`, `requiredUrls`, `forbidStatusGte`, `minTotal` | `{ passed, checks, summary }` |
 | navigate | 导航到 URL | `url`, `waitUntil` | `{ url, title, loadTime }` |
 | screenshot | 页面截图 | `fullPage`, `clip`, `filename` | `{ filepath, width, height }` |
 | compare | 设计稿对比 | `designImagePath`, `threshold`, `regions[]` | `{ fidelity, diffPixels, diffImagePath, regions[] }` |
@@ -236,6 +238,18 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-act-observe.json
 ```
 
+### 左侧菜单路径稳定点击
+```bash
+node {client_path}/local-browser-executor.js \
+  --action act \
+  --url-contains "platform.aicityos.com" \
+  --menu-path "目录管理/数据集目录" \
+  --observe-after \
+  --output /tmp/browser-menu-act.json
+```
+
+`--menu-path` 会按路径逐级匹配菜单项，非末级优先执行展开，末级执行点击；匹配优先考虑 `role=menuitem`、`.ant-menu-item`、`.ant-menu-submenu-title` 和文本精确/包含匹配。
+
 ### 轻量 DOM 断言
 ```bash
 node {client_path}/local-browser-executor.js \
@@ -247,6 +261,34 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-assert.json
 ```
 
+### API 请求/响应捕获（真实浏览器 + 微前端）
+```bash
+node {client_path}/local-browser-executor.js \
+  --action api-capture \
+  --url-contains "platform.aicityos.com" \
+  --frame-content-contains "数据集目录" \
+  --url-pattern "/api/" \
+  --wait 15000 \
+  --include-response-body \
+  --reload \
+  --output /tmp/browser-api-capture.json
+```
+
+`api-capture` 使用 CDP `Network.*` 事件监听主页面和可 attach 的 page/iframe target，不使用 `setRequestInterception`，避免阻断真实请求。wujie/qiankun 场景优先传 `--frame-content-contains` 锁定业务 iframe；如需监听全部 target，追加 `--include-all-targets`。
+
+### API 捕获结果断言
+```bash
+node {client_path}/local-browser-executor.js \
+  --action assert-api \
+  --capture-file /tmp/browser-api-capture.json \
+  --max-failed 0 \
+  --forbid-status-gte 400 \
+  --required-url "/list" \
+  --output /tmp/browser-api-assert.json
+```
+
+计划内可直接在 `apiCapture` 后追加 `{ "type": "assertApi", "maxFailed": 0, "forbidStatusGte": 400 }`，会自动读取上一步捕获结果。
+
 ### 快速诊断（过渡兼容）
 ```bash
 NODE_PATH=~/.szcd-mcp/deps/node_modules node {skill_path}/local-browser-executor.cjs \

package/standard-skill/local-browser-test/SKILL.md

@@ -79,8 +79,10 @@ AI 直接构造测试计划 JSON：
 | type | 功能 | 参数 | 返回 |
 |------|------|------|------|
 | observe | 结构化观察 | `selector`, `depth`, `frameContentContains`, `maxInteractiveElements` | `{ frames, tree, interactiveElements[] }` |
-| act | 按 index/selector 交互 | `index` 或 `selector/click/hover`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element }` |
+| act | 按 index/selector/menuPath 交互 | `index` 或 `selector/click/hover` 或 `menuPath`, `typeText`, `clear`, `frameContentContains` | `{ acted, action, element/steps }` |
 | assert | 轻量断言 | `selector`, `expect`, `urlContains`, `textContains` | `{ passed, checks }` |
+| apiCapture | API 请求/响应捕获 | `wait`, `urlPattern`, `method`, `includeResponseBody`, `frameContentContains` | `{ targets, requests, summary }` |
+| assertApi | API 捕获结果断言 | `maxFailed`, `requiredUrls`, `forbidStatusGte`, `minTotal` | `{ passed, checks, summary }` |
 | navigate | 导航到 URL | `url`, `waitUntil` | `{ url, title, loadTime }` |
 | screenshot | 页面截图 | `fullPage`, `clip`, `filename` | `{ filepath, width, height }` |
 | compare | 设计稿对比 | `designImagePath`, `threshold`, `regions[]` | `{ fidelity, diffPixels, diffImagePath, regions[] }` |
@@ -236,6 +238,18 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-act-observe.json
 ```
 
+### 左侧菜单路径稳定点击
+```bash
+node {client_path}/local-browser-executor.js \
+  --action act \
+  --url-contains "platform.aicityos.com" \
+  --menu-path "目录管理/数据集目录" \
+  --observe-after \
+  --output /tmp/browser-menu-act.json
+```
+
+`--menu-path` 会按路径逐级匹配菜单项，非末级优先执行展开，末级执行点击；匹配优先考虑 `role=menuitem`、`.ant-menu-item`、`.ant-menu-submenu-title` 和文本精确/包含匹配。
+
 ### 轻量 DOM 断言
 ```bash
 node {client_path}/local-browser-executor.js \
@@ -247,6 +261,34 @@ node {client_path}/local-browser-executor.js \
   --output /tmp/browser-assert.json
 ```
 
+### API 请求/响应捕获（真实浏览器 + 微前端）
+```bash
+node {client_path}/local-browser-executor.js \
+  --action api-capture \
+  --url-contains "platform.aicityos.com" \
+  --frame-content-contains "数据集目录" \
+  --url-pattern "/api/" \
+  --wait 15000 \
+  --include-response-body \
+  --reload \
+  --output /tmp/browser-api-capture.json
+```
+
+`api-capture` 使用 CDP `Network.*` 事件监听主页面和可 attach 的 page/iframe target，不使用 `setRequestInterception`，避免阻断真实请求。wujie/qiankun 场景优先传 `--frame-content-contains` 锁定业务 iframe；如需监听全部 target，追加 `--include-all-targets`。
+
+### API 捕获结果断言
+```bash
+node {client_path}/local-browser-executor.js \
+  --action assert-api \
+  --capture-file /tmp/browser-api-capture.json \
+  --max-failed 0 \
+  --forbid-status-gte 400 \
+  --required-url "/list" \
+  --output /tmp/browser-api-assert.json
+```
+
+计划内可直接在 `apiCapture` 后追加 `{ "type": "assertApi", "maxFailed": 0, "forbidStatusGte": 400 }`，会自动读取上一步捕获结果。
+
 ### 快速诊断（过渡兼容）
 ```bash
 NODE_PATH=~/.szcd-mcp/deps/node_modules node {skill_path}/local-browser-executor.cjs \

package/standard-skill/local-browser-test/local-browser-executor-old.cjs

@@ -1,395 +0,0 @@
-#!/usr/bin/env node
-/**
- * local-browser-executor.js - 本地浏览器自动化执行器
- *
- * 功能：
- *   --action diagnose    全面诊断（JS错误、网络请求、API检查、资源加载）
- *   --action list-pages  列出所有标签页
- *   --action screenshot  截图
- *   --action api-check   检查 API 请求状态
- *   --action plan        执行测试计划 JSON
- *
- * 连接方式：
- *   --cdp-url http://localhost:9222  (默认自动检测 9222)
- *   --auto-detect                    自动检测 Chrome/Edge 进程
- *
- * 通用参数：
- *   --url <url>          目标页面 URL
- *   --url-contains <s>   按关键词查找已打开的页面
- *   --wait <ms>          额外等待时间（默认 5000）
- *   --output <path>      结果输出文件
- *   --output-dir <dir>   截图/产物输出目录
- */
-
-const puppeteer = require('puppeteer-core');
-const fs = require('fs');
-const path = require('path');
-const http = require('http');
-
-// ===== 参数解析 =====
-const args = process.argv.slice(2);
-function getArg(name, defaultVal) {
-  const idx = args.indexOf(`--${name}`);
-  if (idx === -1) return defaultVal;
-  return args[idx + 1] || defaultVal;
-}
-function hasFlag(name) {
-  return args.includes(`--${name}`);
-}
-
-const ACTION = getArg('action', 'diagnose');
-const CDP_URL = getArg('cdp-url', 'http://localhost:9222');
-const TARGET_URL = getArg('url', null);
-const URL_CONTAINS = getArg('url-contains', null);
-const WAIT_MS = parseInt(getArg('wait', '5000'), 10);
-const OUTPUT = getArg('output', null);
-const OUTPUT_DIR = getArg('output-dir', '/tmp/browser-test');
-const PLAN_FILE = getArg('plan-file', null);
-
-// ===== 工具函数 =====
-function log(msg) { console.log(msg); }
-function ensureDir(dir) { fs.mkdirSync(dir, { recursive: true }); }
-
-function checkCDP(url) {
-  return new Promise((resolve) => {
-    const req = http.get(url + '/json/version', { timeout: 2000 }, (res) => {
-      let data = '';
-      res.on('data', c => data += c);
-      res.on('end', () => {
-        try { resolve(JSON.parse(data)); } catch { resolve(null); }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-  });
-}
-
-async function findPage(browser) {
-  const pages = await browser.pages();
-  if (TARGET_URL) {
-    for (const p of pages) {
-      if (p.url().includes(TARGET_URL) || p.url() === TARGET_URL) return p;
-    }
-    // 导航到目标 URL
-    const p = pages[0] || await browser.newPage();
-    await p.goto(TARGET_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
-    return p;
-  }
-  if (URL_CONTAINS) {
-    for (const p of pages) {
-      if (p.url().includes(URL_CONTAINS)) return p;
-    }
-    log(`[WARN] 未找到包含 "${URL_CONTAINS}" 的页面，使用第一个页面`);
-  }
-  // 找到非 about:blank 的页面
-  for (const p of pages) {
-    if (!p.url().startsWith('about:') && !p.url().startsWith('devtools:')) return p;
-  }
-  return pages[0];
-}
-
-// ===== Action: list-pages =====
-async function listPages(browser) {
-  const pages = await browser.pages();
-  const result = [];
-  for (let i = 0; i < pages.length; i++) {
-    const p = pages[i];
-    let title = '';
-    try { title = await p.title(); } catch {}
-    result.push({ index: i, url: p.url(), title });
-    log(`[${i}] ${p.url()}`);
-    if (title) log(`    title: ${title}`);
-  }
-  return { pages: result, total: result.length };
-}
-
-// ===== Action: diagnose =====
-async function diagnose(browser) {
-  ensureDir(OUTPUT_DIR);
-  const page = await findPage(browser);
-  log(`[PAGE] ${page.url()}`);
-
-  // 收集数据
-  const pageErrors = [];
-  const consoleMessages = [];
-  const failedRequests = [];
-  const apiRequests = [];
-  const resourceRequests = [];
-
-  page.on('pageerror', err => {
-    pageErrors.push({ message: err.message, stack: err.stack?.split('\n').slice(0, 5).join('\n') });
-  });
-  page.on('console', msg => {
-    const type = msg.type();
-    const text = msg.text().substring(0, 500);
-    consoleMessages.push({ type, text });
-  });
-  page.on('response', resp => {
-    const url = resp.url();
-    const status = resp.status();
-    const type = resp.request().resourceType();
-    if (type === 'xhr' || type === 'fetch') {
-      apiRequests.push({ status, url, method: resp.request().method() });
-    }
-    if (type === 'stylesheet' || type === 'script') {
-      resourceRequests.push({ status, url, type });
-    }
-    if (status >= 400) {
-      failedRequests.push({ status, url, type });
-    }
-  });
-  page.on('requestfailed', req => {
-    failedRequests.push({ status: 'ABORTED', url: req.url(), error: req.failure()?.errorText });
-  });
-
-  // 刷新页面收集
-  log('[INFO] 刷新页面收集诊断数据...');
-  try {
-    await page.reload({ waitUntil: 'load', timeout: 30000 });
-  } catch (e) {
-    log(`[WARN] 刷新超时: ${e.message.substring(0, 100)}`);
-  }
-  await new Promise(r => setTimeout(r, WAIT_MS));
-
-  // 截图
-  const screenshotPath = path.join(OUTPUT_DIR, 'diagnose-screenshot.png');
-  await page.screenshot({ path: screenshotPath, fullPage: false });
-  log(`[OK] 截图: ${screenshotPath}`);
-
-  // 检查 iframe
-  const frames = page.frames();
-  const iframeInfo = [];
-  for (const frame of frames) {
-    const url = frame.url();
-    if (url === page.url() || url === 'about:blank') continue;
-    let bodyText = '';
-    let rootContent = '';
-    try {
-      const info = await frame.evaluate(() => ({
-        bodyText: document.body?.innerText?.substring(0, 200) || '',
-        rootHTML: document.getElementById('root')?.innerHTML?.substring(0, 200) || 'no root',
-        hasReactRoot: !document.getElementById('root')?.innerHTML?.includes('loading-spinner'),
-        antdElements: document.querySelectorAll('[class*="ant-"]').length,
-      }));
-      bodyText = info.bodyText;
-      rootContent = info.rootHTML;
-      iframeInfo.push({ url, ...info });
-    } catch (e) {
-      iframeInfo.push({ url, error: e.message.substring(0, 100) });
-    }
-  }
-
-  // 输出结果
-  const errors = consoleMessages.filter(m => m.type === 'error');
-  const warnings = consoleMessages.filter(m => m.type === 'warning');
-
-  const result = {
-    url: page.url(),
-    timestamp: new Date().toISOString(),
-    screenshot: screenshotPath,
-    pageErrors,
-    consoleErrors: errors,
-    consoleWarnings: warnings,
-    consoleTotal: consoleMessages.length,
-    failedRequests,
-    apiRequests,
-    resourceStatus: resourceRequests.map(r => ({
-      status: r.status, type: r.type, name: r.url.split('/').pop()
-    })),
-    iframes: iframeInfo,
-    summary: {
-      jsErrors: pageErrors.length,
-      consoleErrors: consoleMessages.filter(m => m.type === 'error').length,
-      failedNetwork: failedRequests.length,
-      totalAPI: apiRequests.length,
-      failedAPI: apiRequests.filter(r => r.status >= 400).length,
-      totalResources: resourceRequests.length,
-      failedResources: resourceRequests.filter(r => r.status >= 400).length,
-    }
-  };
-
-  // 打印摘要
-  log('\n========== 诊断结果 ==========');
-  log(`JS 异常: ${result.summary.jsErrors}`);
-  pageErrors.forEach(e => log(`  [PAGEERROR] ${e.message}`));
-  log(`Console 错误: ${errors.length}`);
-  errors.forEach(e => log(`  [ERROR] ${e.text}`));
-  log(`Console 警告: ${warnings.length}`);
-  warnings.forEach(e => log(`  [WARN] ${e.text}`));
-  log(`Console 消息总数: ${consoleMessages.length}`);
-  log(`失败网络请求: ${result.summary.failedNetwork}`);
-  failedRequests.forEach(r => log(`  [${r.status}] ${r.url}`));
-  log(`API 请求: ${result.summary.totalAPI} (失败: ${result.summary.failedAPI})`);
-  apiRequests.forEach(r => {
-    const marker = r.status >= 400 ? '❌' : '✅';
-    log(`  ${marker} [${r.status}] ${r.method} ${r.url}`);
-  });
-  log(`CSS/JS 资源: ${result.summary.totalResources} (失败: ${result.summary.failedResources})`);
-  resourceRequests.filter(r => r.status >= 400).forEach(r => log(`  ❌ [${r.status}] ${r.url}`));
-  if (iframeInfo.length > 0) {
-    log(`\niframe 信息:`);
-    iframeInfo.forEach(f => log(`  ${f.url} → ${f.error || (f.hasReactRoot ? 'React已挂载' : '未挂载')}`));
-  }
-
-  // 保存结果
-  if (OUTPUT) {
-    fs.writeFileSync(OUTPUT, JSON.stringify(result, null, 2));
-    log(`\n[OK] 结果已保存: ${OUTPUT}`);
-  }
-
-  return result;
-}
-
-// ===== Action: screenshot =====
-async function screenshot(browser) {
-  ensureDir(OUTPUT_DIR);
-  const page = await findPage(browser);
-  const filename = getArg('filename', 'screenshot.png');
-  const fullPath = path.join(OUTPUT_DIR, filename);
-  const fullPage = hasFlag('full-page');
-  await page.screenshot({ path: fullPath, fullPage });
-  log(`[OK] 截图已保存: ${fullPath}`);
-  return { filepath: fullPath };
-}
-
-// ===== Action: api-check =====
-async function apiCheck(browser) {
-  const page = await findPage(browser);
-  log(`[PAGE] ${page.url()}`);
-
-  const requests = [];
-  const failed = [];
-
-  page.on('response', resp => {
-    const type = resp.request().resourceType();
-    if (type === 'xhr' || type === 'fetch') {
-      requests.push({
-        status: resp.status(),
-        url: resp.url(),
-        method: resp.request().method(),
-        frameUrl: resp.request().frame()?.url?.() || '',
-      });
-    }
-  });
-  page.on('requestfailed', req => {
-    failed.push({ url: req.url(), error: req.failure()?.errorText });
-  });
-
-  log('[INFO] 刷新页面收集 API 请求...');
-  try { await page.reload({ waitUntil: 'load', timeout: 30000 }); } catch {}
-  await new Promise(r => setTimeout(r, WAIT_MS));
-
-  log('\n========== API 请求 ==========');
-  requests.forEach(r => {
-    const marker = r.status >= 400 ? '❌' : '✅';
-    const isIframe = r.frameUrl && r.frameUrl !== page.url() ? ' [iframe]' : '';
-    log(`${marker} [${r.status}] ${r.method} ${r.url}${isIframe}`);
-  });
-  if (failed.length > 0) {
-    log('\n========== 失败请求 ==========');
-    failed.forEach(r => log(`[FAILED] ${r.url} → ${r.error}`));
-  }
-  log(`\n总计: ${requests.length} 请求, 失败: ${requests.filter(r => r.status >= 400).length + failed.length}`);
-
-  return { requests, failed };
-}
-
-// ===== Action: plan =====
-async function executePlan(browser) {
-  const planPath = PLAN_FILE;
-  if (!planPath) { log('[ERROR] --plan-file 未指定'); return; }
-  const plan = JSON.parse(fs.readFileSync(planPath, 'utf-8'));
-  ensureDir(plan.options?.outputDir || OUTPUT_DIR);
-
-  log(`[PLAN] ${plan.description || plan.planId}`);
-  log(`[STEPS] ${plan.steps.length} 个步骤`);
-
-  const results = [];
-  let currentPage = await findPage(browser);
-
-  for (let i = 0; i < plan.steps.length; i++) {
-    const step = plan.steps[i];
-    const start = Date.now();
-    try {
-      let result = {};
-      switch (step.type) {
-        case 'navigate':
-          await currentPage.goto(step.url, { waitUntil: step.waitUntil || 'domcontentloaded', timeout: 30000 });
-          result = { url: currentPage.url() };
-          break;
-        case 'screenshot':
-          const fp = path.join(plan.options?.outputDir || OUTPUT_DIR, step.filename || `step-${i}.png`);
-          await currentPage.screenshot({ path: fp, fullPage: step.fullPage });
-          result = { filepath: fp };
-          break;
-        case 'waitFor':
-          if (step.selector) await currentPage.waitForSelector(step.selector, { timeout: step.timeout || 10000 });
-          result = { matched: true };
-          break;
-        case 'evaluate':
-          const evalResult = await currentPage.evaluate(step.expression);
-          result = { result: evalResult };
-          break;
-        case 'click':
-          await currentPage.click(step.selector);
-          result = { clicked: true };
-          break;
-        case 'checkElement':
-          const count = await currentPage.$$eval(step.selector, els => els.length).catch(() => 0);
-          const passed = step.expect?.minCount ? count >= step.expect.minCount : count > 0;
-          result = { passed, elementCount: count };
-          break;
-        default:
-          result = { skipped: true, reason: `unknown step type: ${step.type}` };
-      }
-      const duration = Date.now() - start;
-      results.push({ index: i, step: step.type, status: 'PASS', duration, ...result });
-      log(`  [${i + 1}/${plan.steps.length}] ✅ ${step.type} (${duration}ms)`);
-    } catch (e) {
-      const duration = Date.now() - start;
-      results.push({ index: i, step: step.type, status: 'FAIL', duration, error: e.message });
-      log(`  [${i + 1}/${plan.steps.length}] ❌ ${step.type} (${duration}ms) → ${e.message.substring(0, 100)}`);
-    }
-  }
-
-  const summary = {
-    total: results.length,
-    passed: results.filter(r => r.status === 'PASS').length,
-    failed: results.filter(r => r.status === 'FAIL').length,
-  };
-  log(`\n[RESULT] ${summary.passed}/${summary.total} 通过`);
-
-  if (OUTPUT) {
-    fs.writeFileSync(OUTPUT, JSON.stringify({ steps: results, summary }, null, 2));
-  }
-  return { steps: results, summary };
-}
-
-// ===== 主入口 =====
-(async () => {
-  // 检测 CDP
-  const cdpInfo = await checkCDP(CDP_URL);
-  if (!cdpInfo) {
-    log(`[ERROR] 无法连接到 CDP: ${CDP_URL}`);
-    log('请确保浏览器已启动调试端口:');
-    log('  Windows Edge: "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe" --remote-debugging-port=9222');
-    log('  Windows Chrome: "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" --remote-debugging-port=9222');
-    process.exit(1);
-  }
-  log(`[CDP] ${cdpInfo.Browser || 'connected'} (${CDP_URL})`);
-
-  const browser = await puppeteer.connect({ browserURL: CDP_URL, defaultViewport: null });
-
-  let result;
-  switch (ACTION) {
-    case 'list-pages': result = await listPages(browser); break;
-    case 'diagnose': result = await diagnose(browser); break;
-    case 'screenshot': result = await screenshot(browser); break;
-    case 'api-check': result = await apiCheck(browser); break;
-    case 'plan': result = await executePlan(browser); break;
-    default: log(`[ERROR] 未知 action: ${ACTION}`);
-  }
-
-  browser.disconnect();
-  log('\n[DONE]');
-})();