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

package/qwen-extension/skills/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(),
                 };

package/scripts/lib/codex.js

@@ -23,6 +23,8 @@
  *   1. MCP：优先 spawn `codex mcp remove` 再 `codex mcp add`（CLI 自己做 TOML 合并 + 幂等）
  *   2. MCP fallback：找不到 `codex` 时直接写 config.toml（扁平 TOML，与 CLI 序列化一致）
  *   3. Skill：调用 deps.copySkill(...) 把 standard-skill/* 整目录拷到 ~/.agents/skills/
+ *   4. Command：Codex 无自定义命令目录，把 commands/*.md 转换为 Open Agent Skills：
+ *      ~/.agents/skills/<command-name>/SKILL.md
  */
 
 import fs from "node:fs";
@@ -201,6 +203,105 @@ function copySkillsToCodex(deps) {
     return { ok: results.every(r => r.ok), results, skillsRoot };
 }
 
+// ==================== Command → Skill 转换 ====================
+
+function getCommandsSourceDirectory(deps) {
+    return path.join(deps.PACKAGE_ROOT, "commands");
+}
+
+function copyCommandsAsSkillsToCodex(deps) {
+    const commandsSourceDir = getCommandsSourceDirectory(deps);
+    if (!fs.existsSync(commandsSourceDir)) {
+        console.log("⏭️  Skipping Codex command-to-skill install: commands source directory not found");
+        return { ok: true, skipped: true, results: [] };
+    }
+
+    const skillsRoot = getCodexSkillsDirectory();
+    const commandFiles = fs.readdirSync(commandsSourceDir).filter((f) => f.endsWith(".md"));
+    const results = [];
+
+    for (const commandFile of commandFiles) {
+        const sourcePath = path.join(commandsSourceDir, commandFile);
+        const commandName = path.basename(commandFile, ".md");
+        const skillDir = path.join(skillsRoot, commandName);
+        const destPath = path.join(skillDir, "SKILL.md");
+
+        try {
+            const sourceContent = fs.readFileSync(sourcePath, "utf8");
+            const skillContent = renderCommandAsSkill(commandName, sourceContent);
+            deps.ensureDirectory?.(skillDir) ?? fs.mkdirSync(skillDir, { recursive: true });
+
+            if (fs.existsSync(destPath)) {
+                const existingContent = fs.readFileSync(destPath, "utf8").trim();
+                if (existingContent !== skillContent.trim()) {
+                    console.log(`⏭️  Skipping Codex command skill "${commandName}": already exists with custom content`);
+                    results.push({ name: commandName, ok: false, skipped: true, path: skillDir });
+                    continue;
+                }
+            }
+
+            fs.writeFileSync(destPath, skillContent);
+            console.log(`✓ Converted command "${commandName}" to Codex skill (${skillDir})`);
+            results.push({ name: commandName, ok: true, path: skillDir });
+        } catch (e) {
+            console.warn(`⚠️  Failed to convert command "${commandName}" to Codex skill: ${e.message}`);
+            results.push({ name: commandName, ok: false, error: e.message });
+        }
+    }
+
+    return { ok: results.every(r => r.ok || r.skipped), results, skillsRoot };
+}
+
+function renderCommandAsSkill(commandName, sourceContent) {
+    const { metadata, body } = splitFrontmatter(sourceContent);
+    const description = metadata.description || `Codex skill converted from /${commandName}`;
+    const argumentHint = metadata["argument-hint"];
+    const lines = [
+        "---",
+        `name: ${yamlScalar(commandName)}`,
+        `description: ${yamlScalar(description)}`,
+        "---",
+        "",
+        `# /${commandName}`,
+        "",
+    ];
+
+    if (argumentHint) {
+        lines.push(`参数提示：\`${argumentHint}\``, "");
+    }
+
+    lines.push(body.trimStart());
+    return lines.join("\n").replace(/\n*$/, "\n");
+}
+
+function splitFrontmatter(content) {
+    const match = String(content).match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!match) return { metadata: {}, body: String(content) };
+    return { metadata: parseSimpleYaml(match[1]), body: match[2] };
+}
+
+function parseSimpleYaml(yaml) {
+    const metadata = {};
+    for (const line of yaml.split(/\r?\n/)) {
+        const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!match) continue;
+        metadata[match[1]] = stripYamlScalar(match[2]);
+    }
+    return metadata;
+}
+
+function stripYamlScalar(value) {
+    const trimmed = String(value).trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+
+function yamlScalar(value) {
+    return JSON.stringify(String(value));
+}
+
 // ==================== 主入口 ====================
 
 export function setupCodex(deps) {
@@ -223,7 +324,10 @@ export function setupCodex(deps) {
     // 3) Skill 复制（独立于 MCP 注册成败，文件操作本身基本不会失败）
     const skillResult = copySkillsToCodex(deps);
 
-    return { mcp: mcpResult, skill: skillResult };
+    // 4) Command 转 Skill（Codex 无自定义命令目录，使用 Open Agent Skills 承载入口）
+    const commandSkillResult = copyCommandsAsSkillsToCodex(deps);
+
+    return { mcp: mcpResult, skill: skillResult, commandSkill: commandSkillResult };
 }
 
 function registerMcpServers(ourServers) {