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

package/dist/modes/mcp/index.js

@@ -0,0 +1,49 @@
+import { Exit, FileSystem, logger } from '../../platform/index.js';
+import { serve } from 'reserve';
+import { buildREserveConfiguration } from './reserve.js';
+import { init, reindex, DOCS_DIR } from './knowledgeBase.js';
+import { logReserve } from '../../reserveLogger.js';
+import { Folder } from '../../utils/node/Folder.js';
+export const mcp = async (configuration) => {
+    await Folder.create(configuration.reportDir);
+    await logger.start(configuration);
+    await init(configuration);
+    if (configuration.debugMcpLocalDocs && configuration.watch) {
+        let debounce;
+        const watcher = FileSystem.watch(DOCS_DIR, { recursive: true });
+        watcher.on('change', () => {
+            clearTimeout(debounce);
+            debounce = setTimeout(() => {
+                void reindex(configuration).then(() => logger.info({ source: 'mcp', message: 'knowledge base reindexed' }));
+            }, 300);
+        });
+        Exit.registerAsyncTask({
+            name: 'mcp-watcher',
+            stop: () => {
+                clearTimeout(debounce);
+                watcher.close();
+                return Promise.resolve();
+            }
+        });
+    }
+    const { promise, resolve } = Promise.withResolvers();
+    const server = serve(buildREserveConfiguration(configuration));
+    const stop = async () => {
+        await server?.close();
+        resolve();
+    };
+    Exit.registerAsyncTask({
+        name: 'mcp',
+        stop
+    });
+    logReserve(server);
+    server.on('ready', ({ url }) => {
+        logger.info({ source: 'mcp', message: 'connect your MCP client to ' + new URL('/mcp', url).href });
+        logger.info({ source: 'mcp', message: 'use CTRL+C to end' });
+    });
+    server.on('error', ({ reason: error }) => {
+        logger.error({ source: 'mcp', message: 'server error', error });
+        void stop();
+    });
+    await promise;
+};

package/dist/modes/mcp/knowledgeBase.js

@@ -0,0 +1,104 @@
+import { Crypto, FileSystem, Path, __sourcesRoot, assert, logger } from '../../platform/index.js';
+import { parseFrontmatter } from './frontmatter.js';
+import { collectRemoteDocuments } from './remoteKnowledgeBase.js';
+import { isExcludedPath } from './IDocument.js';
+export const DOCS_DIR = Path.join(__sourcesRoot, '../docs');
+const ENTITY_TYPES = new Set(['option', 'mode', 'concept', 'task']);
+const ID_RELATIONS = ['see-also', 'affects', 'requires', 'supersedes'];
+const SHA_LENGTH = 16;
+export const deriveId = (documentationRelativePath) => {
+    const withoutExtension = documentationRelativePath.replaceAll('\\', '/').replace(/\.md$/, '');
+    return withoutExtension.replace(/\/index$/, '');
+};
+const toCatalogEntry = (entity) => ({
+    id: entity.id,
+    '#type': entity['#type'],
+    title: entity.title,
+    summary: entity.summary,
+    relations: entity.relations
+});
+const parseDocumentToEntity = ({ path, content }) => {
+    const { frontmatter, body } = parseFrontmatter(content);
+    if (frontmatter === null || frontmatter['#type'] === undefined) {
+        return null;
+    }
+    const type = frontmatter['#type'];
+    if (!ENTITY_TYPES.has(type)) {
+        logger.debug({ source: 'mcp', message: `skipping ${path}: invalid #type '${type}'` });
+        return null;
+    }
+    if (frontmatter.title === undefined || frontmatter.summary === undefined) {
+        logger.debug({ source: 'mcp', message: `skipping ${path}: missing title or summary` });
+        return null;
+    }
+    return {
+        id: frontmatter.id ?? deriveId(path),
+        '#type': type,
+        title: frontmatter.title,
+        summary: frontmatter.summary,
+        keywords: frontmatter.keywords ?? [],
+        relations: frontmatter.relations ?? {},
+        sha: Crypto.sha256hex(content).slice(0, SHA_LENGTH),
+        path,
+        body
+    };
+};
+const buildReverseIndex = (entities) => {
+    const reverse = new Map();
+    for (const entity of entities) {
+        for (const relation of ID_RELATIONS) {
+            const targets = entity.relations[relation] ?? [];
+            for (const target of targets) {
+                const existing = reverse.get(target) ?? [];
+                existing.push({ id: entity.id, relation });
+                reverse.set(target, existing);
+            }
+        }
+    }
+    return reverse;
+};
+export const buildKnowledgeBaseIndex = (documents) => {
+    const byId = new Map();
+    for (const document of documents) {
+        const entity = parseDocumentToEntity(document);
+        if (entity === null) {
+            continue;
+        }
+        if (byId.has(entity.id)) {
+            logger.debug({ source: 'mcp', message: `skipping ${entity.path}: duplicate id '${entity.id}'` });
+            continue;
+        }
+        byId.set(entity.id, entity);
+    }
+    const entities = byId.values().toArray();
+    const reverse = buildReverseIndex(entities);
+    const catalog = entities
+        .map((entity) => toCatalogEntry(entity))
+        .toSorted((left, right) => left.id.localeCompare(right.id));
+    return {
+        catalog,
+        getEntity: (id) => byId.get(id),
+        getReverseRelations: (id) => reverse.get(id) ?? []
+    };
+};
+let _index;
+const collectLocalDocuments = async () => {
+    const entries = await FileSystem.readdir(DOCS_DIR, { recursive: true, withFileTypes: true });
+    const markdown = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.md'));
+    const documents = await Promise.all(markdown.map(async (entry) => {
+        const path = Path.relative(DOCS_DIR, Path.join(entry.parentPath, entry.name));
+        return { path, content: await FileSystem.readFile(Path.join(DOCS_DIR, path), 'utf8') };
+    }));
+    return documents.filter((document) => !isExcludedPath(document.path));
+};
+const collectDocuments = (configuration) => configuration.debugMcpLocalDocs ? collectLocalDocuments() : collectRemoteDocuments();
+export const reindex = async (configuration) => {
+    _index = buildKnowledgeBaseIndex(await collectDocuments(configuration));
+};
+export const init = async (configuration) => {
+    await reindex(configuration);
+};
+export const getIndex = () => {
+    assert(_index !== undefined, 'knowledge base not initialized');
+    return _index;
+};

package/dist/modes/mcp/remoteKnowledgeBase.js

@@ -0,0 +1,79 @@
+import { FileSystem, Host, Http, Path, logger } from '../../platform/index.js';
+import { isExcludedPath } from './IDocument.js';
+const REPO = 'ArnaudBuchholz/ui5-test-runner';
+const BRANCH = 'main';
+const DOCS_PATH = 'docs';
+const RAW_BASE = `https://raw.githubusercontent.com/${REPO}/${BRANCH}`;
+const API_BASE = `https://api.github.com/repos/${REPO}`;
+const CACHE_FILE_NAME = 'ui5-test-runner-mcp-kb-cache.json';
+const CACHE_FILE_PATH = Path.join(Host.tmpdir(), CACHE_FILE_NAME);
+const ONE_HOUR_MS = 60 * 60 * 1000;
+const loadCache = async () => {
+    try {
+        const raw = await FileSystem.readFile(CACHE_FILE_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+const saveCache = (cache) => {
+    FileSystem.writeFileSync(CACHE_FILE_PATH, JSON.stringify(cache));
+};
+const fetchTreeSha = async () => {
+    const url = `${API_BASE}/git/trees/${BRANCH}?recursive=1`;
+    const text = await Http.getAsText(url);
+    const tree = JSON.parse(text);
+    const entries = tree.tree
+        .filter((entry) => entry.type === 'blob' &&
+        entry.path.startsWith(`${DOCS_PATH}/`) &&
+        entry.path.endsWith('.md') &&
+        !isExcludedPath(entry.path.slice(DOCS_PATH.length + 1)))
+        .map((entry) => ({ path: entry.path.slice(DOCS_PATH.length + 1), sha: entry.sha }));
+    return { treeSha: tree.sha, entries };
+};
+const fetchFileContent = async (relativePath) => Http.getAsText(`${RAW_BASE}/${DOCS_PATH}/${relativePath}`);
+const buildDocuments = (contents) => Object.entries(contents).map(([path, content]) => ({ path, content }));
+export const collectRemoteDocuments = async () => {
+    logger.info({ source: 'mcp', message: `cache path: ${CACHE_FILE_PATH}` });
+    const cache = await loadCache();
+    const now = Date.now();
+    if (cache !== null && now - cache.checkedAt < ONE_HOUR_MS) {
+        logger.info({ source: 'mcp', message: 'using cached remote KB (within 1-hour window)' });
+        return buildDocuments(cache.contents);
+    }
+    logger.debug({ source: 'mcp', message: 'checking remote tree SHA' });
+    let treeResult;
+    try {
+        treeResult = await fetchTreeSha();
+    }
+    catch (error) {
+        if (cache !== null) {
+            logger.warn({ source: 'mcp', message: 'could not reach GitHub, using cached KB', error });
+            return buildDocuments(cache.contents);
+        }
+        throw new Error('Failed to fetch knowledge base from GitHub and no local cache is available', { cause: error });
+    }
+    const { treeSha, entries } = treeResult;
+    if (cache !== null && treeSha === cache.treeSha) {
+        logger.info({ source: 'mcp', message: 'remote tree SHA unchanged' });
+        saveCache({ ...cache, checkedAt: now });
+        return buildDocuments(cache.contents);
+    }
+    logger.info({ source: 'mcp', message: 'remote tree SHA changed, fetching updates' });
+    const previousContents = cache?.contents ?? {};
+    const previousFiles = cache?.files ?? {};
+    const newFiles = {};
+    const newContents = {};
+    for (const entry of entries) {
+        newFiles[entry.path] = entry.sha;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        newContents[entry.path] =
+            previousFiles[entry.path] === entry.sha && previousContents[entry.path] !== undefined
+                ? previousContents[entry.path]
+                : await fetchFileContent(entry.path);
+    }));
+    saveCache({ treeSha, checkedAt: now, files: newFiles, contents: newContents });
+    return buildDocuments(newContents);
+};

package/dist/modes/mcp/reserve.js

@@ -0,0 +1,175 @@
+import { body } from 'reserve';
+import { TOOLS } from './tools/index.js';
+import { FileSystem } from '../../platform/FileSystem.js';
+import { Path } from '../../platform/Path.js';
+import { Crypto, __sourcesRoot } from '../../platform/index.js';
+const DOCS_DIR = Path.join(__sourcesRoot, '../docs');
+const SERVER_INFO = {
+    name: 'ui5-test-runner',
+    version: '1.0.0'
+};
+const INSTRUCTIONS = [
+    'This server is the authoritative, always-current documentation for ui5-test-runner (a tool that runs UI5 QUnit/OPA tests).',
+    '',
+    'For ANY question about ui5-test-runner — its command-line options and flags, configuration keys, execution modes, coverage, reporting, migration between versions, or error messages — call `list_topics` first, then `get_topic` on the relevant entities, and ground your answer in what they return.',
+    '',
+    'Do NOT answer such questions from prior knowledge, and never invent option names, configuration keys, or capabilities: ui5-test-runner evolves across versions and its real option names differ from what similar tools use, so an ungrounded answer is likely wrong. If the documentation does not cover something, say so rather than guessing.',
+    '',
+    "Grounding does not mean exhaustiveness: answer the actual question and tailor the response to the user's project, leaving out documented topics that do not apply to their situation. Reading an entity does not oblige you to repeat everything in it."
+].join('\n');
+const SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+const HTTP_OK = 200;
+const HTTP_ACCEPTED = 202;
+const HTTP_METHOD_NOT_ALLOWED = 405;
+const HTTP_BAD_REQUEST = 400;
+const JSONRPC_PARSE_ERROR = -32_700;
+const JSONRPC_METHOD_NOT_FOUND = -32_601;
+const JSONRPC_INVALID_PARAMS = -32_602;
+const buildError = (id, code, message) => ({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message }
+});
+const isToolCallParameters = (parameters) => typeof parameters === 'object' &&
+    parameters !== null &&
+    typeof parameters.name === 'string' &&
+    typeof parameters.arguments === 'object';
+const negotiateProtocolVersion = (parameters) => {
+    const requested = parameters?.protocolVersion;
+    return typeof requested === 'string' && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : SUPPORTED_PROTOCOL_VERSIONS[0];
+};
+const handleRequest = async (request) => {
+    const { id, method, params } = request;
+    if (id === null || id === undefined) {
+        return null;
+    }
+    if (method === 'initialize') {
+        return {
+            jsonrpc: '2.0',
+            id,
+            result: {
+                protocolVersion: negotiateProtocolVersion(params),
+                serverInfo: SERVER_INFO,
+                capabilities: { tools: {} },
+                instructions: INSTRUCTIONS
+            }
+        };
+    }
+    if (method === 'ping') {
+        return { jsonrpc: '2.0', id, result: {} };
+    }
+    if (method === 'resources/list') {
+        return { jsonrpc: '2.0', id, result: { resources: [] } };
+    }
+    if (method === 'prompts/list') {
+        return { jsonrpc: '2.0', id, result: { prompts: [] } };
+    }
+    if (method === 'tools/list') {
+        return { jsonrpc: '2.0', id, result: { tools: Object.values(TOOLS).map((t) => t.definition) } };
+    }
+    if (method === 'tools/call') {
+        if (!isToolCallParameters(params)) {
+            return buildError(id, JSONRPC_INVALID_PARAMS, 'Invalid params: expected { name, arguments }');
+        }
+        const tool = TOOLS[params.name];
+        if (!tool) {
+            return buildError(id, JSONRPC_METHOD_NOT_FOUND, `Unknown tool: ${params.name}`);
+        }
+        let content;
+        try {
+            content = await tool.handler(params.arguments);
+        }
+        catch (error) {
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: { isError: true, content: [{ type: 'text', text: String(error) }] }
+            };
+        }
+        return {
+            jsonrpc: '2.0',
+            id,
+            result: { content: [{ type: 'text', text: content }] }
+        };
+    }
+    return buildError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${method}`);
+};
+export const buildREserveConfiguration = (configuration) => ({
+    hostname: '127.0.0.1',
+    port: configuration.port ?? 3000,
+    mappings: [
+        {
+            method: 'GET',
+            match: '/mcp',
+            custom: (_request, response) => {
+                response.writeHead(HTTP_METHOD_NOT_ALLOWED, { 'Content-Type': 'application/json' });
+                response.end(JSON.stringify({ error: 'Method Not Allowed' }));
+            }
+        },
+        {
+            method: 'POST',
+            match: '/mcp',
+            custom: async (request, response) => {
+                let parsed;
+                try {
+                    parsed = (await body(request).json());
+                }
+                catch {
+                    response.writeHead(HTTP_BAD_REQUEST, { 'Content-Type': 'application/json' });
+                    response.end(JSON.stringify(buildError(null, JSONRPC_PARSE_ERROR, 'Parse error')));
+                    return;
+                }
+                const result = await handleRequest(parsed);
+                if (result === null) {
+                    response.writeHead(HTTP_ACCEPTED);
+                    response.end();
+                    return;
+                }
+                const headers = { 'Content-Type': 'application/json' };
+                if (parsed.method === 'initialize') {
+                    headers['Mcp-Session-Id'] = Crypto.randomUUID();
+                }
+                response.writeHead(HTTP_OK, headers);
+                response.end(JSON.stringify(result));
+            }
+        },
+        {
+            method: 'GET',
+            match: '/([^?]*)',
+            custom: async ({ url }, _response, path) => {
+                const filePath = Path.join(DOCS_DIR, path || 'index.md');
+                const fileName = Path.basename(path || 'index.md');
+                try {
+                    await FileSystem.access(filePath, FileSystem.constants.R_OK);
+                }
+                catch {
+                    return 404;
+                }
+                if (url?.endsWith('?raw')) {
+                    const content = await FileSystem.readFile(filePath, 'utf8');
+                    return [content, { headers: { 'content-type': 'text/markdown' } }];
+                }
+                return [
+                    `<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+<script>
+  fetch('${fileName}?raw')
+    .then(response => response.text())
+    .then(content => {
+      document.body.innerHTML = marked.parse(content);
+    })
+</script>`,
+                    {
+                        headers: {
+                            'content-type': 'text/html'
+                        }
+                    }
+                ];
+            }
+        },
+        {
+            status: 404
+        }
+    ]
+});

package/dist/modes/mcp/tools/getTopic.js

@@ -0,0 +1,46 @@
+import { getIndex } from '../knowledgeBase.js';
+const buildRelatedTopics = (entity, index) => {
+    const seen = new Set();
+    const lines = [];
+    const add = (id, relation) => {
+        if (seen.has(id) || id === entity.id) {
+            return;
+        }
+        seen.add(id);
+        const related = index.getEntity(id);
+        const title = related === undefined ? id : `${id} — ${related.title}`;
+        lines.push(`- ${title} (${relation})`);
+    };
+    for (const [relation, targets] of Object.entries(entity.relations)) {
+        if (relation === 'breaking-in') {
+            continue;
+        }
+        for (const target of targets) {
+            add(target, relation);
+        }
+    }
+    for (const { id, relation } of index.getReverseRelations(entity.id)) {
+        add(id, `${relation} ←`);
+    }
+    return lines.length === 0 ? '' : `\n\n## Related topics\n\n${lines.join('\n')}\n`;
+};
+export const toolDefinitionGetTopic = {
+    definition: {
+        name: 'get_topic',
+        description: 'Fetch the authoritative ui5-test-runner documentation for one entity by its id (from list_topics, e.g. "options/coverage"). Use this to ground every answer about ui5-test-runner in the actual docs rather than prior knowledge. Returns the entity markdown plus a "Related topics" section listing linked entities worth retrieving next.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Entity id as returned by list_topics' }
+            },
+            required: ['id']
+        }
+    },
+    handler: (arguments_) => {
+        const id = arguments_['id'];
+        const index = getIndex();
+        const entity = index.getEntity(id);
+        const text = entity === undefined ? `No topic found for id "${id}".` : entity.body + buildRelatedTopics(entity, index);
+        return Promise.resolve(text);
+    }
+};

package/dist/modes/mcp/tools/index.js

@@ -0,0 +1,6 @@
+import { toolDefinitionListTopics } from './listTopics.js';
+import { toolDefinitionGetTopic } from './getTopic.js';
+export const TOOLS = {
+    list_topics: toolDefinitionListTopics,
+    get_topic: toolDefinitionGetTopic
+};

package/dist/modes/mcp/tools/listTopics.js

@@ -0,0 +1,14 @@
+import { getIndex } from '../knowledgeBase.js';
+const JSON_INDENT = 2;
+export const toolDefinitionListTopics = {
+    definition: {
+        name: 'list_topics',
+        description: 'Authoritative documentation catalog for ui5-test-runner. Call this whenever the user asks anything about ui5-test-runner — its options, flags, configuration keys, modes, coverage, reporting, migration, or error messages — BEFORE answering, and do not rely on prior knowledge (it is often wrong or outdated for this tool). Returns a flat catalog (id, type, title, summary, relations); match the question against the titles and summaries, then pass the chosen id to get_topic.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    handler: (_arguments) => Promise.resolve(JSON.stringify(getIndex().catalog, null, JSON_INDENT))
+};

package/dist/modes/test/PageContext.js

@@ -0,0 +1 @@
+export {};

package/dist/modes/test/Server.js

@@ -0,0 +1,99 @@
+import { assert, Exit, logger, Thread } from '../../platform/index.js';
+import { serve } from 'reserve';
+import { toPlainObject } from '../../utils/shared/object.js';
+import { redactSecrets } from '../../utils/node/anonymize.js';
+import { buildREserveConfiguration } from './reserve.js';
+import { logReserve } from '../../reserveLogger.js';
+let _channel;
+let _serverWorker;
+let _isStopping = false;
+export const Server = {
+    async start(configuration) {
+        assert(_serverWorker === undefined);
+        _channel = Thread.createBroadcastChannel('server');
+        Exit.registerAsyncTask({
+            name: 'server',
+            stop: () => Server.stop()
+        });
+        _serverWorker = Thread.createWorker('modes/test/Server', redactSecrets(toPlainObject(configuration)));
+        const { promise, resolve, reject } = Promise.withResolvers();
+        _channel.onmessage = ({ data: message }) => {
+            if (message.command === 'ready') {
+                resolve(message.port);
+            }
+            else if (message.command === 'error') {
+                reject(new Error('failed to start'));
+            }
+            else {
+                assert(false, 'unexpected');
+            }
+        };
+        return promise;
+    },
+    async stop() {
+        if (_isStopping) {
+            return;
+        }
+        _isStopping = true;
+        try {
+            assert(_serverWorker !== undefined);
+            _channel.postMessage({
+                command: 'terminate'
+            });
+            const { promise, resolve } = Promise.withResolvers();
+            _channel.onmessage = ({ data: message }) => {
+                if (message.command !== 'terminated') {
+                    return;
+                }
+                _channel.close();
+                _serverWorker?.unref();
+                resolve();
+            };
+            await promise;
+        }
+        finally {
+            _channel.close();
+        }
+    }
+};
+export const workerMain = async (configuration) => {
+    logger.debug({ source: 'server', message: 'starting server...' });
+    _channel = Thread.createBroadcastChannel('server');
+    let reserveServer;
+    _channel.onmessage = ({ data: message }) => {
+        if (message.command !== 'terminate') {
+            return;
+        }
+        logger.debug({ source: 'server', message: 'stopping server...' });
+        void reserveServer.close({ force: true }).finally(() => {
+            logger.debug({ source: 'server', message: 'server stopped.' });
+            _channel.postMessage({
+                command: 'terminated'
+            });
+            _channel.close();
+        });
+    };
+    try {
+        reserveServer = serve(await buildREserveConfiguration(configuration));
+    }
+    catch (error) {
+        logger.error({ source: 'server', message: 'an error occurred while configuring', error });
+        _channel.postMessage({
+            command: 'error'
+        });
+        return;
+    }
+    logReserve(reserveServer);
+    reserveServer
+        .on('ready', (event) => {
+        _channel.postMessage({
+            command: 'ready',
+            port: event.port
+        });
+    })
+        .on('error', () => {
+        _channel.postMessage({
+            command: 'error'
+        });
+    });
+};

package/dist/modes/test/browser.js

@@ -1,24 +1,37 @@
-import { BrowserFactory } from '../../browsers/factory.js';
-import { Exit, assert, logger } from '../../platform/index.js';
-let browser;
+import { BrowserFactory, getDescriptor, isDriver } from '../../browsers/factory.js';
+import { Exit, logger } from '../../platform/index.js';
+let _browser;
+let _capabilities;
 export const setupBrowser = async (configuration) => {
-    assert(configuration.browser === 'puppeteer');
-    browser = await BrowserFactory.build(configuration, 'puppeteer');
-    const { debugKeepBrowserOpen } = configuration;
+    const { driver } = configuration;
+    if (!isDriver(driver)) {
+        return logger.fatal({ source: 'job', message: `Unknown driver: ${driver}` });
+    }
+    _browser = await BrowserFactory.build(configuration, driver);
+    const { debugKeepBrowserOpen, browserVisible, browserViewportWidth, browserViewportHeight, browserDevice } = configuration;
     const settings = {
-        visible: debugKeepBrowserOpen
+        visible: browserVisible || debugKeepBrowserOpen,
+        viewport: {
+            width: browserViewportWidth,
+            height: browserViewportHeight
+        },
+        device: browserDevice,
+        browser: configuration.browser ?? getDescriptor(driver).defaultBrowser,
+        options: configuration.browserOptions,
+        basicAuthentication: configuration.browserBasicAuthUsername !== undefined && configuration.browserBasicAuthPassword !== undefined
+            ? { username: configuration.browserBasicAuthUsername, password: configuration.browserBasicAuthPassword }
+            : undefined
     };
     try {
-        await browser.setup(settings);
+        _capabilities = await _browser.setup(settings);
     }
     catch (error) {
-        logger.fatal({ source: 'job', message: 'Unable to setup browser', error });
-        throw error;
+        logger.fatal({ source: 'job', message: 'unable to setup browser', error });
     }
     if (debugKeepBrowserOpen) {
-        const { newWindow } = browser;
-        browser.newWindow = async (settings) => {
-            const window = await newWindow.call(browser, settings);
+        const { newWindow } = _browser;
+        _browser.newWindow = async (settings) => {
+            const window = await newWindow.call(_browser, settings);
             window.close = async () => { };
             return window;
         };
@@ -27,11 +40,12 @@ export const setupBrowser = async (configuration) => {
             name: 'debugKeepBrowserOpen',
             stop: () => resolve()
         });
-        browser.shutdown = () => {
-            logger.warn({ source: 'job', message: 'Browser will remain open, use CTRL+C to end command' });
+        _browser.shutdown = () => {
+            logger.warn({ source: 'job', message: 'browser will remain open, use CTRL+C to end command' });
             return promise;
         };
     }
-    return browser;
+    return _capabilities;
 };
-export const getBrowser = () => browser;
+export const getBrowser = () => _browser;
+export const getBrowserCapabilities = () => _capabilities;

package/dist/modes/test/browserConfig.js

@@ -0,0 +1,17 @@
+import { options } from '../../configuration/options.js';
+import { toPlainObject, pick } from '../../utils/shared/object.js';
+import { assert } from '../../platform/index.js';
+const UI5_TEST_RUNNER = 'ui5-test-runner';
+const browserExposedKeys = options
+    .filter((option) => 'browserExposed' in option)
+    .map(({ name }) => name);
+const serializeRegExps = (_key, value) => (value instanceof RegExp ? value.source : value);
+let _browserConfigScript;
+export const initBrowserConfig = (configuration) => {
+    const payload = pick(toPlainObject(configuration), browserExposedKeys);
+    _browserConfigScript = `(function(){window['${UI5_TEST_RUNNER}']=window['${UI5_TEST_RUNNER}']||{};window['${UI5_TEST_RUNNER}'].config=${JSON.stringify(payload, serializeRegExps)};})();`;
+};
+export const getBrowserConfigScript = (pageId) => {
+    assert(_browserConfigScript !== undefined, 'browserConfig not initialized');
+    return _browserConfigScript + `(function(){window['${UI5_TEST_RUNNER}'].config.pageId=${pageId};})();`;
+};