@wdio/nightwatch-devtools 1.1.0 → 1.2.0

package/dist/session.js

@@ -1,643 +0,0 @@
-import fs from 'node:fs/promises';
-import http from 'node:http';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import logger from '@wdio/logger';
-import { WebSocket } from 'ws';
-import { CONSOLE_METHODS, LOG_SOURCES, NAVIGATION_COMMANDS, SPINNER_RE } from './constants.js';
-import { stripAnsiCodes, detectLogLevel, createConsoleLogEntry, chromeLogLevelToLogLevel, getRequestType } from './helpers/utils.js';
-import { CAPTURE_PERFORMANCE_SCRIPT } from './helpers/capturePerformance.js';
-const require = createRequire(import.meta.url);
-const log = logger('@wdio/nightwatch-devtools:SessionCapturer');
-export class SessionCapturer {
-    #ws;
-    #originalConsoleMethods;
-    #originalProcessMethods;
-    #isCapturingConsole = false;
-    #browser;
-    #commandCounter = 0;
-    #sentCommandIds = new Set();
-    commandsLog = [];
-    sources = new Map();
-    consoleLogs = [];
-    mutations = [];
-    traceLogs = [];
-    networkRequests = [];
-    metadata;
-    constructor(devtoolsOptions = {}, browser) {
-        const { port, hostname } = devtoolsOptions;
-        this.#browser = browser;
-        if (hostname && port) {
-            this.#ws = new WebSocket(`ws://${hostname}:${port}/worker`);
-            this.#ws.on('open', () => {
-                this.#hasConnected = true;
-                log.info('✓ Worker WebSocket connected to backend');
-            });
-            this.#ws.on('error', (err) => log.error(`Couldn't connect to devtools backend: ${err.message}`));
-            this.#ws.on('close', () => {
-                log.info('Worker WebSocket disconnected');
-            });
-        }
-        this.#originalConsoleMethods = {
-            log: console.log,
-            info: console.info,
-            warn: console.warn,
-            error: console.error
-        };
-        this.#originalProcessMethods = {
-            stdoutWrite: process.stdout.write.bind(process.stdout),
-            stderrWrite: process.stderr.write.bind(process.stderr)
-        };
-        this.#patchConsole();
-        this.#interceptProcessStreams();
-    }
-    #patchConsole() {
-        CONSOLE_METHODS.forEach((method) => {
-            const originalMethod = this.#originalConsoleMethods[method];
-            console[method] = (...consoleArgs) => {
-                this.#isCapturingConsole = true;
-                const result = originalMethod.apply(console, consoleArgs);
-                this.#isCapturingConsole = false;
-                // Capture all console output; strip ANSI codes for clean display in UI
-                const rawText = consoleArgs
-                    .map((a) => typeof a === 'object' && a !== null ? JSON.stringify(a) : String(a))
-                    .join(' ');
-                const cleanText = stripAnsiCodes(rawText).trim();
-                if (!cleanText) {
-                    return result;
-                }
-                const logEntry = createConsoleLogEntry(method, [cleanText], LOG_SOURCES.TEST);
-                this.consoleLogs.push(logEntry);
-                this.sendUpstream('consoleLogs', [logEntry]);
-                return result;
-            };
-        });
-    }
-    #isInternalStreamLine(line) {
-        const t = line.trim();
-        return (t.startsWith('{"') ||
-            t.includes('@wdio/devtools-backend') ||
-            t.startsWith('[SESSION]'));
-    }
-    #hasConnected = false;
-    #isCapturingStream = false;
-    #interceptProcessStreams() {
-        const captureTerminalOutput = (outputData) => {
-            if (this.#isCapturingStream) {
-                return;
-            }
-            const outputText = typeof outputData === 'string' ? outputData : outputData.toString();
-            if (!outputText?.trim()) {
-                return;
-            }
-            this.#isCapturingStream = true;
-            try {
-                const linesToCapture = [];
-                for (const rawLine of outputText.split('\n')) {
-                    const segments = rawLine.split('\r').filter((s) => s.trim());
-                    const lastSegment = segments[segments.length - 1] ?? rawLine;
-                    const clean = stripAnsiCodes(lastSegment).trim();
-                    if (!clean ||
-                        this.#isInternalStreamLine(clean) ||
-                        SPINNER_RE.test(clean)) {
-                        continue;
-                    }
-                    linesToCapture.push(clean);
-                }
-                for (const clean of linesToCapture) {
-                    const logEntry = createConsoleLogEntry(detectLogLevel(clean), [clean], LOG_SOURCES.TERMINAL);
-                    this.consoleLogs.push(logEntry);
-                    this.sendUpstream('consoleLogs', [logEntry]);
-                }
-            }
-            finally {
-                this.#isCapturingStream = false;
-            }
-        };
-        const interceptStreamWrite = (stream, originalWriteMethod) => {
-            const capturer = this;
-            stream.write = function (chunk, ...additionalArgs) {
-                const writeResult = originalWriteMethod.call(stream, chunk, ...additionalArgs);
-                if (chunk && !capturer.#isCapturingConsole) {
-                    captureTerminalOutput(chunk);
-                }
-                return writeResult;
-            };
-        };
-        interceptStreamWrite(process.stdout, this.#originalProcessMethods.stdoutWrite);
-        interceptStreamWrite(process.stderr, this.#originalProcessMethods.stderrWrite);
-    }
-    #restoreConsole() {
-        CONSOLE_METHODS.forEach((method) => {
-            console[method] = this.#originalConsoleMethods[method];
-        });
-    }
-    #restoreProcessStreams() {
-        process.stdout.write = this.#originalProcessMethods.stdoutWrite;
-        process.stderr.write = this.#originalProcessMethods.stderrWrite;
-    }
-    cleanup() {
-        this.#restoreConsole();
-        this.#restoreProcessStreams();
-    }
-    get isReportingUpstream() {
-        return Boolean(this.#ws) && this.#ws?.readyState === WebSocket.OPEN;
-    }
-    /**
-     * Wait for WebSocket to connect
-     */
-    async waitForConnection(timeoutMs = 5000) {
-        if (!this.#ws) {
-            return false;
-        }
-        if (this.#ws.readyState === WebSocket.OPEN) {
-            return true;
-        }
-        return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                log.warn(`WebSocket connection timeout after ${timeoutMs}ms`);
-                resolve(false);
-            }, timeoutMs);
-            this.#ws.once('open', () => {
-                clearTimeout(timeout);
-                resolve(true);
-            });
-            this.#ws.once('error', () => {
-                clearTimeout(timeout);
-                resolve(false);
-            });
-        });
-    }
-    #serializeError(error) {
-        return error
-            ? { name: error.name, message: error.message, stack: error.stack }
-            : undefined;
-    }
-    async captureCommand(command, args, result, error, testUid, callSource, timestamp) {
-        // Serialize error properly (Error objects don't JSON.stringify well)
-        const serializedError = this.#serializeError(error);
-        const commandId = this.#commandCounter++;
-        const commandLogEntry = {
-            _id: commandId,
-            command,
-            args,
-            result,
-            error: serializedError,
-            timestamp: timestamp || Date.now(),
-            callSource,
-            testUid
-        };
-        this.commandsLog.push(commandLogEntry);
-        const isNavigationCommand = NAVIGATION_COMMANDS.some((cmd) => command.toLowerCase().includes(cmd.toLowerCase()));
-        if (isNavigationCommand && this.#browser && !error) {
-            this.#capturePerformanceData(commandLogEntry, args).catch((err) => {
-                log.warn(`Failed to capture performance data: ${err.message}`);
-            });
-        }
-        return true;
-    }
-    async #capturePerformanceData(commandLogEntry, args) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const performanceData = await this.#browser.execute(CAPTURE_PERFORMANCE_SCRIPT);
-        let data;
-        if (performanceData && typeof performanceData === 'object') {
-            data =
-                'value' in performanceData
-                    ? performanceData.value
-                    : performanceData;
-        }
-        if (data && data.navigation) {
-            commandLogEntry.performance = {
-                navigation: data.navigation,
-                resources: data.resources
-            };
-            commandLogEntry.cookies = data.cookies;
-            commandLogEntry.documentInfo = data.documentInfo;
-            commandLogEntry.result = {
-                url: args[0],
-                loadTime: data.navigation?.timing?.loadTime,
-                resources: data.resources,
-                resourceCount: data.resources?.length,
-                cookies: data.cookies,
-                title: data.documentInfo?.title
-            };
-        }
-    }
-    /** Send a command to the UI (only if not already sent) */
-    sendCommand(command) {
-        if (command._id !== undefined && !this.#sentCommandIds.has(command._id)) {
-            this.#sentCommandIds.add(command._id);
-            // Remove internal ID before sending
-            const commandToSend = { ...command };
-            delete commandToSend._id;
-            this.sendUpstream('commands', [commandToSend]);
-        }
-    }
-    /**
-     * Replace an already-captured command entry (used for retried commands so
-     * only the final execution result is shown in the UI).
-     * Removes the old entry from commandsLog, revokes its sent-status so the
-     * replacement can be sent, and returns the new entry together with the
-     * old entry's timestamp (so the UI can locate and replace it in-place).
-     */
-    replaceCommand(oldId, command, args, result, error, testUid, callSource, timestamp) {
-        // Remove the superseded entry and capture its timestamp for the UI
-        const idx = this.commandsLog.findIndex((c) => c._id === oldId);
-        const oldTimestamp = idx !== -1 ? (this.commandsLog[idx].timestamp ?? 0) : 0;
-        if (idx !== -1) {
-            this.commandsLog.splice(idx, 1);
-        }
-        // Allow the slot to be re-used by a new entry
-        this.#sentCommandIds.delete(oldId);
-        const serializedError = this.#serializeError(error);
-        const commandId = this.#commandCounter++;
-        const entry = {
-            _id: commandId,
-            command,
-            args,
-            result,
-            error: serializedError,
-            timestamp: timestamp || Date.now(),
-            callSource,
-            testUid
-        };
-        this.commandsLog.push(entry);
-        return { entry, oldTimestamp };
-    }
-    /** Send a replace-command event to the UI (swaps old entry in-place) */
-    sendReplaceCommand(oldTimestamp, command) {
-        const commandToSend = { ...command };
-        delete commandToSend._id;
-        this.sendUpstream('replaceCommand', {
-            oldTimestamp,
-            command: commandToSend
-        });
-    }
-    /**
-     * Take a screenshot by calling the WebDriver HTTP endpoint directly.
-     * This completely bypasses Nightwatch's command queue so there is no risk
-     * of the request being appended after `end()` / `quit()`.
-     */
-    takeScreenshotViaHttp(browser) {
-        const browserAny = browser;
-        const sessionId = browserAny.sessionId;
-        if (!sessionId) {
-            return Promise.resolve(null);
-        }
-        const pick = (obj, ...keys) => {
-            if (!obj || typeof obj !== 'object') {
-                return undefined;
-            }
-            for (const k of keys) {
-                const val = obj[k];
-                if (val !== undefined && val !== null) {
-                    return val;
-                }
-            }
-            return undefined;
-        };
-        const transportSettings = browserAny.transport?.settings?.webdriver ||
-            browserAny.queue?.transport?.settings?.webdriver ||
-            browserAny.nightwatchInstance?.transport?.settings?.webdriver ||
-            {};
-        const opts = browserAny.options || {};
-        const nightwatchSettings = browserAny.nightwatchInstance?.settings ||
-            browserAny.globals?.nightwatchInstance?.settings ||
-            {};
-        const driverHost = pick(transportSettings, 'host', 'server_address') ||
-            pick(opts.webdriver, 'host') ||
-            pick(nightwatchSettings.webdriver, 'host') ||
-            'localhost';
-        const driverPort = pick(transportSettings, 'port') ||
-            pick(opts.webdriver, 'port') ||
-            pick(nightwatchSettings.webdriver, 'port') ||
-            9515;
-        const endpoint = `http://${driverHost}:${driverPort}/session/${sessionId}/screenshot`;
-        return new Promise((resolve) => {
-            const req = http.get(endpoint, (res) => {
-                let body = '';
-                res.on('data', (chunk) => {
-                    body += chunk;
-                });
-                res.on('end', () => {
-                    try {
-                        const value = JSON.parse(body).value || null;
-                        if (!value) {
-                            log.warn(`[screenshot] Empty response from ${endpoint}`);
-                        }
-                        resolve(value);
-                    }
-                    catch {
-                        log.warn(`[screenshot] Failed to parse response from ${endpoint}`);
-                        resolve(null);
-                    }
-                });
-            });
-            req.on('error', (err) => {
-                log.warn(`[screenshot] HTTP request failed (${endpoint}): ${err.message}`);
-                resolve(null);
-            });
-            req.setTimeout(5000, () => {
-                log.warn(`[screenshot] Request timed out (${endpoint})`);
-                req.destroy();
-                resolve(null);
-            });
-        });
-    }
-    /** Capture test source code */
-    async captureSource(filePath) {
-        if (!this.sources.has(filePath)) {
-            try {
-                const sourceCode = await fs.readFile(filePath, 'utf-8');
-                this.sources.set(filePath, sourceCode.toString());
-                this.sendUpstream('sources', { [filePath]: sourceCode.toString() });
-            }
-            catch (err) {
-                log.warn(`Failed to read source file ${filePath}: ${err.message}`);
-            }
-        }
-    }
-    /** Send data upstream to backend */
-    sendUpstream(event, data) {
-        if (!this.#ws || this.#ws.readyState !== WebSocket.OPEN) {
-            if (this.#hasConnected) {
-                log.warn(`[upstream] WebSocket not open — dropping "${event}" event`);
-            }
-            return;
-        }
-        try {
-            this.#ws.send(JSON.stringify({ scope: event, data }));
-        }
-        catch (err) {
-            log.warn(`[upstream] Failed to send "${event}": ${err.message}`);
-        }
-    }
-    /** Returns true when the WebSocket is open. */
-    isConnected() {
-        return this.#ws?.readyState === WebSocket.OPEN;
-    }
-    /**
-     * Gracefully close the WebSocket, waiting for any buffered messages to flush.
-     * Call this before process exit in reuse mode to prevent data loss.
-     */
-    async closeWebSocket() {
-        if (!this.#ws || this.#ws.readyState === WebSocket.CLOSED) {
-            return;
-        }
-        return new Promise((resolve) => {
-            const timeout = setTimeout(resolve, 2000);
-            this.#ws.once('close', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            this.#ws.close();
-        });
-    }
-    /**
-     * Inject the WDIO devtools script into the browser page
-     */
-    async injectScript(browser) {
-        try {
-            // Load the preload script
-            const scriptPath = require.resolve('@wdio/devtools-script');
-            const scriptDir = path.dirname(scriptPath);
-            const preloadScriptPath = path.join(scriptDir, 'script.js');
-            let scriptContent = await fs.readFile(preloadScriptPath, 'utf-8');
-            // The script contains top-level await - wrap the entire script in async IIFE before injection
-            scriptContent = `(async function() { ${scriptContent} })()`;
-            // Inject using script element - synchronous check after timeout
-            const injectionScript = `
-        const script = document.createElement('script');
-        script.textContent = arguments[0];
-        document.head.appendChild(script);
-        return true;
-      `;
-            await browser.execute(injectionScript, [scriptContent]);
-            // Poll for collector — the async IIFE may take a moment to initialise
-            let hasCollector = false;
-            for (let attempt = 0; attempt < 5; attempt++) {
-                await new Promise((resolve) => setTimeout(resolve, 200));
-                const checkResult = await browser.execute('return typeof window.wdioTraceCollector !== "undefined"');
-                hasCollector = (checkResult?.value ?? checkResult) === true;
-                if (hasCollector) {
-                    break;
-                }
-            }
-            if (hasCollector) {
-                log.info('✓ Script injected and collector ready');
-            }
-            else {
-                log.warn('Script injection may have failed — collector not found');
-            }
-        }
-        catch (err) {
-            log.error(`Failed to inject script: ${err.message}`);
-            throw err;
-        }
-    }
-    /**
-     * Capture Chrome DevTools browser console logs via WebDriver log API.
-     * Requires loggingPrefs: { browser: 'ALL' } in Chrome capabilities.
-     */
-    async captureBrowserLogs(browser) {
-        try {
-            const rawLogs = await browser.getLog('browser');
-            const logs = (rawLogs?.value ?? rawLogs);
-            if (!Array.isArray(logs) || logs.length === 0) {
-                return;
-            }
-            const entries = logs.map((entry) => ({
-                timestamp: entry.timestamp,
-                type: chromeLogLevelToLogLevel(entry.level),
-                args: [entry.message],
-                source: LOG_SOURCES.BROWSER
-            }));
-            this.consoleLogs.push(...entries);
-            this.sendUpstream('consoleLogs', entries);
-        }
-        catch {
-            // Browser log capture not available (loggingPrefs not set or not supported)
-        }
-    }
-    /**
-     * Parse Chrome performance logs to extract network request entries.
-     * Requires loggingPrefs: { performance: 'ALL' } in Chrome capabilities.
-     */
-    async captureNetworkFromPerformanceLogs(browser) {
-        try {
-            const rawLogs = await browser.getLog('performance');
-            const logs = (rawLogs?.value ?? rawLogs);
-            if (!Array.isArray(logs) || logs.length === 0) {
-                return;
-            }
-            // Parse CDP Network.* events from the performance log
-            const pendingRequests = new Map();
-            const networkEntries = [];
-            for (const entry of logs) {
-                try {
-                    const msg = JSON.parse(entry.message);
-                    const { method, params } = msg.message;
-                    if (method === 'Network.requestWillBeSent') {
-                        const { requestId, request: req, timestamp } = params;
-                        pendingRequests.set(requestId, {
-                            id: `${entry.timestamp}-${requestId}`,
-                            url: req.url,
-                            method: req.method,
-                            requestHeaders: req.headers,
-                            timestamp: Math.round(timestamp * 1000),
-                            startTime: entry.timestamp
-                        });
-                    }
-                    else if (method === 'Network.responseReceived') {
-                        const { requestId, response } = params;
-                        const pending = pendingRequests.get(requestId);
-                        if (pending) {
-                            const responseHeaders = {};
-                            for (const [k, v] of Object.entries(response.headers || {})) {
-                                responseHeaders[k.toLowerCase()] = String(v);
-                            }
-                            pending.status = response.status;
-                            pending.statusText = response.statusText;
-                            pending.responseHeaders = responseHeaders;
-                            pending.mimeType = response.mimeType;
-                            pending.type = getRequestType(pending.url, response.mimeType);
-                        }
-                    }
-                    else if (method === 'Network.loadingFinished') {
-                        const { requestId, encodedDataLength } = params;
-                        const pending = pendingRequests.get(requestId);
-                        if (pending && pending.status !== undefined) {
-                            pending.size = encodedDataLength;
-                            pending.endTime = entry.timestamp;
-                            pending.time = entry.timestamp - pending.startTime;
-                            networkEntries.push({ ...pending });
-                            pendingRequests.delete(requestId);
-                        }
-                    }
-                    else if (method === 'Network.loadingFailed') {
-                        const { requestId, errorText } = params;
-                        const pending = pendingRequests.get(requestId);
-                        if (pending) {
-                            pending.error = errorText;
-                            pending.endTime = entry.timestamp;
-                            pending.time = entry.timestamp - pending.startTime;
-                            networkEntries.push({ ...pending });
-                            pendingRequests.delete(requestId);
-                        }
-                    }
-                }
-                catch {
-                    // skip malformed entries
-                }
-            }
-            if (networkEntries.length > 0) {
-                // Helper: for failed requests strip query string so that parallel
-                // autocomplete/prefetch requests to the same path (e.g. /search?q=W,
-                // /search?q=We, /search?q=Web…) collapse to a single entry.
-                const failedKey = (entry) => {
-                    try {
-                        const u = new URL(entry.url);
-                        return `err:${entry.method}:${u.origin}${u.pathname}`;
-                    }
-                    catch {
-                        return `err:${entry.method}:${entry.url}`;
-                    }
-                };
-                const alreadySeen = new Set(this.networkRequests.map((r) => r.error !== undefined
-                    ? failedKey(r)
-                    : `ok:${r.method}:${r.url}:${r.timestamp}`));
-                const deduped = [];
-                const seenFailedInBatch = new Map();
-                for (const entry of networkEntries) {
-                    if (entry.error !== undefined) {
-                        const key = failedKey(entry);
-                        if (alreadySeen.has(key)) {
-                            continue;
-                        }
-                        const existing = seenFailedInBatch.get(key);
-                        if (existing !== undefined) {
-                            deduped[existing] = entry; // replace with latest failure
-                        }
-                        else {
-                            seenFailedInBatch.set(key, deduped.length);
-                            deduped.push(entry);
-                        }
-                    }
-                    else {
-                        const key = `ok:${entry.method}:${entry.url}:${entry.timestamp}`;
-                        if (!alreadySeen.has(key)) {
-                            deduped.push(entry);
-                        }
-                    }
-                }
-                this.networkRequests.push(...deduped);
-                this.sendUpstream('networkRequests', deduped);
-            }
-        }
-        catch (err) {
-            const msg = err.message ?? '';
-            // Silently skip when performance logging was not enabled in capabilities
-            if (!msg.includes('log type') && !msg.includes('performance')) {
-                log.warn(`Performance log capture failed: ${msg}`);
-            }
-        }
-    }
-    /**
-     * Capture trace data from the browser (network requests, console logs, etc.)
-     */
-    async captureTrace(browser) {
-        // Capture network requests from Chrome performance logs
-        await this.captureNetworkFromPerformanceLogs(browser);
-        // Also try the injected wdioTraceCollector script for XHR/fetch and mutations
-        try {
-            const checkResult = await browser.execute('return typeof window.wdioTraceCollector !== "undefined"');
-            const collectorExists = (checkResult?.value ?? checkResult) === true;
-            if (!collectorExists) {
-                return;
-            }
-            const result = await browser.execute(`
-        if (typeof window.wdioTraceCollector === 'undefined') {
-          return null;
-        }
-        return window.wdioTraceCollector.getTraceData();
-      `);
-            const traceData = result?.value ?? result;
-            if (!traceData) {
-                return;
-            }
-            const { mutations, traceLogs, consoleLogs, networkRequests, metadata } = traceData;
-            if (metadata) {
-                this.metadata = { ...this.metadata, ...metadata };
-                this.sendUpstream('metadata', this.metadata);
-            }
-            if (Array.isArray(consoleLogs) && consoleLogs.length > 0) {
-                const tagged = consoleLogs.map((e) => ({
-                    ...e,
-                    source: LOG_SOURCES.BROWSER
-                }));
-                this.consoleLogs.push(...tagged);
-                this.sendUpstream('consoleLogs', tagged);
-            }
-            if (Array.isArray(networkRequests) && networkRequests.length > 0) {
-                this.networkRequests.push(...networkRequests);
-                this.sendUpstream('networkRequests', networkRequests);
-            }
-            if (Array.isArray(mutations) && mutations.length > 0) {
-                this.mutations.push(...mutations);
-                this.sendUpstream('mutations', mutations);
-                log.info(`[trace] Captured ${mutations.length} DOM mutation(s)`);
-            }
-            if (Array.isArray(traceLogs) && traceLogs.length > 0) {
-                this.traceLogs.push(...traceLogs);
-                this.sendUpstream('logs', traceLogs);
-            }
-            if (Array.isArray(networkRequests) && networkRequests.length > 0) {
-                log.info(`[trace] Captured ${networkRequests.length} network request(s)`);
-            }
-        }
-        catch (err) {
-            log.error(`Failed to capture trace from injected script: ${err.message}`);
-        }
-    }
-}
-//# sourceMappingURL=session.js.map