ui5-test-runner 6.0.0-beta.5 → 6.0.0

package/README.md

@@ -1,4 +1,4 @@
-# UI5 Test runner 6️⃣ β
+# UI5 Test runner
 
 [![Node.js CI](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml/badge.svg)](https://github.com/ArnaudBuchholz/ui5-test-runner/actions/workflows/node.js.yml)
 [![Package Quality](https://npm.packagequality.com/shield/ui5-test-runner.svg)](https://packagequality.com/#?package=ui5-test-runner)
@@ -6,48 +6,39 @@
 [![ui5-test-runner](https://badge.fury.io/js/ui5-test-runner.svg)](https://www.npmjs.org/package/ui5-test-runner)
 [![PackagePhobia](https://img.shields.io/badge/%F0%9F%93%A6package-phobia-lightgrey)](https://packagephobia.com/result?p=ui5-test-runner)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield)
-[![Documentation](https://img.shields.io/badge/-%F0%9F%93%9Adocumentation-blueviolet)](https://arnaudbuchholz.github.io/ui5-test-runner/)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield&issueType=license)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_shield&issueType=security)
+[![Documentation](https://img.shields.io/badge/-%F0%9F%93%9Adocumentation-blueviolet)](https://github.com/ArnaudBuchholz/ui5-test-runner/tree/main/docs#-documentation)
 
-A self-sufficient test runner for UI5 applications enabling parallel execution of tests.
 
-> To put it in a nutshell, some UI5 applications have so many tests that when you run them in a browser, it ends up **crashing**. The main reason is **memory consumption** : the browser process goes up to 2 GB and it blows up. JavaScript is based on garbage collecting but it needs time to operate and the stress caused by executing the tests as well as the use of iframes do not let enough bandwidth for the browser to free up the memory.
+A self-sufficient test runner for [UI5 applications](https://ui5.sap.com/) enabling parallel execution of tests.
 
-> This tool is designed and built as a **substitute** of the [UI5 karma runner](https://github.com/SAP/karma-ui5). It executes all the tests in **parallel** thanks to several browser instances *(which also **reduces the total execution time**)*.
+> To put it in a nutshell, some [UI5 applications](https://ui5.sap.com/) have so many tests that when you run them in a browser, it ends up **crashing**. The main reason is **memory consumption** : the browser process goes up to 2 GB and it blows up. JavaScript is based on garbage collecting but it needs time to operate and the stress caused by executing the tests as well as the use of iframes do not let enough bandwidth for the browser to free up the memory.
 
-## 📚 [Documentation](https://arnaudbuchholz.github.io/ui5-test-runner/)
+> This tool is designed and built as a **substitute** of the [UI5 karma runner](https://github.com/SAP/karma-ui5). It executes all the tests in **parallel** thanks to several browser tabs *(which also **reduces the total execution time**)*.
 
 ## 💿 How to install
 
-* Works with [Node.js](https://nodejs.org/en/download/) >= 24
+* Works with [Node.js](https://nodejs.org/en/download/) >= 24.11.1
 * Local installation
-  * `npm install --save-dev ui5-test-runner`
+  * `npm install --save-dev ui5-test-runner@6`
   * Trigger either with `npx ui5-test-runner` or through an npm script invoking `ui5-test-runner`
 * Global installation
-  * `npm install --global ui5-test-runner`
+  * `npm install --global ui5-test-runner@6`
   * Trigger with `ui5-test-runner`
 
-**NOTE** : additional packages might be needed during the execution (`puppeteer`, `selenium-webdriver`, `nyc`...) . If they are found installed **locally** in the tested project, they are used. Otherwise, they are installed **globally**.
+**NOTE** : additional packages might be needed during the execution (`puppeteer`, `selenium-webdriver`, `nyc`...) . If they are found installed **locally** in the tested project, they are used. Otherwise, they are installed **on demand**.
 
-## ⚖️ License
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FArnaudBuchholz%2Fui5-test-runner?ref=badge_large)
+## 🤖 AI-powered documentation
 
-## ⚠️ Breaking changes
+Use `npx ui5-test-runner@6 --mcp` to start an MCP server exposing the latest indexed documentation to your AI client.
 
-| Version | Reason | 
-|-|-|
-| **6**.0.0 | • Drop support of Node.js < 24 |
-| **5**.0.0 | • Some coverage reports now includes **all** files, leading to a potential decrease of coverage |
-| **4**.0.0 | • Drop support of Node.js 16 |
-| **3**.0.0 | • Drop support of Node.js 14 |
-| **2**.0.0 | • Command line **parameters** as well as configuration file **syntax** have changed |
-|| • Dependencies are installed **on demand** |
-|| • Browser instantiation command evolved in an **incompatible way** (see [documentation](https://arnaudbuchholz.github.io/ui5-test-runner/browser.html)) |
-|| • Output is different (report, traces) |
+## 🧭 Links
+
+* 📚 [Documentation](https://github.com/ArnaudBuchholz/ui5-test-runner/tree/main/docs#-documentation)
+
+* ⚠️ [Breaking changes](https://github.com/ArnaudBuchholz/ui5-test-runner/blob/main/docs/v6_breaking_changes.md)
+
+* ✒ [Contributors](https://github.com/ArnaudBuchholz/ui5-test-runner/graphs/contributors?all=1)
 
-## ✒ Contributors
 
-* [Marian Zeis](https://github.com/marianfoo): Documentation page revamp [PR #54](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/54)
-* [Raj Singh](https://github.com/rajxsingh): Basic HTTP Authentication in Puppeteer [PR #71](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/71)
-* [Andreas Kunz](https://github.com/akudev): Improved documentation for TypeScript testing and reviewed `nyc` settings handling [PR #110](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/110)
-* [Juri Zeisler](https://github.com/juriz889): Added screenshots to the JUnit XML Report [PR #158](https://github.com/ArnaudBuchholz/ui5-test-runner/pull/158)

package/dist/Command.js

@@ -0,0 +1,52 @@
+import { assert } from './platform/index.js';
+import { Npm } from './Npm.js';
+const QUOTED_AND_UNQUOTED_TOKENS = /"[^"]*"|'[^']*'|[^ ]+/g;
+export const Command = {
+    split(command) {
+        return command
+            .matchAll(QUOTED_AND_UNQUOTED_TOKENS)
+            .map(([value]) => {
+            return (value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))
+                ? value.slice(1, -1)
+                : value;
+        })
+            .toArray();
+    },
+    substitute(configuration, value, extras = {}) {
+        return value.replaceAll(/\{\{(\w+)\}\}/g, (_, optionName) => {
+            if (optionName in extras) {
+                return extras[optionName];
+            }
+            assert(optionName in configuration, `Invalid command line substitution parameter: ${optionName}`);
+            return configuration[optionName]?.toString() ?? '';
+        });
+    },
+    async parse(configuration, command, extras = {}) {
+        let executable = 'node';
+        const tokens = Command.split(command);
+        const environment = {};
+        while (tokens.length > 0 && /^\w+=/.test(tokens[0])) {
+            const [key, ...rest] = tokens.shift().split('=');
+            environment[key] = Command.substitute(configuration, rest.join('='), extras);
+        }
+        const [commandSpecifier, ...parameters] = tokens;
+        assert(!!commandSpecifier);
+        if (commandSpecifier === 'npm') {
+            parameters.unshift(await Npm.getCliPath());
+        }
+        else if (commandSpecifier !== 'node') {
+            const scripts = await Npm.listPackageScriptNames(configuration.cwd);
+            if (scripts.includes(commandSpecifier)) {
+                parameters.unshift(await Npm.getCliPath(), 'run', commandSpecifier);
+            }
+            else {
+                executable = commandSpecifier;
+            }
+        }
+        return [
+            executable,
+            parameters.map((parameter) => Command.substitute(configuration, parameter, extras)),
+            environment
+        ];
+    }
+};

package/dist/Npm.js

@@ -1,21 +1,14 @@
-import { logger, FileSystem, Http, Module, Path, Process, Url } from './platform/index.js';
+import { assert, logger, FileSystem, Http, Module, Path, Process, Url } from './platform/index.js';
 import { memoize } from './utils/shared/memoize.js';
 export const getNpmCliPath = async () => {
     const npmChildProcess = Process.spawn('npm', [], {
         shell: true
     });
     await npmChildProcess.closed;
-    const error = new Error('Unable to initialize NPM');
     const match = /^npm@([^ ]+) (.*)$/gm.exec(npmChildProcess.stdout);
-    if (!match) {
-        logger.fatal({ source: 'npm', message: 'Unable to match NPM output', error });
-        throw error;
-    }
+    assert(match !== null, 'unable to match NPM output');
     const [, semver, path] = match;
-    if (!semver || !path) {
-        logger.fatal({ source: 'npm', message: 'Failed to parse NPM output', error, data: { semver, path } });
-        throw error;
-    }
+    assert(!!semver && !!path, 'failed to parse NPM output');
     logger.debug({ source: 'npm', message: `npm@${semver} ${path}` });
     return Path.join(path, 'bin/npm-cli.js');
 };
@@ -26,76 +19,87 @@ const npm = async (...arguments_) => {
         detached: true
     });
 };
+const validateRoot = async (proc, label) => {
+    if (proc.code !== 0) {
+        logger.fatal({ source: 'npm', message: `npm root ${label} failed with code ${proc.code}` });
+    }
+    const value = proc.stdout.trim();
+    if (value === '' || !Path.isAbsolute(value)) {
+        logger.fatal({ source: 'npm', message: `npm root ${label} returned an invalid path: "${value}"` });
+    }
+    try {
+        await FileSystem.access(value, FileSystem.constants.R_OK);
+    }
+    catch {
+        logger.fatal({ source: 'npm', message: `npm root ${label} directory is not accessible: "${value}"` });
+    }
+    return value;
+};
 const getRoots = memoize(async () => {
     const localRootProcess = await npm('root');
     const globalRootProcess = await npm('root', '--global');
     await Promise.all([localRootProcess.closed, globalRootProcess.closed]);
-    const local = localRootProcess.stdout.trim();
-    const global = globalRootProcess.stdout.trim();
-    logger.debug({ source: 'npm', message: 'Roots', data: { local, global } });
-    return {
-        local: localRootProcess.stdout.trim(),
-        global: globalRootProcess.stdout.trim()
-    };
+    const local = await validateRoot(localRootProcess, '(local)');
+    const global = await validateRoot(globalRootProcess, '(global)');
+    logger.debug({ source: 'npm', message: 'roots', data: { local, global } });
+    return { local, global };
 });
-const buildInstallPlan = (strategy, moduleName, globalRoot, prefix) => {
+const buildInstallPlan = (strategy, moduleName, options) => {
+    const { globalRoot, prefix, allowScripts, minReleaseAge } = options;
+    const noScripts = allowScripts ? [] : ['--ignore-scripts'];
+    const releaseAge = minReleaseAge > 0 ? [`--min-release-age=${minReleaseAge}`] : [];
+    const extraFlags = [...noScripts, ...releaseAge];
     if (strategy === 'global') {
-        return { installArguments: ['install', '-g', moduleName], reimportPath: globalRoot };
+        return { installArguments: ['install', '-g', ...extraFlags, moduleName], reimportPath: globalRoot };
     }
-    if (strategy === 'prefix') {
-        return {
-            installArguments: ['install', '--prefix', prefix, '--no-save', moduleName],
+    return strategy === 'prefix'
+        ? {
+            installArguments: ['install', '--prefix', prefix, '--no-save', ...extraFlags, moduleName],
             reimportPath: Path.join(prefix, 'node_modules')
-        };
-    }
-    return { installArguments: ['install', '--no-save', moduleName], reimportPath: undefined };
+        }
+        : { installArguments: ['install', '--no-save', ...extraFlags, moduleName], reimportPath: undefined };
 };
 export class Npm {
     static dynamicImport(specifier) {
         return import(specifier);
     }
-    static async tryImportFromPath(configuration, moduleName, nodeModulesPath) {
+    static tryResolvePackageDir(moduleName, nodeModulesPath) {
         try {
-            const require = Module.createRequire(Url.pathToFileURL(Path.join(configuration.cwd, 'package.json')).href);
-            const resolved = require.resolve(moduleName, { paths: [nodeModulesPath] });
-            return await this.dynamicImport(Url.pathToFileURL(resolved).href);
+            const packageJsonPath = Module.findPackageJSON(moduleName, `${nodeModulesPath}/`);
+            return packageJsonPath === undefined ? undefined : Path.dirname(packageJsonPath);
         }
         catch {
             return undefined;
         }
     }
-    static async getLatestVersion(moduleName) {
+    static async tryImportFromPath(configuration, moduleName, nodeModulesPath) {
         try {
-            const response = await Http.get(`https://registry.npmjs.org/${moduleName}/latest`);
-            const { version } = JSON.parse(response);
-            return version;
+            const require = Module.createRequire(`${Url.pathToFileURL(configuration.cwd).href}/`);
+            const resolved = require.resolve(moduleName, { paths: [nodeModulesPath] });
+            return await this.dynamicImport(Url.pathToFileURL(resolved).href);
         }
-        catch (error) {
-            throw new Error(`Unable to fetch latest version of ${moduleName} from NPM registry`, {
-                cause: error
-            });
+        catch {
+            return undefined;
         }
     }
-    static async checkIfLatestVersion(moduleName, isLocal) {
-        try {
-            const { local, global } = await getRoots();
-            const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(isLocal ? local : global, moduleName, 'package.json'), 'utf8'));
-            logger.info({ source: 'npm', message: `Installed version of ${moduleName} is ${installedVersion}` });
-            const latestVersion = await Npm.getLatestVersion(moduleName);
-            if (latestVersion !== installedVersion) {
-                logger.warn({ source: 'npm', message: `[PKGVRS] Latest version of ${moduleName} is ${latestVersion}` });
+    static async tryImportFromRoots(configuration, moduleName, roots) {
+        for (const { path, label, checkVersion } of roots) {
+            const result = await this.tryImportFromPath(configuration, moduleName, path);
+            if (result !== undefined) {
+                logger.debug({ source: 'npm', message: `Module ${moduleName} ${label}` });
+                if (checkVersion)
+                    void this.checkIfLatestVersion(configuration, moduleName);
+                return result;
             }
         }
-        catch (error) {
-            logger.error({ source: 'npm', message: 'Failed in checkIfLatestVersion', error });
-        }
+        return undefined;
     }
     static async import(configuration, moduleName) {
-        logger.debug({ source: 'npm', message: `Npm.import(${moduleName})` });
+        logger.debug({ source: 'npm', message: `Importing module: ${moduleName}` });
         try {
             const module = await this.dynamicImport(moduleName);
             logger.debug({ source: 'npm', message: `Module ${moduleName} found locally` });
-            void Npm.checkIfLatestVersion(moduleName, true);
+            void this.checkIfLatestVersion(configuration, moduleName);
             return module;
         }
         catch (error) {
@@ -103,37 +107,38 @@ export class Npm {
             if (code !== 'ERR_MODULE_NOT_FOUND' && code !== 'MODULE_NOT_FOUND') {
                 throw error;
             }
-            logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
-        }
-        const { global: globalRoot } = await getRoots();
-        const fromGlobal = await this.tryImportFromPath(configuration, moduleName, globalRoot);
-        if (fromGlobal !== undefined) {
-            logger.debug({ source: 'npm', message: `Module ${moduleName} found globally` });
-            void Npm.checkIfLatestVersion(moduleName, false);
-            return fromGlobal;
-        }
-        if (configuration.alternateNpmPath) {
-            const fromAlternate = await this.tryImportFromPath(configuration, moduleName, configuration.alternateNpmPath);
-            if (fromAlternate !== undefined) {
-                logger.debug({ source: 'npm', message: `Module ${moduleName} found in alternateNpmPath` });
-                return fromAlternate;
-            }
-        }
-        if (configuration.npmInstallPrefix) {
-            const fromPrefix = await this.tryImportFromPath(configuration, moduleName, Path.join(configuration.npmInstallPrefix, 'node_modules'));
-            if (fromPrefix !== undefined) {
-                logger.debug({ source: 'npm', message: `Module ${moduleName} found in npmInstallPrefix` });
-                return fromPrefix;
+            if (moduleName === this.packageNameOf(moduleName)) {
+                logger.warn({ source: 'npm', message: `Module ${moduleName} not found locally` });
             }
         }
+        const { local: localRoot, global: globalRoot } = await getRoots();
+        const extraRoots = [
+            ...(configuration.alternateNpmPath
+                ? [{ path: configuration.alternateNpmPath, label: 'found in alternateNpmPath' }]
+                : []),
+            ...(configuration.npmInstallPrefix
+                ? [{ path: Path.join(configuration.npmInstallPrefix, 'node_modules'), label: 'found in npmInstallPrefix' }]
+                : [])
+        ];
+        const found = await this.tryImportFromRoots(configuration, moduleName, [
+            { path: localRoot, label: 'found in local node_modules', checkVersion: true },
+            { path: globalRoot, label: 'found globally', checkVersion: true },
+            ...extraRoots
+        ]);
+        if (found !== undefined)
+            return found;
         if (configuration.noNpmInstall) {
             const message = `Module ${moduleName} not found and noNpmInstall is set`;
             logger.fatal({ source: 'npm', message });
-            throw new Error(message);
         }
         const strategy = configuration.npmInstall;
         logger.info({ source: 'npm', message: `Installing ${moduleName} (strategy: ${strategy})` });
-        const { installArguments, reimportPath } = buildInstallPlan(strategy, moduleName, globalRoot, configuration.npmInstallPrefix ?? '');
+        const { installArguments, reimportPath } = buildInstallPlan(strategy, moduleName, {
+            globalRoot,
+            prefix: configuration.npmInstallPrefix ?? '',
+            allowScripts: !!configuration.npmAllowInstallScripts,
+            minReleaseAge: configuration.npmInstallMinReleaseAge
+        });
         const installProcess = await npm(...installArguments);
         await installProcess.closed;
         if (reimportPath !== undefined) {
@@ -141,10 +146,85 @@ export class Npm {
             if (result === undefined) {
                 const message = `Module ${moduleName} could not be loaded after install`;
                 logger.fatal({ source: 'npm', message });
-                throw new Error(message);
             }
             return result;
         }
         return await this.dynamicImport(moduleName);
     }
+    static async resolvePackageDir(configuration, moduleName) {
+        const { local, global: globalRoot } = await getRoots();
+        const fromLocal = this.tryResolvePackageDir(moduleName, local);
+        if (fromLocal)
+            return fromLocal;
+        const fromGlobal = this.tryResolvePackageDir(moduleName, globalRoot);
+        if (fromGlobal)
+            return fromGlobal;
+        if (configuration.alternateNpmPath) {
+            const fromAlternate = this.tryResolvePackageDir(moduleName, configuration.alternateNpmPath);
+            if (fromAlternate)
+                return fromAlternate;
+        }
+        if (configuration.npmInstallPrefix) {
+            const fromPrefix = this.tryResolvePackageDir(moduleName, Path.join(configuration.npmInstallPrefix, 'node_modules'));
+            if (fromPrefix)
+                return fromPrefix;
+        }
+        throw new Error(`Cannot locate package directory for ${moduleName}`);
+    }
+    static packageNameOf(moduleName) {
+        if (moduleName.startsWith('@')) {
+            const [scope, package_] = moduleName.split('/', 2);
+            return `${scope}/${package_}`;
+        }
+        return moduleName.split('/', 1)[0];
+    }
+    static async getLatestVersion(packageName) {
+        try {
+            const response = await Http.getAsText(`https://registry.npmjs.org/${packageName}/latest`);
+            const { version } = JSON.parse(response);
+            return version;
+        }
+        catch (error) {
+            throw new Error(`Unable to fetch latest version of ${packageName} from NPM registry`, {
+                cause: error
+            });
+        }
+    }
+    static _checkedPackages = new Set();
+    static async checkIfLatestVersion(configuration, moduleName) {
+        const packageName = this.packageNameOf(moduleName);
+        if (this._checkedPackages.has(packageName)) {
+            return;
+        }
+        this._checkedPackages.add(packageName);
+        try {
+            const packageDirectory = await this.resolvePackageDir(configuration, packageName);
+            const { version: installedVersion } = JSON.parse(await FileSystem.readFile(Path.join(packageDirectory, 'package.json'), 'utf8'));
+            logger.info({ source: 'npm', message: `Installed version of ${packageName} is ${installedVersion}` });
+            const latestVersion = await this.getLatestVersion(packageName);
+            if (latestVersion !== installedVersion) {
+                logger.warn({ source: 'npm', message: `Latest version of ${packageName} is ${latestVersion}` });
+            }
+        }
+        catch (error) {
+            logger.error({ source: 'npm', message: 'failed in checkIfLatestVersion', error });
+        }
+    }
+    static async getCliPath() {
+        return await memoizedNpmCliPath();
+    }
+    static async listPackageScriptNames(cwd) {
+        try {
+            const packageJsonPath = Module.findPackageJSON(`${Url.pathToFileURL(cwd).href}/`);
+            if (!packageJsonPath) {
+                return [];
+            }
+            const content = JSON.parse(await FileSystem.readFile(packageJsonPath, 'utf8'));
+            return Object.keys(content?.scripts ?? {});
+        }
+        catch (error) {
+            logger.error({ source: 'npm', message: 'failed to list package script names', error, data: { cwd } });
+            return [];
+        }
+    }
 }

package/dist/browsers/RecoverableBrowserError.js

@@ -0,0 +1,6 @@
+export class RecoverableBrowserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RecoverableBrowserError';
+    }
+}

package/dist/browsers/chromeArguments.js

@@ -0,0 +1,5 @@
+import { Host } from '../platform/index.js';
+export const getExtraChromeArguments = () => {
+    const raw = Host.env['UI5TR_CHROME_ARGS'];
+    return raw === undefined ? [] : raw.split(/\s+/).filter((argument) => argument.length > 0);
+};

package/dist/browsers/chromeOptions.js

@@ -0,0 +1,29 @@
+import { getExtraChromeArguments } from './chromeArguments.js';
+export const DEFAULT_CHROME_ARGS = [
+    '--disable-background-timer-throttling',
+    '--disable-backgrounding-occluded-windows',
+    '--disable-renderer-backgrounding'
+];
+export const buildChromeLaunchOptions = (options, extraArguments = [], shouldIncludeEnvironmentArguments = true) => {
+    const rawArguments = options?.['args'];
+    const userArguments = Array.isArray(rawArguments)
+        ? rawArguments.filter((a) => typeof a === 'string')
+        : [];
+    const rawIgnoreDefaultArguments = options?.['ignoreDefaultArgs'];
+    let ignoreDefaultArguments;
+    if (rawIgnoreDefaultArguments === true) {
+        ignoreDefaultArguments = true;
+    }
+    else if (Array.isArray(rawIgnoreDefaultArguments)) {
+        ignoreDefaultArguments = rawIgnoreDefaultArguments.filter((argument) => typeof argument === 'string');
+    }
+    return {
+        args: [
+            ...DEFAULT_CHROME_ARGS,
+            ...extraArguments,
+            ...userArguments,
+            ...(shouldIncludeEnvironmentArguments ? getExtraChromeArguments() : [])
+        ],
+        ...(ignoreDefaultArguments !== undefined && { ignoreDefaultArgs: ignoreDefaultArguments })
+    };
+};

package/dist/browsers/consoleMessage.js

@@ -0,0 +1,23 @@
+import { logger } from '../platform/index.js';
+import { agentLogPrefix } from '../types/AgentState.js';
+const LOG_TYPES = {
+    error: 'error',
+    warn: 'warn',
+    assert: 'warn',
+    debug: 'debug'
+};
+export const handleConsoleMessage = (type, text, pageId) => {
+    const normalizedType = type === 'warning' ? 'warn' : type;
+    const logType = LOG_TYPES[normalizedType] ?? 'info';
+    let source;
+    let message;
+    if (text.startsWith(agentLogPrefix)) {
+        source = 'browser/agent';
+        message = text.slice(agentLogPrefix.length);
+    }
+    else {
+        source = 'browser/console';
+        message = text;
+    }
+    logger[logType]({ source, message, pageId, data: { type: normalizedType } });
+};