@szc-ft/mcp-szcd-client 0.30.0 → 0.32.0

package/opencode-extension/skills/local-browser-test/lib/browser-engine.js

@@ -14,6 +14,12 @@
 import { findChrome, getChromeInstallGuide } from "./chrome-finder.js";
 import { AntAdapter } from "./ant-adapter.js";
 import { createExpect, locator as expectLocator, validation as expectValidation, url as expectUrl, api as expectApi } from "./expect.js";
+import { getBrowserConfigFromProcess } from "./cdp-browser-config.js";
+import { decryptAllPasswords } from "./decrypt-passwords.js";
+import { existsSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 
 export class BrowserEngine {
     constructor() {
@@ -25,6 +31,8 @@ export class BrowserEngine {
         this._adapter = null;      // 懒加载 AntAdapter
         this._lastActWasDropdown = false; // 用于 act 入口自动 closeAllDropdowns
         this._wujieContext = null;  // wujie 微前端模式 { type, frameCount, wujieApp? }
+        this._credentials = null;   // 解密后的凭据 [{ url, username, password }]，init() 时自动填充
+        this._cdpScripts = this._initCdpScripts(); // 内置通用 cdpScript
     }
 
     /**
@@ -232,15 +240,89 @@ export class BrowserEngine {
         // 微前端模式检测
         this._wujieContext = await this._detectWujieMode();
 
+        // 自动解密凭据（从浏览器密码管理器）
+        this._credentials = await this._decryptCredentials();
+
         return {
             mode: "connect",
             cdpUrl,
             currentUrl: this.page?.url() || null,
             totalPages: pages.length,
             allPageUrls: pages.map((p) => p.url()),
+            credentials: this._credentials,  // 解密后的凭据
         };
     }
 
+    /**
+     * 自动解密浏览器保存的凭据（connect 模式初始化时调用）
+     * 结果缓存到 ~/.szcd-mcp/deps/decrypted-creds.json，避免重复解密
+     * @returns {Array|null} [{ url, username, password }] 或 null
+     */
+    async _decryptCredentials() {
+        const CACHE_DIR = join(homedir(), '.szcd-mcp', 'deps');
+        const CACHE_FILE = join(CACHE_DIR, 'decrypted-creds.json');
+
+        try {
+            // 1. 检测 user-data-dir
+            const config = getBrowserConfigFromProcess();
+            if (!config?.userDataDir) return null;
+            const userDataDir = config.userDataDir;
+
+            // 2. 检查缓存（Login Data 未变 + 24 小时内）
+            const CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 小时
+            if (existsSync(CACHE_FILE)) {
+                try {
+                    const cache = JSON.parse(readFileSync(CACHE_FILE, 'utf8'));
+                    const cacheKey = `${userDataDir}::%%`;
+                    if (cache[cacheKey]) {
+                        const entry = cache[cacheKey];
+                        const age = Date.now() - entry.cachedAt;
+                        // 检查 Login Data 是否被修改
+                        const loginDataPath = join(userDataDir, 'Default', 'Login Data');
+                        if (existsSync(loginDataPath)) {
+                            const mtime = statSync(loginDataPath).mtimeMs;
+                            if (mtime > entry.cachedAt) {
+                                if (options.verbose) process.stderr.write('[browser-engine] Login Data 已更新，缓存过期\n');
+                            } else if (age > CACHE_MAX_AGE_MS) {
+                                process.stderr.write(`[browser-engine] 缓存已过期 (${Math.round(age / 3600000)}h)，重新解密\n`);
+                            } else {
+                                process.stderr.write(`[browser-engine] ✓ 凭据缓存命中 (${entry.credentials.length} 条, ${Math.round(age / 60000)}min 前)\n`);
+                                return entry.credentials;
+                            }
+                        }
+                    }
+                } catch { /* 缓存读取失败，继续解密 */ }
+            }
+
+            // 3. 解密
+            process.stderr.write('[browser-engine] 解密浏览器凭据...\n');
+            const credentials = await decryptAllPasswords({
+                userDataDir,
+                filter: '%',
+                verbose: false,
+            });
+
+            if (credentials.length === 0) return null;
+
+            // 4. 写入缓存
+            try {
+                let cache = {};
+                if (existsSync(CACHE_FILE)) {
+                    try { cache = JSON.parse(readFileSync(CACHE_FILE, 'utf8')); } catch {}
+                }
+                const cacheKey = `${userDataDir}::%%`;
+                cache[cacheKey] = { cachedAt: Date.now(), userDataDir, credentials };
+                writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf8');
+                process.stderr.write(`[browser-engine] ✓ 已缓存 ${credentials.length} 条凭据\n`);
+            } catch { /* 缓存写入失败不致命 */ }
+
+            return credentials;
+        } catch (e) {
+            process.stderr.write(`[browser-engine] 凭据解密失败: ${e.message}\n`);
+            return null;
+        }
+    }
+
     /**
      * 模式 B：启动新的 Chrome
      */
@@ -1360,6 +1442,12 @@ export class BrowserEngine {
             case "antUpload":    return this._antUpload(step);
             case "formFill":     return this._formFill(step);
             case "closeAllDropdowns": return this._closeAllDropdowns(step);
+            // ===== cdpScript / rawScript =====
+            case "apiCall": case "api-call": return this._apiCall(step);
+            case "switchPage": case "switch-page": return this._switchPage(step);
+            case "registerCdpScript": case "register-cdp-script": return this._registerCdpScript(step);
+            case "cdpScript": case "cdp-script": return this._cdpScript(step);
+            case "rawScript": case "raw-script": return this._rawScript(step);
             // ===== 语义断言层 =====
             case "expect":       return this._expect(step);
             default:
@@ -2294,6 +2382,307 @@ export class BrowserEngine {
         this.page = null;
     }
 
+    /**
+     * 通用 cdpScript 注册——封装跨项目复用的 UI 交互模式
+     * 业务特定逻辑（审核/变更/下线）由 LLM 用 rawScript 动态生成
+     */
+    _initCdpScripts() {
+        return {
+            'drawer-action': async (page, frame, params) => {
+                const { action, radioIndex, searchText, searchPlaceholder } = params;
+                if (action === 'search' && searchText !== undefined) {
+                    await frame.evaluate((text, ph) => {
+                        var inputs = document.querySelectorAll('.ant-drawer input[type=text]');
+                        for (var i = 0; i < inputs.length; i++) {
+                            if (!ph || (inputs[i].placeholder && inputs[i].placeholder.includes(ph))) {
+                                inputs[i].focus(); inputs[i].value = text;
+                                inputs[i].dispatchEvent(new InputEvent('input', { bubbles: true }));
+                                inputs[i].dispatchEvent(new Event('change', { bubbles: true }));
+                                break;
+                            }
+                        }
+                    }, searchText, searchPlaceholder);
+                    await frame.evaluate(function() {
+                        var btns = document.querySelectorAll('.ant-drawer button');
+                        for (var i = 0; i < btns.length; i++) { if (btns[i].textContent.trim() === '查 询') { btns[i].click(); return; } }
+                    });
+                    await new Promise(function(r) { setTimeout(r, 500); });
+                }
+                if (action === 'select' && radioIndex !== undefined) {
+                    await frame.evaluate(function(idx) {
+                        var radios = document.querySelectorAll('.ant-drawer .ant-radio-input');
+                        if (radios[idx]) radios[idx].click();
+                    }, radioIndex);
+                }
+                if (action === 'confirm') {
+                    await frame.evaluate(function() {
+                        var btns = document.querySelectorAll('.ant-drawer button');
+                        for (var i = 0; i < btns.length; i++) { if (btns[i].textContent.trim().replace(/\s+/g, '').indexOf('确认选择') >= 0) { btns[i].click(); return; } }
+                    });
+                    await new Promise(function(r) { setTimeout(r, 500); });
+                }
+                if (action === 'cancel') {
+                    await frame.evaluate(function() {
+                        var btns = document.querySelectorAll('.ant-drawer button');
+                        for (var i = 0; i < btns.length; i++) { if (btns[i].textContent.trim().replace(/\s+/g, '').indexOf('取消') >= 0) { btns[i].click(); return; } }
+                    });
+                }
+                return { acted: true, passed: true, action: action, status: 'PASS' };
+            },
+            'modal-action': async (page, frame, params) => {
+                var action = params.action;
+                var pattern = params.buttonText || (action === 'confirm' ? '确定|OK|确认' : '取消|Cancel');
+                await frame.evaluate(function(p) {
+                    var btns = document.querySelectorAll('.ant-modal button, .ant-modal-confirm button, .ant-popconfirm button');
+                    var re = new RegExp(p);
+                    for (var i = 0; i < btns.length; i++) { if (re.test(btns[i].textContent.trim().replace(/\s+/g, ''))) { btns[i].click(); return; } }
+                }, pattern);
+                await new Promise(function(r) { setTimeout(r, 500); });
+                return { acted: true, passed: true, action: action, status: 'PASS' };
+            },
+            'switch-tab': async (page, frame, params, browser) => {
+                var urlContains = params.urlContains, titleIncludes = params.titleIncludes, pageIndex = params.pageIndex;
+                var pages = await browser.pages();
+                var target = null;
+                if (urlContains) target = pages.find(function(p) { return p.url().indexOf(urlContains) >= 0; });
+                else if (titleIncludes) { for (var p = 0; p < pages.length; p++) { if ((await pages[p].title().catch(function() { return ''; })).indexOf(titleIncludes) >= 0) { target = pages[p]; break; } } }
+                else if (pageIndex !== undefined) target = pages[pageIndex];
+                if (!target) return { acted: false, passed: false, reason: 'tab not found: ' + (urlContains || titleIncludes || pageIndex), status: 'FAIL' };
+                await target.bringToFront();
+                return { acted: true, passed: true, url: target.url(), status: 'PASS' };
+            },
+            'wait-api': async (page, frame, params) => {
+                var urlPattern = params.urlPattern, timeout = params.timeout || 10000, method = params.method;
+                return new Promise(function(resolve) {
+                    var timer = setTimeout(function() { resolve({ acted: false, passed: false, reason: 'timeout: ' + urlPattern, status: 'FAIL' }); }, timeout);
+                    page.on('response', function(response) {
+                        if (response.url().indexOf(urlPattern) >= 0 && (!method || response.request().method() === method.toUpperCase())) {
+                            clearTimeout(timer);
+                            resolve({ acted: true, passed: response.status() < 400, status: response.status(), url: response.url().slice(0, 100) });
+                        }
+                    });
+                });
+            },
+            'get-table-data': async (page, frame, params) => {
+                var selector = params.selector || '.ant-table', maxRows = params.maxRows || 50;
+                var data = await frame.evaluate(function(sel, max) {
+                    var table = document.querySelector(sel);
+                    if (!table) return { found: false, headers: [], rows: [] };
+                    var headers = []; table.querySelectorAll('.ant-table-thead th').forEach(function(th) { headers.push(th.textContent.trim()); });
+                    var rows = []; var trs = table.querySelectorAll('.ant-table-tbody tr');
+                    for (var i = 0; i < Math.min(trs.length, max); i++) {
+                        var cells = trs[i].querySelectorAll('td');
+                        rows.push(Array.from(cells).map(function(c) { return { text: c.textContent.trim().slice(0, 80), actions: Array.from(c.querySelectorAll('a,button')).map(function(l) { return l.textContent.trim(); }).filter(Boolean) }; }));
+                    }
+                    return { found: true, headers: headers, rows: rows, rowCount: trs.length };
+                }, selector, maxRows);
+                return { acted: true, passed: data.found, data: data, status: data.found ? 'PASS' : 'FAIL' };
+            },
+            'login': async (page, frame, params, browser, engine) => {
+                var username = params.username, password = params.password;
+                if (!username) return { acted: false, passed: false, reason: 'login requires username', status: 'FAIL' };
+                // 如果没有提供密码，从缓存凭据中查找
+                if (!password && engine && engine._credentials) {
+                    var cred = engine._credentials.find(function(c) { return c.username === username; });
+                    if (cred) password = cred.password;
+                }
+                if (!password) return { acted: false, passed: false, reason: 'password not found for: ' + username, status: 'FAIL' };
+                var captcha = params.captcha || '6';
+                var maxRetries = params.maxRetries || 3;
+
+                // 0. 构建带参登录URL
+                var appId = params.appId, viewId = params.viewId;
+                if (!appId) {
+                    try {
+                        for (var k = 0; k < page.frames().length; k++) {
+                            try {
+                                var fu = page.frames()[k].url();
+                                var am = fu.match(/appId=(\\d+)/);
+                                var vm = fu.match(/viewId=(\\d+)/);
+                                if (am) { appId = am[1]; if (vm) viewId = vm[1]; break; }
+                            } catch (e) { /* skip */ }
+                        }
+                    } catch (e) { /* ignore */ }
+                }
+                var loginUrl = params.loginUrl || 'http://platform.aicityos.com:32222/ucenter/login/';
+                if (appId && viewId) loginUrl += '#/user/login?appId=' + appId + '&viewId=' + viewId;
+
+                // 尝试登录，验证码过期自动重试
+                for (var attempt = 0; attempt < maxRetries; attempt++) {
+                    // 导航到登录页（重试时刷新获取新验证码）
+                    await page.goto(loginUrl, { waitUntil: 'domcontentloaded', timeout: 10000 }).catch(function(){});
+                    await new Promise(function(r) { setTimeout(r, attempt === 0 ? 2000 : 1000); });
+
+                    // 1. 使用 antInput 统一填表
+                    var steps = [
+                        { placeholder: '请输入账户', value: username },
+                        { placeholder: '请输入密码', value: password },
+                        { placeholder: '请输入图形验证码', value: captcha },
+                    ];
+                    for (var i = 0; i < steps.length; i++) {
+                        var s = steps[i];
+                        var adapter = new (await import('./ant-adapter.js')).AntAdapter();
+                        await adapter.input(frame, { placeholder: s.placeholder }, s.value, { clear: true, stepDelay: 200 });
+                    }
+
+                    // 2. 点击登录
+                    await frame.evaluate(function() {
+                        var btns = document.querySelectorAll('button');
+                        for (var i = 0; i < btns.length; i++) {
+                            var t = btns[i].textContent || '';
+                            if (t.indexOf('登') >= 0 && t.indexOf('录') >= 0) { btns[i].click(); return 'clicked'; }
+                        }
+                        return 'not found';
+                    });
+                    await new Promise(function(r) { setTimeout(r, 4000); });
+
+                    // 3. 检查是否登录成功
+                    var loggedIn = page.url().indexOf('/login') < 0;
+                    if (loggedIn) {
+                        return { acted: true, passed: true, username: username, loggedIn: true, appId: appId, viewId: viewId, url: page.url(), attempts: attempt + 1, status: 'PASS' };
+                    }
+
+                    // 失败时可能是验证码过期，检查是否有错误提示
+                    var hasError = await frame.evaluate(function() {
+                        var errs = document.querySelectorAll('.ant-message-notice,.ant-form-item-explain-error');
+                        for (var e = 0; e < errs.length; e++) {
+                            var t = errs[e].textContent.trim();
+                            if (t && (t.indexOf('验证码') >= 0 || t.indexOf('错误') >= 0)) return true;
+                        }
+                        return false;
+                    }).catch(function() { return false; });
+
+                    if (attempt < maxRetries - 1) {
+                        process.stderr.write('[cdpScript:login] 验证码可能过期，刷新重试 (' + (attempt + 2) + '/' + maxRetries + ')...\n');
+                    }
+                }
+
+                return { acted: true, passed: false, username: username, loggedIn: false, appId: appId, viewId: viewId, url: page.url(), attempts: maxRetries, status: 'FAIL', reason: 'login failed after ' + maxRetries + ' attempts' };
+            },
+            'logout': async (page, frame, params, browser) => {
+                var appUrl = params.appUrl || '/szc-ai-data/';
+                var frames = page.frames();
+                var childFrame = frames.find(function(f) { return f.url().indexOf(appUrl) >= 0; });
+                if (!childFrame && frames.length > 1) childFrame = frames[1];
+
+                // 1. 从主 frame 获取 appId/viewId（wujie 父应用注入）
+                var appId = null, viewId = null;
+                var mainFrame = page.mainFrame();
+                try {
+                    var wujieProps = await mainFrame.evaluate(function() {
+                        if (window.$wujie && window.$wujie.props) {
+                            return { appId: window.$wujie.props.appId, viewId: window.$wujie.props.viewId };
+                        }
+                        // 退而求其次：从 URL 解析
+                        var hash = location.hash || '';
+                        var appIdMatch = hash.match(/appId=(\d+)/);
+                        var viewIdMatch = hash.match(/viewId=(\d+)/);
+                        if (appIdMatch) return { appId: appIdMatch[1], viewId: viewIdMatch ? viewIdMatch[1] : null };
+                        return null;
+                    });
+                    if (wujieProps) { appId = wujieProps.appId; viewId = wujieProps.viewId; }
+                } catch (e) { /* ignore */ }
+                if (!appId && childFrame) {
+                    try {
+                        // 从子 frame URL 解析
+                        var cfUrl = childFrame.url();
+                        var appMatch = cfUrl.match(/appId=(\d+)/);
+                        var viewMatch = cfUrl.match(/viewId=(\d+)/);
+                        if (appMatch) { appId = appMatch[1]; viewId = viewMatch ? viewMatch[1] : null; }
+                    } catch (e) { /* ignore */ }
+                }
+
+                // 2. 尝试调用 loginOut
+                var loginOutResult = null;
+                if (childFrame) {
+                    loginOutResult = await childFrame.evaluate(function() {
+                        try {
+                            if (window.$wujie && window.$wujie.props && typeof window.$wujie.props.loginOut === 'function') {
+                                window.$wujie.props.loginOut();
+                                return 'loginOut called';
+                            }
+                        } catch (e) { return 'error: ' + e.message; }
+                        return 'no loginOut prop';
+                    }).catch(function() { return 'evaluate failed'; });
+                }
+
+                // 3. 兜底：清除所有 cookie
+                await page.evaluate(function() {
+                    document.cookie.split(';').forEach(function(c) {
+                        var name = c.replace(/^ +/, '').split('=')[0];
+                        document.cookie = name + '=;expires=' + new Date(0).toUTCString() + ';path=/';
+                    });
+                });
+
+                // 4. 构建带参数的登录 URL（保留 appId/viewId）
+                var loginUrl = 'http://platform.aicityos.com:32222/ucenter/login/';
+                if (appId && viewId) {
+                    loginUrl += '#/user/login?appId=' + appId + '&viewId=' + viewId;
+                }
+                await page.goto(loginUrl, { waitUntil: 'domcontentloaded', timeout: 10000 }).catch(function(){});
+                await new Promise(function(r) { setTimeout(r, 2000); });
+
+                var loggedOut = page.url().indexOf('/login') >= 0;
+                return { acted: true, passed: loggedOut, loginOutResult: loginOutResult, appId: appId, viewId: viewId, loggedOut: loggedOut, url: page.url(), status: loggedOut ? 'PASS' : 'FAIL' };
+            },
+        };
+    }
+
+    _registerCdpScript(step) {
+        if (!this._cdpScripts) this._cdpScripts = {};
+        try {
+            this._cdpScripts[step.name] = new Function('page', 'frame', 'params', 'browser', 'return (' + step.code + ')(page, frame, params, browser)');
+            return { type: 'registerCdpScript', name: step.name, registered: true, status: 'PASS', passed: true };
+        } catch (e) {
+            return { type: 'registerCdpScript', name: step.name, registered: false, reason: 'compile error: ' + e.message, status: 'FAIL', passed: false };
+        }
+    }
+
+    async _cdpScript(step) {
+        var scripts = this._cdpScripts || {};
+        var fn = scripts[step.script];
+        if (!fn) return { type: 'cdpScript', passed: false, reason: 'cdpScript "' + step.script + '" not registered', status: 'FAIL' };
+        var target = await this._getTargetFrame(step);
+        var result = await fn(this.page, target.frame, step.params || {}, this.browser, this);
+        return Object.assign({ type: 'cdpScript', script: step.script }, result);
+    }
+
+    async _rawScript(step) {
+        var target = await this._getTargetFrame(step);
+        var fn;
+        try { fn = new Function('page', 'frame', 'params', 'browser', 'return (' + step.code + ')(page, frame, params, browser)'); }
+        catch (e) { return { type: 'rawScript', passed: false, reason: 'script compile error: ' + e.message, status: 'FAIL' }; }
+        try {
+            var result = await fn(this.page, target.frame, step.params || {}, this.browser);
+            return Object.assign({ type: 'rawScript' }, result);
+        } catch (e) { return { type: 'rawScript', passed: false, reason: 'script execution error: ' + e.message, status: 'FAIL' }; }
+    }
+
+    async _apiCall(step) {
+        var method = (step.method || 'POST').toUpperCase();
+        var response = await this.page.evaluate(async function(opts) {
+            var res = await fetch(opts.url, { method: opts.method, headers: Object.assign({ 'Content-Type': 'application/json' }, opts.headers || {}), body: opts.body ? JSON.stringify(opts.body) : undefined });
+            var data = await res.text();
+            try { return { status: res.status, data: JSON.parse(data) }; } catch(e) { return { status: res.status, data: data }; }
+        }, { method: method, url: step.url, body: step.body, headers: step.headers });
+        var passed = response.status >= 200 && response.status < 300;
+        return { type: 'apiCall', status: response.status, data: typeof response.data === 'string' ? response.data.slice(0, 500) : response.data, passed: passed, reason: passed ? null : 'API returned ' + response.status };
+    }
+
+    async _switchPage(step) {
+        var pages = await this.browser.pages();
+        var target = null;
+        if (step.urlContains) target = pages.find(function(p) { return p.url().indexOf(step.urlContains) >= 0; });
+        else if (step.titleIncludes) { for (var p = 0; p < pages.length; p++) { if ((await pages[p].title().catch(function() { return ''; })).indexOf(step.titleIncludes) >= 0) { target = pages[p]; break; } } }
+        else if (step.pageIndex !== undefined) target = pages[step.pageIndex];
+        if (!target) return { type: 'switchPage', passed: false, reason: 'page not found: ' + (step.urlContains || step.titleIncludes || step.pageIndex), totalPages: pages.length, status: 'FAIL' };
+        await target.bringToFront();
+        this.page = target;
+        this._activeFrame = null;
+        var url = target.url();
+        return { type: 'switchPage', passed: true, url: url, title: await target.title().catch(function() { return ''; }), status: 'PASS' };
+    }
+
     /**
      * 执行测试用例：支持 dataset 参数化、变量替换
      * @param {object} testCase - 用例配置
@@ -2305,6 +2694,9 @@ export class BrowserEngine {
         const results = [];
         const dataset = testCase.dataset || [{ __row: 0 }];
 
+        // 自动开启浏览器错误和网络监控
+        const monitor = await this._startAutoCapture();
+
         // setup 阶段：page 切换 + frame 预定位
         if (testCase.setup?.findPage) {
             const pageResult = await this._findPage(testCase.setup.findPage);
@@ -2401,15 +2793,41 @@ export class BrowserEngine {
         const passed = results.filter((r) => r.status === "PASS").length;
         const failed = results.filter((r) => r.status === "FAIL").length;
 
+        // 停止监控并收集数据
+        const capturedErrors = await this._stopAutoCapture(monitor);
+
+        // 生成诊断提示（帮助 LLM 推断失败原因）
+        const diagnosticHint = failed > 0 ? this._generateDiagnosticHint(results, capturedErrors) : null;
+
+        // L3 自动修复：根据诊断结果尝试恢复并重试
+        var autoRecovery = null;
+        var shouldAutoRecover = testCase.options?.autoRecover !== false && failed > 0;
+        if (shouldAutoRecover && diagnosticHint) {
+            autoRecovery = await this._attemptAutoRecovery(testCase, context, diagnosticHint, capturedErrors);
+            if (autoRecovery?.retryResults) {
+                for (var ri = 0; ri < autoRecovery.retryResults.length; ri++) {
+                    results.push(autoRecovery.retryResults[ri]);
+                }
+            }
+        }
+
+        var finalPassed = results.filter(function(r) { return r.status === 'PASS'; }).length;
+        var finalFailed = results.filter(function(r) { return r.status === 'FAIL'; }).length;
+
         return {
             title: testCase.title,
             datasetSize: dataset.length,
             totalSteps: results.length,
-            passedSteps: passed,
-            failedSteps: failed,
-            passed: failed === 0,
+            passedSteps: finalPassed,
+            failedSteps: finalFailed,
+            passed: finalFailed === 0,
             duration,
             results,
+            browserErrors: capturedErrors.errors,
+            failedRequests: capturedErrors.failedRequests,
+            consoleErrors: capturedErrors.consoleErrors,
+            diagnosticHint,
+            autoRecovery: autoRecovery ? { strategies: autoRecovery.strategies, recovered: autoRecovery.recovered, retries: autoRecovery.retryCount } : null,
             summary: {
                 perDataset: results.reduce((acc, r) => {
                     const key = r.dataRowIndex;
@@ -2443,10 +2861,229 @@ export class BrowserEngine {
         }
         return obj;
     }
+
+    async _startAutoCapture() {
+        var self = this;
+        var monitor = { jsErrors: [], consoleErrors: [], failedRequests: [], cdpSessions: [] };
+        try {
+            if (!self.page || !self.page.target) { monitor = { jsErrors: [], consoleErrors: [], failedRequests: [], cdpSessions: [] }; return monitor; }
+            var cdp = await self.page.target().createCDPSession();
+            monitor.cdpSessions.push(cdp);
+            await cdp.send('Runtime.enable');
+            cdp.on('Runtime.exceptionThrown', function(event) {
+                var d = event.exceptionDetails || {};
+                monitor.jsErrors.push({ text: d.text || '', url: d.url || '', line: d.lineNumber || 0, time: Date.now() });
+            });
+            self.page.on('console', function(msg) {
+                if (msg.type() === 'error') monitor.consoleErrors.push({ text: msg.text(), time: Date.now() });
+            });
+            await cdp.send('Network.enable');
+            cdp.on('Network.responseReceived', function(event) {
+                var r = event.response || {};
+                if (r.status >= 400) monitor.failedRequests.push({ url: r.url, status: r.status, time: Date.now() });
+            });
+        } catch(e) { process.stderr.write('[auto-capture] setup: '+e.message+'\n'); }
+        return monitor;
+    }
+
+    async _stopAutoCapture(monitor) {
+        if (!monitor) return { errors: [], failedRequests: [], consoleErrors: [] };
+        try {
+            for (var i = 0; i < monitor.cdpSessions.length; i++) {
+                try { monitor.cdpSessions[i].send('Runtime.disable').catch(function(){}); } catch(e) {}
+                try { monitor.cdpSessions[i].send('Network.disable').catch(function(){}); } catch(e) {}
+            }
+        } catch(e) {}
+        return { errors: monitor.jsErrors || [], failedRequests: monitor.failedRequests || [], consoleErrors: monitor.consoleErrors || [] };
+    }
+
+    /**
+     * L2 智能诊断：分析失败步骤和捕获的错误，生成结构化诊断提示
+     * 帮助 LLM 结合 SKILL.md 上下文推断失败原因并决定恢复策略
+     */
+    _generateDiagnosticHint(results, capturedErrors) {
+        var failedSteps = results.filter(function(r) { return r.status === 'FAIL'; });
+        var hints = [];
+        var suggestions = [];
+
+        // 1. 分析失败步骤
+        failedSteps.forEach(function(step) {
+            var info = { step: step.step, stepIndex: step.stepIndex, dataRowIndex: step.dataRowIndex };
+            if (step.error) info.error = step.error;
+            if (step.reason) info.reason = step.reason;
+            hints.push(info);
+        });
+
+        // 2. 分析网络错误
+        var failedReqs = capturedErrors.failedRequests || [];
+        if (failedReqs.length > 0) {
+            var statusCodes = {};
+            failedReqs.forEach(function(r) {
+                statusCodes[r.status] = (statusCodes[r.status] || 0) + 1;
+            });
+            hints.push({ type: 'network', failedCount: failedReqs.length, statusCodes: statusCodes, samples: failedReqs.slice(0, 3) });
+        }
+
+        // 3. 分析 JS 错误
+        if (capturedErrors.errors && capturedErrors.errors.length > 0) {
+            hints.push({ type: 'browserErrors', count: capturedErrors.errors.length, samples: capturedErrors.errors.slice(0, 5) });
+        }
+
+        // 4. 推断建议
+        if (failedReqs.some(function(r) { return r.status === 401 || r.status === 403; })) {
+            suggestions.push('检测到 401/403 响应，session 可能已过期，建议重新登录');
+        }
+        if (failedReqs.some(function(r) { return r.status >= 500; })) {
+            suggestions.push('服务器 5xx 错误，可能是后端服务异常，建议稍后重试或检查服务状态');
+        }
+
+        var loginFailed = failedSteps.some(function(s) {
+            return s.step === 'cdpScript' && (s.script === 'login') || s.step === 'antInput';
+        });
+        var loggedIn = results.some(function(s) { return s.status === 'PASS' && (s.loggedIn === true); });
+        if (loginFailed && !loggedIn && failedReqs.length === 0) {
+            suggestions.push('登录步骤失败但无网络错误，可能是验证码过期，建议刷新登录页重试（验证码默认值 6）');
+        }
+
+        if (capturedErrors.errors && capturedErrors.errors.length > 0) {
+            var jsPatterns = capturedErrors.errors.map(function(e) { return e.text; }).filter(Boolean);
+            if (jsPatterns.some(function(t) { return t.indexOf('Cannot read') >= 0 || t.indexOf('undefined') >= 0; })) {
+                suggestions.push('存在 JS 空指针异常，可能是页面元素未渲染完成即执行操作，建议增加 wait 步骤');
+            }
+        }
+
+        return {
+            failedAt: hints,
+            suggestions: suggestions,
+            summary: failedSteps.length + ' 个步骤失败, ' + failedReqs.length + ' 个请求异常, ' + (capturedErrors.errors ? capturedErrors.errors.length : 0) + ' 个 JS 错误',
+        };
+    }
+
+    /**
+     * L3 自动修复：根据诊断结果执行恢复策略并重试失败步骤
+     */
+    async _attemptAutoRecovery(testCase, context, diagnosticHint, capturedErrors) {
+        var maxRetries = (testCase.options && testCase.options.autoRecoverRetries) || 2;
+        var strategies = [];
+        var retryResults = [];
+        var recovered = false;
+        var retryCount = 0;
+        var dataRow = (testCase.dataset && testCase.dataset[0]) || {};
+
+        // 匹配恢复策略
+        var hasLoginFailure = diagnosticHint.failedAt.some(function(f) {
+            return f.step === 'cdpScript' || f.step === 'antInput';
+        });
+        var hasNetworkError = (capturedErrors.failedRequests || []).length > 0;
+        var hasJsError = (capturedErrors.errors || []).length > 0;
+        var hasElementNotFound = diagnosticHint.failedAt.some(function(f) {
+            return (f.error || '').indexOf('not found') >= 0;
+        });
+
+        // 策略 A：登录失败 → 获取新验证码 → 重新登录
+        if (hasLoginFailure && !hasNetworkError) {
+            strategies.push({ type: 'login', action: '刷新登录页获取新验证码后重新登录' });
+            for (var attempt = 0; attempt < maxRetries && !recovered; attempt++) {
+                retryCount++;
+                process.stderr.write('[auto-recovery] 尝试恢复登录 (' + (attempt + 1) + '/' + maxRetries + ')...\n');
+
+                // 重新执行所有包含登录的步骤
+                var allPassed = true;
+                for (var si = 0; si < testCase.steps.length; si++) {
+                    var rawStep = testCase.steps[si];
+                    var step = this._substituteVariables(rawStep, testCase.dataset ? testCase.dataset[0] : {});
+
+                    // 只重试导航和登录相关步骤
+                    if (step.type === 'navigate' || step.type === 'antInput' || step.type === 'act' ||
+                        (step.type === 'cdpScript' && (step.script === 'login'))) {
+                        try {
+                            var result = await this.executeStep(step, context);
+                            retryResults.push(Object.assign({}, result, { stepIndex: si, dataRowIndex: 0, recovery: true, recoveryAttempt: attempt + 1 }));
+                            if (result.status === 'FAIL') allPassed = false;
+                        } catch(e) {
+                            retryResults.push({ step: step.type, status: 'FAIL', error: e.message, stepIndex: si, dataRowIndex: 0, recovery: true, recoveryAttempt: attempt + 1 });
+                            allPassed = false;
+                        }
+                    } else if (allPassed) {
+                        // 登录成功后才执行后续步骤
+                        try {
+                            var r2 = await this.executeStep(step, context);
+                            retryResults.push(Object.assign({}, r2, { stepIndex: si, dataRowIndex: 0, recovery: true }));
+                        } catch(e) {
+                            retryResults.push({ step: step.type, status: 'FAIL', error: e.message, stepIndex: si, dataRowIndex: 0, recovery: true });
+                        }
+                    }
+                }
+
+                if (allPassed) {
+                    recovered = true;
+                    strategies[strategies.length - 1].result = 'success';
+                } else if (attempt < maxRetries - 1) {
+                    strategies[strategies.length - 1].result = 'retrying';
+                } else {
+                    strategies[strategies.length - 1].result = 'exhausted';
+                }
+            }
+        }
+
+        // 策略 B：元素未找到 → 等待并重试
+        if (hasElementNotFound && !recovered) {
+            strategies.push({ type: 'elementNotFound', action: '等待页面渲染后重试' });
+            for (var ea = 0; ea < maxRetries && !recovered; ea++) {
+                retryCount++;
+                process.stderr.write('[auto-recovery] 等待页面渲染后重试 (' + (ea + 1) + '/' + maxRetries + ')...\n');
+                await new Promise(function(r) { setTimeout(r, 3000); });
+                var ep = true;
+                for (var si2 = 0; si2 < testCase.steps.length; si2++) {
+                    var s2 = this._substituteVariables(testCase.steps[si2], dataRow);
+                    try {
+                        var r3 = await this.executeStep(s2, context);
+                        retryResults.push(Object.assign({}, r3, { stepIndex: si2, dataRowIndex: 0, recovery: true, recoveryAttempt: ea + 1 }));
+                        if (r3.status === 'FAIL') ep = false;
+                    } catch(e) {
+                        retryResults.push({ step: s2.type, status: 'FAIL', error: e.message, stepIndex: si2, dataRowIndex: 0, recovery: true });
+                        ep = false;
+                    }
+                }
+                if (ep) { recovered = true; strategies[strategies.length - 1].result = 'success'; }
+                else if (ea < maxRetries - 1) strategies[strategies.length - 1].result = 'retrying';
+                else strategies[strategies.length - 1].result = 'exhausted';
+            }
+        }
+
+        // 策略 C：网络错误 → 页面重载 + 重试
+        if (hasNetworkError && !recovered) {
+            strategies.push({ type: 'networkError', action: '页面重载后重试' });
+            for (var na = 0; na < maxRetries && !recovered; na++) {
+                retryCount++;
+                process.stderr.write('[auto-recovery] 网络错误，重载页面 (' + (na + 1) + '/' + maxRetries + ')...\n');
+                try { await this.page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 }); } catch(e) {}
+                await new Promise(function(r) { setTimeout(r, 2000); });
+                var np = true;
+                for (var si3 = 0; si3 < testCase.steps.length; si3++) {
+                    var s3 = this._substituteVariables(testCase.steps[si3], dataRow);
+                    try {
+                        var r4 = await this.executeStep(s3, context);
+                        retryResults.push(Object.assign({}, r4, { stepIndex: si3, dataRowIndex: 0, recovery: true, recoveryAttempt: na + 1 }));
+                        if (r4.status === 'FAIL') np = false;
+                    } catch(e) {
+                        retryResults.push({ step: s3.type, status: 'FAIL', error: e.message, stepIndex: si3, dataRowIndex: 0, recovery: true });
+                        np = false;
+                    }
+                }
+                if (np) { recovered = true; strategies[strategies.length - 1].result = 'success'; }
+                else if (na < maxRetries - 1) strategies[strategies.length - 1].result = 'retrying';
+                else strategies[strategies.length - 1].result = 'exhausted';
+            }
+        }
+
+        return { strategies: strategies, recovered: recovered, retryCount: retryCount, retryResults: retryResults };
+    }
 }
 
 /**
- * 动态加载 puppeteer-core，从共享缓存目录加载，缺失时自动安装
+ * 动态加载 puppeteer-core 和 sql.js，从共享缓存目录加载，缺失时自动安装
+ * 主链路（observe/act/assert + 凭据解密）需要这两项依赖
  */
 async function loadPuppeteer() {
     const { ensureCoreDeps, loadFromShared } = await import("./shared-deps.js");
@@ -2459,7 +3096,7 @@ async function loadPuppeteer() {
         // 本地未安装
     }
 
-    // 2. observe/act/assert 主链路只需要 puppeteer-core
+    // 2. 安装主链路依赖（puppeteer-core + sql.js）到共享缓存
     await ensureCoreDeps();
 
     try {