@godscene/web 1.7.11

package/dist/lib/playwright/reporter/index.js

@@ -0,0 +1,212 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>reporter
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const agent_namespaceObject = require("@godscene/core/agent");
+const report_namespaceObject = require("@godscene/core/report");
+const common_namespaceObject = require("@godscene/shared/common");
+const utils_namespaceObject = require("@godscene/shared/utils");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class MidsceneReporter {
+    static getMode(reporterType) {
+        if (!reporterType) return 'merged';
+        if ('merged' !== reporterType && 'separate' !== reporterType) throw new Error(`Unknown reporter type in playwright config: ${reporterType}, only support 'merged' or 'separate'`);
+        return reporterType;
+    }
+    getSeparatedFilename(testTitle) {
+        if (!this.testTitleToFilename.has(testTitle)) {
+            const baseTag = `playwright-${(0, utils_namespaceObject.replaceIllegalPathCharsAndSpace)(testTitle)}`;
+            const generatedFilename = (0, agent_namespaceObject.getReportFileName)(baseTag);
+            this.testTitleToFilename.set(testTitle, generatedFilename);
+        }
+        return this.testTitleToFilename.get(testTitle);
+    }
+    getReportFilename(testTitle) {
+        if ('merged' === this.mode) {
+            if (!this.mergedFilename) this.mergedFilename = (0, agent_namespaceObject.getReportFileName)('playwright-merged');
+            return this.mergedFilename;
+        }
+        if ('separate' === this.mode) {
+            if (!testTitle) throw new Error('testTitle is required in separate mode');
+            return this.getSeparatedFilename(testTitle);
+        }
+        throw new Error(`Unknown mode: ${this.mode}`);
+    }
+    getReportPath(testTitle) {
+        const fileName = this.getReportFilename(testTitle);
+        if ('html-and-external-assets' === this.outputFormat) return (0, external_node_path_namespaceObject.join)((0, common_namespaceObject.getMidsceneRunSubDir)('report'), fileName, 'index.html');
+        return (0, external_node_path_namespaceObject.join)((0, common_namespaceObject.getMidsceneRunSubDir)('report'), `${fileName}.html`);
+    }
+    ensureOutputRoot() {
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, common_namespaceObject.getMidsceneRunSubDir)('report'), {
+            recursive: true
+        });
+    }
+    copyReport(reportFilePath, targetPath) {
+        if ((0, report_namespaceObject.isDirectoryModeReport)(reportFilePath)) {
+            const targetDir = (0, external_node_path_namespaceObject.dirname)(targetPath);
+            (0, external_node_fs_namespaceObject.mkdirSync)(targetDir, {
+                recursive: true
+            });
+            (0, external_node_fs_namespaceObject.cpSync)((0, external_node_path_namespaceObject.dirname)(reportFilePath), targetDir, {
+                recursive: true,
+                force: true
+            });
+            return;
+        }
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(targetPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.copyFileSync)(reportFilePath, targetPath);
+    }
+    collectReportInfo(test, result) {
+        const reportAnnotations = test.annotations.filter((annotation)=>'MIDSCENE_DUMP_ANNOTATION' === annotation.type && annotation.description);
+        if (0 === reportAnnotations.length || !this.mode) return;
+        const retry = result.retry ? `(retry #${result.retry})` : '';
+        const testId = `${test.id}${retry}`;
+        const projectName = this.hasMultipleProjects ? test.parent?.project()?.name : void 0;
+        const projectSuffix = projectName ? ` [${projectName}]` : '';
+        const testTitle = `${test.title}${projectSuffix}${retry}`;
+        const reports = reportAnnotations.map((annotation)=>annotation.description).filter((reportFilePath)=>{
+            if ((0, external_node_fs_namespaceObject.existsSync)(reportFilePath)) return true;
+            (0, utils_namespaceObject.logMsg)(`Failed to read Midscene report file: ${reportFilePath}`, new Error('Report file does not exist'));
+            return false;
+        }).map((reportFilePath)=>({
+                reportFilePath,
+                reportAttributes: {
+                    testDuration: result.duration,
+                    testStatus: result.status,
+                    testTitle,
+                    testId,
+                    testDescription: test.parent?.title || ''
+                }
+            }));
+        if (0 === reports.length) return;
+        this.reportsByTestId.set(testId, {
+            testTitle,
+            reports
+        });
+    }
+    finalizeMergedReport() {
+        this.ensureOutputRoot();
+        const tool = new report_namespaceObject.ReportMergingTool();
+        let reportCount = 0;
+        for (const entry of this.reportsByTestId.values())for (const report of entry.reports){
+            tool.append(report);
+            reportCount += 1;
+        }
+        if (0 === reportCount) return;
+        const targetName = this.getReportFilename();
+        if (1 === reportCount) {
+            const firstReport = Array.from(this.reportsByTestId.values())[0]?.reports[0];
+            if (!firstReport) return;
+            if (firstReport.reportFilePath) {
+                const targetPath = this.getReportPath();
+                this.copyReport(firstReport.reportFilePath, targetPath);
+                (0, agent_namespaceObject.printReportMsg)(targetPath);
+                return;
+            }
+            const mergedReportPath = tool.mergeReports(targetName, {
+                overwrite: true
+            });
+            if (mergedReportPath) (0, agent_namespaceObject.printReportMsg)(mergedReportPath);
+            return;
+        }
+        const mergedReportPath = tool.mergeReports(targetName, {
+            overwrite: true
+        });
+        if (mergedReportPath) (0, agent_namespaceObject.printReportMsg)(mergedReportPath);
+    }
+    finalizeSeparateReports() {
+        this.ensureOutputRoot();
+        for (const entry of this.reportsByTestId.values()){
+            const targetName = this.getReportFilename(entry.testTitle);
+            if (1 === entry.reports.length) {
+                const firstReport = entry.reports[0];
+                if (firstReport.reportFilePath) {
+                    const targetPath = this.getReportPath(entry.testTitle);
+                    this.copyReport(firstReport.reportFilePath, targetPath);
+                    (0, agent_namespaceObject.printReportMsg)(targetPath);
+                    continue;
+                }
+                const tool = new report_namespaceObject.ReportMergingTool();
+                tool.append(firstReport);
+                const reportPath = tool.mergeReports(targetName, {
+                    overwrite: true
+                });
+                if (reportPath) (0, agent_namespaceObject.printReportMsg)(reportPath);
+                continue;
+            }
+            const tool = new report_namespaceObject.ReportMergingTool();
+            for (const report of entry.reports)tool.append(report);
+            const reportPath = tool.mergeReports(targetName, {
+                overwrite: true
+            });
+            if (reportPath) (0, agent_namespaceObject.printReportMsg)(reportPath);
+        }
+    }
+    async onBegin(config, _suite) {
+        this.hasMultipleProjects = (config.projects?.length || 0) > 1;
+    }
+    onTestBegin(_test, _result) {}
+    onTestEnd(test, result) {
+        this.collectReportInfo(test, result);
+    }
+    async onEnd() {
+        if ('merged' === this.mode) return void this.finalizeMergedReport();
+        if ('separate' === this.mode) this.finalizeSeparateReports();
+    }
+    constructor(options = {}){
+        _define_property(this, "mergedFilename", void 0);
+        _define_property(this, "testTitleToFilename", new Map());
+        _define_property(this, "reportsByTestId", new Map());
+        _define_property(this, "mode", void 0);
+        _define_property(this, "outputFormat", void 0);
+        _define_property(this, "hasMultipleProjects", false);
+        this.mode = MidsceneReporter.getMode(options.type ?? 'merged');
+        this.outputFormat = options.outputFormat ?? 'single-html';
+    }
+}
+const reporter = MidsceneReporter;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/puppeteer/agent-launcher.js

@@ -0,0 +1,240 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    defaultViewportScale: ()=>defaultViewportScale,
+    launchPuppeteerPage: ()=>launchPuppeteerPage,
+    defaultUA: ()=>defaultUA,
+    buildChromeArgs: ()=>buildChromeArgs,
+    defaultViewportHeight: ()=>viewport_js_namespaceObject.defaultViewportHeight,
+    defaultWaitForNetworkIdleTimeout: ()=>defaultWaitForNetworkIdleTimeout,
+    resolveAiActionContext: ()=>resolveAiActionContext,
+    defaultViewportWidth: ()=>viewport_js_namespaceObject.defaultViewportWidth,
+    puppeteerAgentForTarget: ()=>puppeteerAgentForTarget
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const utils_namespaceObject = require("@godscene/shared/utils");
+const viewport_js_namespaceObject = require("../common/viewport.js");
+const external_index_js_namespaceObject = require("./index.js");
+const constants_namespaceObject = require("@godscene/shared/constants");
+const external_puppeteer_namespaceObject = require("puppeteer");
+var external_puppeteer_default = /*#__PURE__*/ __webpack_require__.n(external_puppeteer_namespaceObject);
+const defaultUA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36';
+const defaultViewportScale = 0;
+const defaultWaitForNetworkIdleTimeout = constants_namespaceObject.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT;
+function resolveAiActionContext(target, preference) {
+    const data = preference?.aiActContext ?? preference?.aiActionContext ?? target.aiActionContext;
+    return data;
+}
+const DANGEROUS_ARGS = [
+    '--no-sandbox',
+    '--disable-setuid-sandbox',
+    '--disable-web-security',
+    '--ignore-certificate-errors',
+    '--disable-features=IsolateOrigins',
+    '--disable-site-isolation-trials',
+    '--allow-running-insecure-content'
+];
+function validateChromeArgs(args, baseArgs) {
+    const newArgs = args.filter((arg)=>!baseArgs.some((baseArg)=>{
+            const argFlag = arg.split('=')[0];
+            const baseFlag = baseArg.split('=')[0];
+            return argFlag === baseFlag;
+        }));
+    const dangerousArgs = newArgs.filter((arg)=>DANGEROUS_ARGS.some((dangerous)=>arg.startsWith(dangerous)));
+    if (dangerousArgs.length > 0) console.warn(`Warning: Dangerous Chrome arguments detected: ${dangerousArgs.join(', ')}.\nThese arguments may reduce browser security. Use only in controlled testing environments.`);
+}
+const launcherDebug = (0, logger_namespaceObject.getDebug)('puppeteer:launcher');
+function buildChromeArgs(options) {
+    const isWindows = 'win32' === process.platform;
+    const sandboxArgs = isWindows ? [] : [
+        '--no-sandbox',
+        '--disable-setuid-sandbox'
+    ];
+    const featureArgs = [
+        '--disable-features=HttpsFirstBalancedModeAutoEnable',
+        '--disable-features=PasswordLeakDetection',
+        '--disable-save-password-bubble'
+    ];
+    const userAgentArg = options?.userAgent ? [
+        `--user-agent="${options.userAgent}"`
+    ] : [];
+    const windowSizeArg = options?.windowSize ? [
+        `--window-size=${options.windowSize.width},${options.windowSize.height}`
+    ] : [];
+    const baseArgs = [
+        ...sandboxArgs,
+        ...featureArgs,
+        ...userAgentArg,
+        ...windowSizeArg
+    ];
+    if (options?.chromeArgs?.length) {
+        validateChromeArgs(options.chromeArgs, baseArgs);
+        return [
+            ...baseArgs,
+            ...options.chromeArgs
+        ];
+    }
+    return baseArgs;
+}
+async function launchPuppeteerPage(target, preference, browser, existingPage) {
+    (0, utils_namespaceObject.assert)(target.url, 'url is required');
+    const freeFn = [];
+    const ua = target.userAgent || defaultUA;
+    const { width, height } = (0, viewport_js_namespaceObject.resolveWebViewportSize)(target);
+    let dpr = defaultViewportScale;
+    if (void 0 !== target.deviceScaleFactor && null !== target.deviceScaleFactor) {
+        (0, utils_namespaceObject.assert)('number' == typeof target.deviceScaleFactor, 'deviceScaleFactor must be a number');
+        dpr = target.deviceScaleFactor;
+        (0, utils_namespaceObject.assert)(dpr > 0, `deviceScaleFactor must be > 0, but got ${dpr}`);
+    }
+    const viewportConfig = {
+        width,
+        height,
+        deviceScaleFactor: dpr
+    };
+    const headed = preference?.headed || preference?.keepWindow;
+    const defaultViewportConfig = headed ? null : viewportConfig;
+    if (headed && '1' === process.env.CI) console.warn('you are probably running headed mode in CI, this will usually fail.');
+    const browserUIHeight = 100;
+    const args = buildChromeArgs({
+        userAgent: ua,
+        windowSize: headed ? {
+            width,
+            height: height + browserUIHeight
+        } : void 0,
+        chromeArgs: target.chromeArgs
+    });
+    launcherDebug('launching browser with viewport, headed', headed, 'viewport', viewportConfig, 'args', args, 'preference', preference);
+    let page;
+    let browserInstance = browser;
+    if (existingPage) {
+        page = existingPage;
+        launcherDebug('reusing existing page for shared browser context');
+        if (!browserInstance) browserInstance = page.browser();
+    } else {
+        if (!browserInstance) {
+            browserInstance = await external_puppeteer_default().launch({
+                headless: !preference?.headed,
+                defaultViewport: defaultViewportConfig,
+                args,
+                acceptInsecureCerts: target.acceptInsecureCerts,
+                ignoreDefaultArgs: preference?.ignoreDefaultArgs
+            });
+            freeFn.push({
+                name: 'puppeteer_browser',
+                fn: ()=>{
+                    if (!preference?.keepWindow) if ('win32' === process.platform) setTimeout(()=>{
+                        browserInstance?.close();
+                    }, 800);
+                    else browserInstance?.close();
+                }
+            });
+        }
+        page = await browserInstance.newPage();
+    }
+    if (target.cookie) {
+        const cookieFileContent = (0, external_node_fs_namespaceObject.readFileSync)(target.cookie, 'utf-8');
+        await browserInstance.setCookie(...JSON.parse(cookieFileContent));
+    }
+    if (ua) await page.setUserAgent(ua);
+    if (viewportConfig) await page.setViewport(viewportConfig);
+    const waitForNetworkIdleTimeout = 'number' == typeof target.waitForNetworkIdle?.timeout ? target.waitForNetworkIdle.timeout : defaultWaitForNetworkIdleTimeout;
+    try {
+        launcherDebug('goto', target.url);
+        await page.goto(target.url);
+        if (waitForNetworkIdleTimeout > 0) {
+            launcherDebug('waitForNetworkIdle', waitForNetworkIdleTimeout);
+            await page.waitForNetworkIdle({
+                timeout: waitForNetworkIdleTimeout
+            });
+        }
+    } catch (e) {
+        if ('boolean' == typeof target.waitForNetworkIdle?.continueOnNetworkIdleError && !target.waitForNetworkIdle?.continueOnNetworkIdleError) {
+            const newError = new Error(`failed to wait for network idle: ${e}`, {
+                cause: e
+            });
+            throw newError;
+        }
+        const newMessage = `failed to wait for network idle after ${waitForNetworkIdleTimeout}ms, but the script will continue.`;
+        console.warn(newMessage);
+    }
+    return {
+        page,
+        freeFn
+    };
+}
+async function puppeteerAgentForTarget(target, preference, browser, existingPage) {
+    const { page, freeFn } = await launchPuppeteerPage(target, preference, browser, existingPage);
+    const aiActContext = resolveAiActionContext(target, preference);
+    const { aiActionContext, ...preferenceToUse } = preference ?? {};
+    const agent = new external_index_js_namespaceObject.PuppeteerAgent(page, {
+        ...preferenceToUse,
+        aiActContext,
+        waitForNetworkIdleTimeout: 'number' == typeof target.waitForNetworkIdle?.timeout ? target.waitForNetworkIdle.timeout : void 0,
+        forceSameTabNavigation: void 0 !== target.forceSameTabNavigation ? target.forceSameTabNavigation : true
+    });
+    freeFn.push({
+        name: 'midscene_puppeteer_agent',
+        fn: ()=>agent.destroy()
+    });
+    return {
+        agent,
+        freeFn
+    };
+}
+exports.buildChromeArgs = __webpack_exports__.buildChromeArgs;
+exports.defaultUA = __webpack_exports__.defaultUA;
+exports.defaultViewportHeight = __webpack_exports__.defaultViewportHeight;
+exports.defaultViewportScale = __webpack_exports__.defaultViewportScale;
+exports.defaultViewportWidth = __webpack_exports__.defaultViewportWidth;
+exports.defaultWaitForNetworkIdleTimeout = __webpack_exports__.defaultWaitForNetworkIdleTimeout;
+exports.launchPuppeteerPage = __webpack_exports__.launchPuppeteerPage;
+exports.puppeteerAgentForTarget = __webpack_exports__.puppeteerAgentForTarget;
+exports.resolveAiActionContext = __webpack_exports__.resolveAiActionContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildChromeArgs",
+    "defaultUA",
+    "defaultViewportHeight",
+    "defaultViewportScale",
+    "defaultViewportWidth",
+    "defaultWaitForNetworkIdleTimeout",
+    "launchPuppeteerPage",
+    "puppeteerAgentForTarget",
+    "resolveAiActionContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});