@godscene/web 1.7.11

package/dist/es/playwright/reporter/index.mjs

@@ -0,0 +1,178 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getReportFileName, printReportMsg } from "@godscene/core/agent";
+import { ReportMergingTool, isDirectoryModeReport } from "@godscene/core/report";
+import { getMidsceneRunSubDir } from "@godscene/shared/common";
+import { logMsg, replaceIllegalPathCharsAndSpace } from "@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-${replaceIllegalPathCharsAndSpace(testTitle)}`;
+            const generatedFilename = getReportFileName(baseTag);
+            this.testTitleToFilename.set(testTitle, generatedFilename);
+        }
+        return this.testTitleToFilename.get(testTitle);
+    }
+    getReportFilename(testTitle) {
+        if ('merged' === this.mode) {
+            if (!this.mergedFilename) this.mergedFilename = 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 join(getMidsceneRunSubDir('report'), fileName, 'index.html');
+        return join(getMidsceneRunSubDir('report'), `${fileName}.html`);
+    }
+    ensureOutputRoot() {
+        mkdirSync(getMidsceneRunSubDir('report'), {
+            recursive: true
+        });
+    }
+    copyReport(reportFilePath, targetPath) {
+        if (isDirectoryModeReport(reportFilePath)) {
+            const targetDir = dirname(targetPath);
+            mkdirSync(targetDir, {
+                recursive: true
+            });
+            cpSync(dirname(reportFilePath), targetDir, {
+                recursive: true,
+                force: true
+            });
+            return;
+        }
+        mkdirSync(dirname(targetPath), {
+            recursive: true
+        });
+        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 (existsSync(reportFilePath)) return true;
+            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 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);
+                printReportMsg(targetPath);
+                return;
+            }
+            const mergedReportPath = tool.mergeReports(targetName, {
+                overwrite: true
+            });
+            if (mergedReportPath) printReportMsg(mergedReportPath);
+            return;
+        }
+        const mergedReportPath = tool.mergeReports(targetName, {
+            overwrite: true
+        });
+        if (mergedReportPath) 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);
+                    printReportMsg(targetPath);
+                    continue;
+                }
+                const tool = new ReportMergingTool();
+                tool.append(firstReport);
+                const reportPath = tool.mergeReports(targetName, {
+                    overwrite: true
+                });
+                if (reportPath) printReportMsg(reportPath);
+                continue;
+            }
+            const tool = new ReportMergingTool();
+            for (const report of entry.reports)tool.append(report);
+            const reportPath = tool.mergeReports(targetName, {
+                overwrite: true
+            });
+            if (reportPath) 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;
+export { reporter as default };

package/dist/es/puppeteer/agent-launcher.mjs

@@ -0,0 +1,172 @@
+import { readFileSync } from "node:fs";
+import { getDebug } from "@godscene/shared/logger";
+import { assert } from "@godscene/shared/utils";
+import { defaultViewportHeight, defaultViewportWidth, resolveWebViewportSize } from "../common/viewport.mjs";
+import { PuppeteerAgent } from "./index.mjs";
+import { DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT } from "@godscene/shared/constants";
+import puppeteer from "puppeteer";
+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 = 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 = 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) {
+    assert(target.url, 'url is required');
+    const freeFn = [];
+    const ua = target.userAgent || defaultUA;
+    const { width, height } = resolveWebViewportSize(target);
+    let dpr = defaultViewportScale;
+    if (void 0 !== target.deviceScaleFactor && null !== target.deviceScaleFactor) {
+        assert('number' == typeof target.deviceScaleFactor, 'deviceScaleFactor must be a number');
+        dpr = target.deviceScaleFactor;
+        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 puppeteer.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 = 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 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
+    };
+}
+export { buildChromeArgs, defaultUA, defaultViewportHeight, defaultViewportScale, defaultViewportWidth, defaultWaitForNetworkIdleTimeout, launchPuppeteerPage, puppeteerAgentForTarget, resolveAiActionContext };