@piwitests/reporter 0.4.2

package/dist/helpers.js

@@ -0,0 +1,288 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashForProject = hashForProject;
+exports.workerIndexOf = workerIndexOf;
+exports.detectCliFileFilters = detectCliFileFilters;
+exports.getSetupFilePath = getSetupFilePath;
+exports.computeInstanceId = computeInstanceId;
+exports.detectCiRunLabel = detectCiRunLabel;
+exports.readSetupInfo = readSetupInfo;
+exports.readSourceSnippet = readSourceSnippet;
+exports.createLimiter = createLimiter;
+exports.createGlobalSetup = createGlobalSetup;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const config_js_1 = require("./config.js");
+const http_client_js_1 = require("./http-client.js");
+const logger_js_1 = require("./logger.js");
+/** Produce a deterministic short SHA-1 hex hash for a project name (used in temp file names) */
+function hashForProject(projectName) {
+    return crypto.createHash('sha1').update(projectName).digest('hex').slice(0, 16);
+}
+/**
+ * Extract a worker index from a Playwright `TestResult`, falling back to
+ * `parallelIndex` when `workerIndex` is absent. Returns `null` when neither is
+ * set. Localizes the `as any` reach into Playwright's result object so the
+ * cast lives in exactly one place.
+ */
+function workerIndexOf(result) {
+    if (!result)
+        return null;
+    return result.workerIndex ?? result.parallelIndex ?? null;
+}
+/**
+ * Extract positional file/path filters from a Playwright CLI invocation
+ * (e.g. `playwright test tests/login.spec.ts auth/`). These narrow a run to
+ * specific files and are NOT reflected in `config.grep`, so they're the only
+ * signal that a file-filtered run is partial. Returns an empty array when the
+ * full suite was requested.
+ *
+ * Best-effort: skips the values of known value-taking options so they aren't
+ * mistaken for file filters. `--flag=value` forms consume no extra token.
+ */
+const PW_VALUE_FLAGS = new Set([
+    '-c',
+    '--config',
+    '-j',
+    '--workers',
+    '-g',
+    '--grep',
+    '--grep-invert',
+    '--global-timeout',
+    '--max-failures',
+    '--output',
+    '-p',
+    '--project',
+    '--repeat-each',
+    '--reporter',
+    '--retries',
+    '--shard',
+    '--timeout',
+    '--trace',
+]);
+function detectCliFileFilters(argv = process.argv) {
+    // Drop the node executable + script path, then start after the `test` subcommand.
+    const args = argv.slice(2);
+    const testIdx = args.indexOf('test');
+    const rest = testIdx >= 0 ? args.slice(testIdx + 1) : args;
+    const files = [];
+    for (let i = 0; i < rest.length; i++) {
+        const tok = rest[i];
+        if (tok.startsWith('-')) {
+            // A bare value-taking flag (no `=`) consumes the next token as its value.
+            if (!tok.includes('=') && PW_VALUE_FLAGS.has(tok))
+                i++;
+            continue;
+        }
+        files.push(tok);
+    }
+    return files;
+}
+/** Return the temp-file path used to exchange setup info between globalSetup and the reporter instance */
+function getSetupFilePath(projectName) {
+    return path.join(os.tmpdir(), `piwi-dashboard-setup-${hashForProject(projectName)}.json`);
+}
+/** Derive a unique instance identifier by hashing hostname + projectName (or runLabel + projectName when sharding) */
+function computeInstanceId(projectName, runLabel) {
+    const seed = runLabel ? `${projectName}|${runLabel}` : `${os.hostname()}|${projectName}`;
+    return crypto.createHash('sha256').update(seed).digest('hex').slice(0, 16);
+}
+/** Detect a stable CI run label from well-known environment variables. Returns null outside CI. */
+function detectCiRunLabel() {
+    const env = process.env;
+    if (env.GITHUB_ACTIONS && env.GITHUB_RUN_ID)
+        return env.GITHUB_RUN_ID;
+    if (env.GITLAB_CI && env.CI_PIPELINE_ID)
+        return env.CI_PIPELINE_ID;
+    if (env.CIRCLECI && env.CIRCLE_WORKFLOW_ID)
+        return env.CIRCLE_WORKFLOW_ID;
+    if (env.TRAVIS && env.TRAVIS_BUILD_ID)
+        return env.TRAVIS_BUILD_ID;
+    if (env.TF_BUILD && env.BUILD_BUILDID)
+        return env.BUILD_BUILDID;
+    if (env.JENKINS_URL && env.BUILD_ID)
+        return env.BUILD_ID;
+    if (env.BUILDKITE_BUILD_ID)
+        return env.BUILDKITE_BUILD_ID;
+    if (env.TEAMCITY_BUILD_ID)
+        return env.TEAMCITY_BUILD_ID;
+    if (env.BITBUCKET_BUILD_NUMBER)
+        return env.BITBUCKET_BUILD_NUMBER;
+    if (env.SEMAPHORE_WORKFLOW_ID)
+        return env.SEMAPHORE_WORKFLOW_ID;
+    if (env.APPVEYOR_BUILD_ID)
+        return env.APPVEYOR_BUILD_ID;
+    if (env.DRONE_BUILD_NUMBER)
+        return env.DRONE_BUILD_NUMBER;
+    return null;
+}
+/** Read and delete the setup info file for the given project. Returns `null` when no file exists. */
+function readSetupInfo(projectName) {
+    const setupFile = getSetupFilePath(projectName);
+    try {
+        if (fs.existsSync(setupFile)) {
+            const info = JSON.parse(fs.readFileSync(setupFile, 'utf8'));
+            fs.unlinkSync(setupFile);
+            if (info.projectName === projectName)
+                return info;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/** Read a snippet of source code surrounding the given line, returning a formatted string with line numbers. Returns `null` on error. */
+function readSourceSnippet(file, line, context) {
+    try {
+        const content = fs.readFileSync(file, 'utf-8');
+        const lines = content.split('\n');
+        const start = Math.max(0, line - context - 1);
+        const end = Math.min(lines.length, line + context);
+        return lines
+            .slice(start, end)
+            .map((l, i) => {
+            const lineNum = start + i + 1;
+            const marker = lineNum === line ? '> ' : '  ';
+            return `${marker}${String(lineNum).padStart(4)} | ${l}`;
+        })
+            .join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+/** Create a concurrency limiter that ensures at most `maxConcurrent` async operations run simultaneously */
+function createLimiter(maxConcurrent) {
+    const limitValue = Math.max(1, Math.floor(maxConcurrent));
+    let active = 0;
+    const queue = [];
+    const next = () => {
+        active--;
+        const run = queue.shift();
+        if (run)
+            run();
+    };
+    return function limit(fn) {
+        return new Promise((resolve, reject) => {
+            const run = () => {
+                active++;
+                Promise.resolve().then(fn).then(resolve, reject).finally(next);
+            };
+            if (active < limitValue)
+                run();
+            else
+                queue.push(run);
+        });
+    };
+}
+/**
+ * Create a Playwright `globalSetup` function that registers a test run on the
+ * Piwi Dashboard server at the start of the run.  An optional `userSetup` is
+ * called afterward so existing setup logic is preserved.
+ *
+ * The server-run ID and a one-time token are written to a temp file so the
+ * reporter instance can pick them up during the streaming handshake.
+ *
+ * @param options   Piwi Dashboard options (uses `serverUrl`, `projectName`, …).
+ * @param userSetup An existing global setup to chain after the Piwi registration.
+ */
+function createGlobalSetup(options, userSetup) {
+    return async function globalSetupFn(config) {
+        const opts = (0, config_js_1.resolveOptions)((options ?? {}));
+        const logger = new logger_js_1.Logger(opts.verbose ?? false);
+        if (!opts.serverUrl) {
+            logger.info('Not enabled — set PIWI_DASHBOARD_URL or serverUrl to enable.');
+            if (userSetup)
+                return userSetup(config);
+            return;
+        }
+        const piwiReporterPath = path.resolve(__dirname, 'index.js');
+        const hasPiwi = Array.isArray(config?.reporter) &&
+            config.reporter.some((r) => {
+                if (!Array.isArray(r) || typeof r[0] !== 'string')
+                    return false;
+                if (r[0].toLowerCase().includes('piwi'))
+                    return true;
+                try {
+                    return path.resolve(require.resolve(r[0])) === piwiReporterPath;
+                }
+                catch {
+                    return false;
+                }
+            });
+        if (!hasPiwi) {
+            logger.debug('Not reporting — Piwi is not in the Playwright reporters list.');
+            if (userSetup)
+                return userSetup(config);
+            return;
+        }
+        const httpClient = new http_client_js_1.HttpClient(opts.serverUrl, logger);
+        try {
+            const auth = await httpClient.resolveAuth(opts);
+            const runLabel = opts.runLabel || detectCiRunLabel();
+            // Detect shard info from Playwright config (--shard=1/3)
+            const pwShard = config.shard;
+            const shardIndex = pwShard?.current;
+            const shardTotal = pwShard?.total;
+            const response = await httpClient.postJSON('/api/test-runs/setup', {
+                projectName: opts.projectName,
+                projectDescription: opts.projectDescription,
+                environment: opts.environment || null,
+                label: opts.label || null,
+                startTime: new Date().toISOString(),
+                instanceId: computeInstanceId(opts.projectName, runLabel),
+                shardIndex,
+                shardTotal,
+            }, auth);
+            if (response?.runId && response?.setupToken) {
+                fs.writeFileSync(getSetupFilePath(opts.projectName), JSON.stringify({
+                    runId: response.runId,
+                    setupToken: response.setupToken,
+                    projectName: opts.projectName,
+                }));
+                logger.debug(`Global setup: initialising run #${response.runId}`);
+            }
+        }
+        catch (error) {
+            logger.warn(`Could not register global setup: ${error.message}`);
+        }
+        if (userSetup)
+            return userSetup(config);
+    };
+}

package/dist/http-client.d.ts

@@ -0,0 +1,42 @@
+import FormData from 'form-data';
+import { Logger } from './logger.js';
+export { FormData };
+/**
+ * Low-level HTTP client for communicating with the Piwi Dashboard server.
+ * Supports JSON requests, multipart form-data uploads, and session-based login.
+ *
+ * All three public methods (`login`, `postJSON`, `postFormData`) delegate to a
+ * single `request()` core that owns the transport selection, header/auth
+ * application, response accumulation, and socket timeout. The package stays on
+ * the single `form-data` runtime dependency — no HTTP client library.
+ */
+export declare class HttpClient {
+    private readonly serverUrl;
+    private readonly logger;
+    private readonly timeout;
+    /**
+     * @param serverUrl Base URL of the Piwi Dashboard server (e.g. `http://localhost:3000`).
+     * @param logger    Prefixed logger for verbose diagnostics.
+     * @param timeout   Socket inactivity timeout in ms (default 30s). A hung
+     *                  server now fails fast instead of stalling the reporter.
+     */
+    constructor(serverUrl: string, logger?: Logger, timeout?: number);
+    /**
+     * Resolve an auth credential: prefer `apiKey`, fall back to `username`/`password` login,
+     * or return `null` when neither is configured.
+     */
+    resolveAuth(options: {
+        apiKey?: string | null;
+        username?: string | null;
+        password?: string | null;
+    }): Promise<string | null>;
+    /** Authenticate with username/password and return the session cookie string */
+    login(username: string, password: string): Promise<string>;
+    /** Send a JSON POST request. `auth` can be an API key (prefix `pd_`) or a session cookie string. */
+    postJSON(pathname: string, payload: unknown, auth?: string | null): Promise<any>;
+    /** Send a multipart form-data POST request. Used for report and trace uploads. */
+    postFormData(pathname: string, form: FormData, auth?: string | null): Promise<any>;
+    /** Unified request core: transport, headers, auth, response accumulation, timeout. */
+    private request;
+    private applyAuth;
+}

package/dist/http-client.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = exports.FormData = void 0;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const form_data_1 = __importDefault(require("form-data"));
+exports.FormData = form_data_1.default;
+const logger_js_1 = require("./logger.js");
+/**
+ * Low-level HTTP client for communicating with the Piwi Dashboard server.
+ * Supports JSON requests, multipart form-data uploads, and session-based login.
+ *
+ * All three public methods (`login`, `postJSON`, `postFormData`) delegate to a
+ * single `request()` core that owns the transport selection, header/auth
+ * application, response accumulation, and socket timeout. The package stays on
+ * the single `form-data` runtime dependency — no HTTP client library.
+ */
+class HttpClient {
+    /**
+     * @param serverUrl Base URL of the Piwi Dashboard server (e.g. `http://localhost:3000`).
+     * @param logger    Prefixed logger for verbose diagnostics.
+     * @param timeout   Socket inactivity timeout in ms (default 30s). A hung
+     *                  server now fails fast instead of stalling the reporter.
+     */
+    constructor(serverUrl, logger = new logger_js_1.Logger(), timeout = 30000) {
+        this.serverUrl = serverUrl;
+        this.logger = logger;
+        this.timeout = timeout;
+    }
+    /**
+     * Resolve an auth credential: prefer `apiKey`, fall back to `username`/`password` login,
+     * or return `null` when neither is configured.
+     */
+    async resolveAuth(options) {
+        if (options.apiKey)
+            return options.apiKey;
+        if (options.username && options.password) {
+            this.logger.info(`Authenticating as ${options.username}...`);
+            return this.login(options.username, options.password);
+        }
+        return null;
+    }
+    /** Authenticate with username/password and return the session cookie string */
+    async login(username, password) {
+        const body = JSON.stringify({ username, password });
+        const res = await this.request('POST', '/api/auth/login', {
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            body,
+        });
+        if (res.status < 200 || res.status >= 300) {
+            this.logger.debugError(`Login response: ${res.text}`);
+            throw new Error(`Login failed with status ${res.status}`);
+        }
+        const setCookie = res.headers['set-cookie'];
+        if (!setCookie || setCookie.length === 0) {
+            throw new Error('Login succeeded but no session cookie was returned');
+        }
+        const cookie = setCookie.map((c) => c.split(';')[0]).join('; ');
+        this.logger.debug('Logged in successfully');
+        return cookie;
+    }
+    /** Send a JSON POST request. `auth` can be an API key (prefix `pd_`) or a session cookie string. */
+    async postJSON(pathname, payload, auth) {
+        const body = JSON.stringify(payload);
+        const res = await this.request('POST', pathname, {
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            body,
+            auth,
+        });
+        if (res.status < 200 || res.status >= 300) {
+            this.logger.debugError(`Response: ${res.text}`);
+            throw new Error(`Request failed with status ${res.status}`);
+        }
+        try {
+            return JSON.parse(res.text);
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Send a multipart form-data POST request. Used for report and trace uploads. */
+    async postFormData(pathname, form, auth) {
+        const headers = form.getHeaders();
+        const res = await this.request('POST', pathname, { headers, form, auth });
+        if (res.status < 200 || res.status >= 300) {
+            throw new Error(`Request failed with status ${res.status}: ${res.text}`);
+        }
+        try {
+            return JSON.parse(res.text);
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Unified request core: transport, headers, auth, response accumulation, timeout. */
+    request(method, pathname, opts) {
+        return new Promise((resolve, reject) => {
+            const url = new url_1.URL(pathname, this.serverUrl);
+            const transport = url.protocol === 'https:' ? https_1.default : http_1.default;
+            const headers = { ...opts.headers };
+            this.applyAuth(headers, opts.auth);
+            const req = transport.request({
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname,
+                method,
+                headers,
+            }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ status: res.statusCode ?? 0, text: data, headers: res.headers });
+                });
+            });
+            req.on('error', reject);
+            req.setTimeout(this.timeout, () => {
+                req.destroy(new Error(`Request to ${pathname} timed out after ${this.timeout}ms`));
+            });
+            if (opts.form) {
+                opts.form.pipe(req);
+            }
+            else if (opts.body !== undefined) {
+                req.write(opts.body);
+                req.end();
+            }
+            else {
+                req.end();
+            }
+        });
+    }
+    applyAuth(headers, auth) {
+        if (!auth)
+            return;
+        if (auth.startsWith('pd_')) {
+            headers['Authorization'] = `Bearer ${auth}`;
+        }
+        else {
+            headers['Cookie'] = auth;
+        }
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { PiwiDashboardReporter } from './reporter.js';
+import { wrapConfig } from './config-wrapper.js';
+import { createGlobalSetup } from './helpers.js';
+declare const _default: typeof PiwiDashboardReporter & {
+    wrapConfig: typeof wrapConfig;
+    createGlobalSetup: typeof createGlobalSetup;
+};
+export = _default;

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+const reporter_js_1 = require("./reporter.js");
+const config_wrapper_js_1 = require("./config-wrapper.js");
+const helpers_js_1 = require("./helpers.js");
+const _default = Object.assign(reporter_js_1.PiwiDashboardReporter, { wrapConfig: config_wrapper_js_1.wrapConfig, createGlobalSetup: helpers_js_1.createGlobalSetup });
+module.exports = _default;

package/dist/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tiny prefixed logger. Owns the `[Piwi Dashboard]` prefix and the verbose
+ * gate so the prefix isn't typed out ~46× across the package and `verbose`
+ * doesn't need to be threaded into every constructor.
+ *
+ * Channel preservation:
+ * - `info`  → stdout (always),
+ * - `warn`  → stderr (always),
+ * - `error` → stderr (always),
+ * - `debug` → stdout (only when `verbose`),
+ * - `debugError` → stderr (only when `verbose`).
+ *
+ * `debugError` exists so verbose-only diagnostics that previously used
+ * `console.error` (e.g. HTTP response bodies on failure) keep going to stderr
+ * after the refactor.
+ */
+export declare class Logger {
+    private readonly verbose;
+    private readonly prefix;
+    constructor(verbose?: boolean);
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    debug(msg: string): void;
+    debugError(msg: string): void;
+}

package/dist/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+/**
+ * Tiny prefixed logger. Owns the `[Piwi Dashboard]` prefix and the verbose
+ * gate so the prefix isn't typed out ~46× across the package and `verbose`
+ * doesn't need to be threaded into every constructor.
+ *
+ * Channel preservation:
+ * - `info`  → stdout (always),
+ * - `warn`  → stderr (always),
+ * - `error` → stderr (always),
+ * - `debug` → stdout (only when `verbose`),
+ * - `debugError` → stderr (only when `verbose`).
+ *
+ * `debugError` exists so verbose-only diagnostics that previously used
+ * `console.error` (e.g. HTTP response bodies on failure) keep going to stderr
+ * after the refactor.
+ */
+class Logger {
+    constructor(verbose = false) {
+        this.verbose = verbose;
+        this.prefix = '[Piwi Dashboard] ';
+    }
+    info(msg) {
+        console.log(this.prefix + msg);
+    }
+    warn(msg) {
+        console.warn(this.prefix + msg);
+    }
+    error(msg) {
+        console.error(this.prefix + msg);
+    }
+    debug(msg) {
+        if (this.verbose)
+            console.log(this.prefix + msg);
+    }
+    debugError(msg) {
+        if (this.verbose)
+            console.error(this.prefix + msg);
+    }
+}
+exports.Logger = Logger;

package/dist/metadata-collector.d.ts

@@ -0,0 +1,32 @@
+import type { FullConfig, Suite, TestCase } from '@playwright/test/reporter';
+import { Logger } from './logger.js';
+import type { SuiteConfigEntry } from './types.js';
+/**
+ * Collects CI/CD environment metadata, SCM (git) information, and Playwright
+ * config metadata to attach to each test run submission.
+ *
+ * Also owns all reach-through access to Playwright-internal suite fields
+ * (`_parallelMode`, `_annotations`, `project()`) so the surface area that
+ * breaks when Playwright renames those internals is guarded behind one class.
+ */
+export declare class MetadataCollector {
+    private readonly logger;
+    constructor(logger?: Logger);
+    /** Collect all available metadata from the environment, config, and suite */
+    collect(config: FullConfig, suite: Suite, options: any): Record<string, unknown>;
+    /** Walk the test's parent hierarchy to extract the resolved browser/project configuration */
+    getBrowserConfig(test: TestCase): Record<string, any> | null;
+    /**
+     * Walk the test's parent `describe` suites to extract the suite path (titles)
+     * and per-level config (parallel mode + annotations). Reaches into Playwright
+     * suite internals (`_parallelMode`, `_annotations`) — kept here next to
+     * `getBrowserConfig` so all such access is guarded behind one class.
+     */
+    getSuiteInfo(test: TestCase): {
+        suitePath: string[];
+        suiteConfig: SuiteConfigEntry[];
+    };
+    private collectScmInfo;
+    private collectCiInfo;
+    private extractPlaywrightConfigMetadata;
+}