@szc-ft/mcp-szcd-client 0.34.1 → 0.34.2

package/standard-skill/local-browser-test/local-browser-executor.js

@@ -238,6 +238,24 @@ function parseArgs() {
             case "--fail-on-falsy":
                 parsed.failOnFalsy = true;
                 break;
+            case "--filename":
+                parsed.filename = args[++i];
+                break;
+            case "--full-page":
+                parsed.fullPage = true;
+                break;
+            case "--output-dir":
+                parsed.outputDir = args[++i];
+                break;
+            case "--interval":
+                parsed.interval = Number.parseInt(args[++i], 10);
+                break;
+            case "--max-rounds":
+                parsed.maxRounds = Number.parseInt(args[++i], 10);
+                break;
+            case "--no-reload":
+                parsed.noReload = true;
+                break;
             case "--help":
             case "-h":
                 printHelp();
@@ -264,7 +282,7 @@ function printHelp() {
   node local-browser-executor.js --plan-file <path> [options]
 
 选项:
-  --action <name>                    直接执行动作，当前支持 observe/act/assert/evaluate/api-capture/assert-api/run-task/test-case/plan
+  --action <name>                    直接执行动作，当前支持 observe/act/assert/evaluate/api-capture/assert-api/run-task/test-case/plan/list-pages/diagnose/perf/watch
   --plan <json>                      测试计划 JSON 字符串
   --plan-file <path>                 测试计划 JSON 文件路径
   --output <path>                    结果输出文件路径（默认 stdout）
@@ -324,6 +342,12 @@ function printHelp() {
   --snapshot-each                    run-task 每条菜单成功后做一次轻量 observe
   --screenshot-each                  run-task 失败时截图（依赖 outputDir，默认关闭）
   --no-continue-on-fail              run-task 第一条失败即终止（默认遇错继续）
+  --filename <name>                  screenshot / diagnose 截图文件名
+  --full-page                        screenshot 全页截图
+  --output-dir <dir>                 screenshot / diagnose / watch 产物目录
+  --interval <ms>                    watch 监控间隔（默认 5000）
+  --max-rounds <n>                   watch 最大轮数（默认 60）
+  --no-reload                        diagnose 不刷新页面（默认刷新）
   -h, --help                         显示帮助
 `);
 }
@@ -494,6 +518,11 @@ async function executeAction(args) {
                     frameUrlContains: args.frameUrlContains,
                     frameContentContains: args.frameContentContains,
                     frameIndex: args.frameIndex,
+                    drawerTriggerSelector: args.drawerTriggerSelector,
+                    drawerOpenSelector: args.drawerOpenSelector,
+                    menuScrollContainer: args.menuScrollContainer,
+                    useNativeHover: args.useNativeHover,
+                    maxRetryPerStep: args.maxRetryPerStep,
                 });
                 if (!args.observeAfter) {
                     return { type: "act", ...actResult, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
@@ -671,11 +700,180 @@ async function executeAction(args) {
 
                 return { type: "testCase", ...result, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
             }
+            case "list-pages":
+            case "listPages": {
+                const pages = await engine._safeGetPages();
+                const result = [];
+                for (let i = 0; i < pages.length; i++) {
+                    let title = "";
+                    try { title = await pages[i].title(); } catch {}
+                    result.push({ index: i, url: pages[i].url(), title });
+                }
+                return { type: "list-pages", pages: result, total: result.length, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
+            }
+            case "screenshot": {
+                const filename = args.filename || "screenshot.png";
+                const outputDir = args.outputDir || "./";
+                if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+                const filepath = path.join(outputDir, filename);
+                await engine.page.screenshot({ path: filepath, fullPage: args.fullPage });
+                return { type: "screenshot", filepath, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
+            }
+            case "diagnose": {
+                const outputDir = args.outputDir || "./";
+                if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+                const pageErrors = [];
+                const consoleMessages = [];
+                const failedRequests = [];
+                const apiRequests = [];
+                const resourceRequests = [];
+
+                engine.page.on("pageerror", (err) => {
+                    pageErrors.push({ message: err.message, stack: err.stack?.split("\n").slice(0, 5).join("\n") });
+                });
+                engine.page.on("console", (msg) => {
+                    consoleMessages.push({ type: msg.type(), text: msg.text().substring(0, 500) });
+                });
+                engine.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 });
+                    }
+                });
+                engine.page.on("requestfailed", (req) => {
+                    failedRequests.push({ status: "ABORTED", url: req.url(), error: req.failure()?.errorText });
+                });
+
+                if (!args.noReload) {
+                    try { await engine.page.reload({ waitUntil: "load", timeout: 30000 }); } catch {}
+                }
+                await new Promise((r) => setTimeout(r, args.wait || 5000));
+
+                const screenshotPath = path.join(outputDir, args.filename || "diagnose-screenshot.png");
+                await engine.page.screenshot({ path: screenshotPath, fullPage: false });
+
+                const frames = engine.page.frames();
+                const iframeInfo = [];
+                for (const frame of frames) {
+                    const url = frame.url();
+                    if (url === engine.page.url() || url === "about:blank") continue;
+                    try {
+                        const info = await frame.evaluate(() => ({
+                            bodyText: document.body?.innerText?.substring(0, 200) || "",
+                            antdElements: document.querySelectorAll("[class*='ant-']").length,
+                        }));
+                        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");
+
+                return {
+                    type: "diagnose",
+                    url: engine.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: errors.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,
+                    },
+                    browserInfo: initResult,
+                    startTime: startedAt,
+                    endTime: new Date().toISOString(),
+                };
+            }
+            case "perf": {
+                const perfMetrics = await engine.page.evaluate(() => {
+                    const perf = performance.getEntriesByType("navigation")[0];
+                    const paint = performance.getEntriesByType("paint");
+                    const fcp = paint.find((p) => p.name === "first-contentful-paint");
+                    const resources = performance.getEntriesByType("resource");
+                    return {
+                        dns: perf?.domainEnd - perf?.domainStart || 0,
+                        tcp: perf?.connectEnd - perf?.connectStart || 0,
+                        ttfb: perf?.responseStart - perf?.requestStart || 0,
+                        domReady: perf?.domContentLoadedEventEnd - perf?.startTime || 0,
+                        loadComplete: perf?.loadEventEnd - perf?.startTime || 0,
+                        fcp: fcp?.startTime || null,
+                        totalResources: resources.length,
+                        totalTransferSize: resources.reduce((sum, r) => sum + (r.transferSize || 0), 0),
+                        slowResources: resources.filter((r) => r.duration > 1000).map((r) => ({
+                            name: r.name.split("/").pop(), duration: Math.round(r.duration), size: r.transferSize,
+                        })),
+                    };
+                });
+
+                let webVitals = {};
+                try {
+                    const client = await engine.page.target().createCDPSession();
+                    await client.send("Performance.enable");
+                    const metrics = await client.send("Performance.getMetrics");
+                    const m = {};
+                    metrics.metrics.forEach((item) => { m[item.name] = item.value; });
+                    webVitals = {
+                        layoutCount: m.LayoutCount || 0,
+                        recalcCount: m.RecalcLayoutCount || 0,
+                        jsHeapUsed: Math.round((m.JSHeapUsedSize || 0) / 1024 / 1024) + "MB",
+                        jsHeapTotal: Math.round((m.JSHeapTotalSize || 0) / 1024 / 1024) + "MB",
+                        taskDuration: (m.TaskDuration || 0).toFixed(2) + "s",
+                    };
+                    await client.send("Performance.disable");
+                    await client.detach();
+                } catch {}
+
+                return { type: "perf", perfMetrics, webVitals, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
+            }
+            case "watch": {
+                const interval = args.interval || 5000;
+                const maxRounds = args.maxRounds || 60;
+                const outputDir = args.outputDir || "./";
+                if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+                const watchErrors = [];
+                engine.page.on("pageerror", (err) => watchErrors.push({ time: new Date().toISOString(), error: err.message }));
+                engine.page.on("console", (msg) => {
+                    if (msg.type() === "error") watchErrors.push({ time: new Date().toISOString(), type: "console", text: msg.text() });
+                });
+
+                for (let i = 1; i <= maxRounds; i++) {
+                    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+                    const fp = path.join(outputDir, `watch-${String(i).padStart(3, "0")}-${ts}.png`);
+                    await engine.page.screenshot({ path: fp });
+                    await new Promise((r) => setTimeout(r, interval));
+                }
+
+                return { type: "watch", rounds: maxRounds, errors: watchErrors, browserInfo: initResult, startTime: startedAt, endTime: new Date().toISOString() };
+            }
             default:
                 return {
                     error: `未知 action: ${args.action}`,
                     errorCode: "UNKNOWN_ACTION",
-                    supportedActions: ["observe", "act", "assert", "evaluate", "api-capture", "assert-api", "run-task", "test-case", "plan"],
+                    supportedActions: ["observe", "act", "assert", "evaluate", "api-capture", "assert-api", "run-task", "test-case", "plan", "list-pages", "screenshot", "diagnose", "perf", "watch"],
                     startTime: startedAt,
                     endTime: new Date().toISOString(),
                 };