@testomatio/reporter 2.20.0 → 2.21.0

package/lib/adapter/codecept.js

@@ -23,7 +23,7 @@ if (!global.codeceptjs) {
     global.codeceptjs = codeceptjs_1.default;
 }
 // @ts-ignore
-const { event, recorder, codecept, output } = global.codeceptjs;
+const { event, recorder, codecept, output, container } = global.codeceptjs;
 const [, MAJOR_VERSION, MINOR_VERSION] = codecept
     .version()
     .match(/(\d+)\.(\d+)/)
@@ -52,6 +52,7 @@ function CodeceptReporter(config) {
     const reportTestPromises = [];
     let isRunFinalized = false;
     const testTimeMap = {};
+    const failedUrls = new Map();
     const clientConfig = buildCodeceptClientConfig(config);
     const client = new client_js_1.default(clientConfig);
     // Store original output methods for fallback
@@ -212,6 +213,24 @@ function CodeceptReporter(config) {
             await finalizeRun('all.after');
         }, true);
     });
+    event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+        // no browser in suite hooks
+        if (hookName === 'BeforeSuite' || hookName === 'AfterSuite')
+            return;
+        const helper = Object.values(container.helpers()).find(h => typeof h.grabCurrentUrl === 'function');
+        if (!helper)
+            return;
+        recorder.add('url of failed test', async () => {
+            try {
+                const url = await helper.grabCurrentUrl();
+                if (url)
+                    failedUrls.set(test.uid, url);
+            }
+            catch (err) {
+                debug('Failed to grab url of failed test', err?.message || err);
+            }
+        }, true);
+    });
     event.dispatcher.on(event.test.skipped, test => {
         const { uid, tags, title } = test.simplify();
         if (uid && reportedTestUids.has(uid))
@@ -240,6 +259,10 @@ function CodeceptReporter(config) {
         const keyValues = index_js_1.services.keyValues.get(test.fullTitle());
         const links = index_js_1.services.links.get(test.fullTitle());
         const screenshotOnFailPath = artifacts.screenshot || null;
+        const meta = { ...keyValues, ...test.meta };
+        if (test.state === constants_js_1.STATUS.FAILED && failedUrls.has(uid))
+            meta.failedUrl = failedUrls.get(uid);
+        failedUrls.delete(uid);
         // Build step hierarchy with screenshot from screenshotOnFail
         const stepHierarchy = buildUnifiedStepHierarchy(test.steps, hookSteps, screenshotOnFailPath);
         index_js_1.services.setContext(null);
@@ -256,7 +279,7 @@ function CodeceptReporter(config) {
             logs,
             links,
             manuallyAttachedArtifacts,
-            meta: { ...keyValues, ...test.meta },
+            meta,
         });
         reportTestPromises.push(reportTestPromise);
         processArtifactsForUpload(artifacts, uid, title, videos, traces);

package/lib/adapter/e2e.js

@@ -98,6 +98,9 @@ function toTestData(result, groups, artifactsRoot) {
         meta.retryCount = attempts.length - 1;
     if (result.status === 'flaky')
         meta.isFlaky = true;
+    const status = testStatus(result.status);
+    if (status === constants_js_1.STATUS.FAILED && final?.failure?.url)
+        meta.failedUrl = final.failure.url;
     const filesById = new Map();
     for (const artifact of final?.artifacts || []) {
         if (artifact.path) {
@@ -129,7 +132,7 @@ function toTestData(result, groups, artifactsRoot) {
         files: files.length ? files : undefined,
         meta,
     };
-    return { status: testStatus(result.status), data };
+    return { status, data };
 }
 /** Attempts of a result; a serial member keeps its part of the group's attempts. */
 function attemptsOf(result, groups) {
@@ -141,6 +144,7 @@ function attemptsOf(result, groups) {
         return {
             status: member?.status || attempt.status,
             error: member?.error || attempt.error,
+            failure: member?.failure || attempt.failure,
             steps: member?.steps || [],
             appLog: member?.appLog || [],
             skip: member?.skip,

package/lib/adapter/playwright.js

@@ -104,7 +104,11 @@ class PlaywrightReporter {
             if (result.status === 'passed')
                 status = 'failed';
         }
-        const reportTestPromise = this.client.addTestRun(checkStatus(status), {
+        const testStatus = checkStatus(status);
+        let failedUrl;
+        if (testStatus === constants_js_1.STATUS.FAILED)
+            failedUrl = lastNavigatedUrl(result.steps, test.parent.project().use.baseURL);
+        const reportTestPromise = this.client.addTestRun(testStatus, {
             rid: `${rid}-${project.name}`,
             error,
             test_id: (0, utils_js_1.getTestomatIdFromTestTitle)(`${title} ${tags.join(' ')}`),
@@ -122,6 +126,7 @@ class PlaywrightReporter {
                 isMobile: project.isMobile,
                 project: project.name,
                 projectDependencies: project.dependencies?.length ? project.dependencies : null,
+                failedUrl,
                 ...testMeta,
                 ...meta,
                 ...project.metadata, // metadata has any type (in playwright), but we will stringify it in client.js
@@ -222,6 +227,32 @@ function processArtifactsForUpload(attachments) {
 function isScreenshotArtifact(attachment) {
     return attachment?.contentType === 'image/png' && attachment?.name === 'screenshot';
 }
+/**
+ * Last url the test navigated to; the reporter has no access to the page itself.
+ * @returns {string|undefined}
+ */
+function lastNavigatedUrl(steps, baseURL) {
+    const url = findLastNavigation(steps);
+    if (!url)
+        return;
+    try {
+        return new URL(url, baseURL).href;
+    }
+    catch {
+        return url;
+    }
+}
+function findLastNavigation(steps = []) {
+    let url;
+    for (const step of steps) {
+        // 'Navigate to "url"' since Playwright 1.53, 'page.goto(url)' before
+        const match = step.title.match(/^Navigate to "(.+)"$/) || step.title.match(/^page\.goto\((.+)\)$/);
+        if (step.category === 'pw:api' && match)
+            url = match[1];
+        url = findLastNavigation(step.steps) || url;
+    }
+    return url;
+}
 function appendStep(step, shift = 0) {
     // nesting too deep, ignore those steps
     if (shift >= 10)

package/lib/adapter/vitest.js

@@ -394,7 +394,10 @@ function normalizeVitestTest(test) {
             file,
             suiteTitle,
             logs: '',
-            meta: typeof test.meta === 'function' ? test.meta() : {},
+            meta: {
+                ...(test.task?.meta || {}),
+                ...(typeof test.meta === 'function' ? test.meta() : test.meta || {}),
+            },
         };
     }
     return {

package/lib/adapter/webdriver.js

@@ -42,6 +42,8 @@ const utils_js_1 = require("../utils/utils.js");
 const index_js_1 = require("../services/index.js");
 const constants_js_1 = require("../constants.js");
 const data_storage_js_1 = require("../data-storage.js");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('@testomatio/reporter:adapter:webdriver');
 global.TESTOMATIO_ADAPTER = 'webdriverio';
 class WebdriverReporter extends reporter_1.default {
     constructor(options) {
@@ -130,13 +132,19 @@ class WebdriverReporter extends reporter_1.default {
     async addTest(test) {
         if (!this.client)
             return;
-        const { title, _duration: duration, state, error, output, links, artifacts, meta, logs } = test;
+        const { title, _duration: duration, state, error, output, links, artifacts, logs } = test;
+        let { meta } = test;
         const testId = (0, utils_js_1.getTestomatIdFromTestTitle)(title);
         const screenshotEndpoint = '/session/:sessionId/screenshot';
         const screenshotsBuffers = output
             .filter(el => el.endpoint === screenshotEndpoint && el.result && el.result.value)
             .map(el => Buffer.from(el.result.value, 'base64'));
         const rid = (0, data_storage_js_1.stringToMD5Hash)(test.fullTitle);
+        if (state === 'failed') {
+            const failedUrl = (await grabCurrentUrl()) || lastNavigatedUrl(output);
+            if (failedUrl)
+                meta = { ...meta, failedUrl };
+        }
         await this.client.addTestRun(state, {
             rid,
             manuallyAttachedArtifacts: test.artifacts,
@@ -153,7 +161,7 @@ class WebdriverReporter extends reporter_1.default {
     /**
      * @param {import('../../types/types.js').WebdriverIOScenario} scenario
      */
-    addBddScenario(scenario) {
+    async addBddScenario(scenario) {
         if (!this.client)
             return;
         const { title, _duration: duration } = scenario;
@@ -168,6 +176,12 @@ class WebdriverReporter extends reporter_1.default {
             .filter(Boolean);
         const error = errors.join('\n');
         const tags = scenario.tags.map(tag => tag.name);
+        let meta;
+        if (scenarioState === 'failed') {
+            const failedUrl = await grabCurrentUrl();
+            if (failedUrl)
+                meta = { failedUrl };
+        }
         return this.client.addTestRun(scenarioState, {
             error: error ? Error(error) : null,
             title,
@@ -175,10 +189,38 @@ class WebdriverReporter extends reporter_1.default {
             time: duration,
             tags,
             file: scenario.file,
+            meta,
             // filesBuffers: screenshotsBuffers,
         });
     }
 }
+/**
+ * Current url of the browser in this worker; reporters run in the worker process.
+ * @returns {Promise<string|undefined>}
+ */
+async function grabCurrentUrl() {
+    // @ts-ignore
+    const browser = globalThis.browser;
+    if (typeof browser?.getUrl !== 'function')
+        return;
+    try {
+        const url = await browser.getUrl();
+        // multiremote returns a url per browser
+        if (typeof url === 'string')
+            return url;
+    }
+    catch (err) {
+        debug('Failed to grab url of failed test', err?.message || err);
+    }
+}
+/**
+ * Last url opened by the test, taken from its command log.
+ * @returns {string|undefined}
+ */
+function lastNavigatedUrl(output = []) {
+    const navigations = output.filter(el => el.endpoint === '/session/:sessionId/url' && el.body?.url);
+    return navigations.at(-1)?.body.url;
+}
 /**
  *
  * @param {*} fullTestTitle

package/lib/bin/cli.js

@@ -13,6 +13,7 @@ const xmlReader_js_1 = __importDefault(require("../xmlReader.js"));
 const allureReader_js_1 = __importDefault(require("../allureReader.js"));
 const constants_js_1 = require("../constants.js");
 const utils_js_1 = require("../utils/utils.js");
+const detectRunner_js_1 = require("../utils/detectRunner.js");
 const config_js_1 = require("../config.js");
 const utils_js_2 = require("../utils/utils.js");
 const picocolors_1 = __importDefault(require("picocolors"));
@@ -23,6 +24,8 @@ const log_js_1 = require("../utils/log.js");
 const pipe_utils_js_1 = require("../utils/pipe_utils.js");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const testruns_js_1 = require("../fetch/testruns.js");
+const report_js_1 = require("../fetch/report.js");
 const debug = (0, debug_1.default)('@testomatio/reporter:cli');
 const version = (0, utils_js_1.getPackageVersion)();
 const program = new commander_1.Command();
@@ -43,8 +46,13 @@ program
     // remaining output to stderr, skip the banner, and silence info-level logs so
     // stdout stays clean for capture (e.g. RUN_ID=$(... start --format id)).
     // Set TESTOMATIO_LOG_LEVEL=INFO to re-enable progress logs for debugging.
-    const subOpts = actionCommand.opts();
-    if (subOpts.filterList || subOpts.format) {
+    const subOpts = actionCommand.optsWithGlobals();
+    // fetch status|count|report print their result on stdout, so the rest goes to stderr too
+    const isFetchSubcommand = actionCommand.parent?.name() === 'fetch';
+    if (isFetchSubcommand && !subOpts.format) {
+        process.env.TESTOMATIO_LOG_STDERR = '1';
+    }
+    else if (subOpts.filterList || subOpts.format) {
         process.env.TESTOMATIO_LOG_STDERR = '1';
         process.env.TESTOMATIO_LOG_LEVEL ||= 'WARN';
         // with --format json the logs are machine-readable too: one JSON object per line on stderr
@@ -61,9 +69,10 @@ program
     .option('--kind <type>', 'Specify run type: automated, manual, mixed, or detect')
     .option('--filter <filter>', 'Scope the prepared run to tests matching the filter (no execution)')
     .option('--format <format>', 'Machine-readable output: the run id (--format id) or run details (--format json)')
-    .option('--warn', 'Exit 0 instead of 1 when the filter matches no tests (warn only)')
+    .option('--warn', 'Exit 0 instead of 1 when the filter matches no tests (warn only); env: TESTOMATIO_WARN')
     .action(async (opts) => {
     (0, utils_js_1.cleanLatestRunId)();
+    opts.warn ||= (0, utils_js_1.transformEnvVarToBoolean)(process.env.TESTOMATIO_WARN);
     log_js_1.log.info('Starting a new Run on Testomat.io...');
     const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config_js_1.config.TESTOMATIO;
     const client = new client_js_1.default({ apiKey });
@@ -118,7 +127,7 @@ program
         process.exit(0);
     });
 });
-program
+const fetchCommand = program
     .command('fetch')
     .description('Fetch runs from Testomat.io API v2')
     .argument('[url]', 'URL of a run or of a (filtered) runs page in Testomat.io')
@@ -127,7 +136,8 @@ program
     .option('--title <text>', 'Filter by run title')
     .option('--tql <query>', 'Filter using Testomat Query Language')
     .option('--rungroup <uid>', 'Filter by rungroup id')
-    .option('--limit <number>', `Max number of runs to return (max ${FETCH_RUNS_MAX_LIMIT})`, String(FETCH_RUNS_DEFAULT_LIMIT))
+    // no default value: fetch parses --limit for its subcommands too, see createRunFetcher
+    .option('--limit <number>', `Max number of runs to return (default ${FETCH_RUNS_DEFAULT_LIMIT}, max ${FETCH_RUNS_MAX_LIMIT})`)
     .option('--latest', 'Only fetch the most recent run (shorthand for --limit 1)')
     .option('--format <format>', 'Machine-readable output: run ids, one per line (--format id) or run details (--format json)')
     .action(async (pageUrl, opts) => {
@@ -177,6 +187,141 @@ program
     }
     console.log((0, pipe_utils_js_1.formatFetchRunsOutput)(body, opts.format));
 });
+// fetch parses the options it shares with its subcommands (--project, --format, --limit) wherever they are placed,
+// so subcommands declare them only for help and read them with optsWithGlobals()
+/**
+ * Build a RunFetcher for the run argument of fetch status|count|report, or exit with an error.
+ *
+ * @param {string} runArg
+ * @param {{project?: string}} opts
+ * @returns {RunFetcher}
+ */
+function createRunFetcher(runArg, opts) {
+    const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config_js_1.config.TESTOMATIO;
+    if (!apiKey) {
+        log_js_1.log.error(picocolors_1.default.red('⚠️  TESTOMATIO API key required'));
+        process.exit(1);
+    }
+    try {
+        return new testruns_js_1.RunFetcher({ ...(0, testruns_js_1.resolveRunTarget)(runArg, opts), apiKey });
+    }
+    catch (err) {
+        log_js_1.log.error(picocolors_1.default.red(`⚠️  ${err.message}`));
+        process.exit(1);
+    }
+}
+/**
+ * @param {{only?: string, onlyFailed?: boolean}} opts
+ * @returns {string[]}
+ */
+function getStatusFilter(opts) {
+    try {
+        return (0, testruns_js_1.parseStatuses)(opts);
+    }
+    catch (err) {
+        log_js_1.log.error(picocolors_1.default.red(`⚠️  ${err.message}`));
+        process.exit(1);
+    }
+}
+/**
+ * @param {Error} err
+ * @returns {never}
+ */
+function exitOnFetchError(err) {
+    log_js_1.log.error(picocolors_1.default.red(`⚠️  Failed to fetch: ${err.message}`));
+    process.exit(1);
+}
+const RUN_ARGUMENT_DESCRIPTION = 'Run id, or URL of a run in Testomat.io';
+const STATUS_FILTER_DESCRIPTION = `Only testruns with these statuses, comma-separated (${testruns_js_1.TESTRUN_STATUSES.join(', ')})`;
+fetchCommand
+    .command('status')
+    .description('Show a run with the number of its testruns by status')
+    .argument('<run>', RUN_ARGUMENT_DESCRIPTION)
+    .option('--project <slug>', 'Project slug (or set TESTOMATIO_PROJECT)')
+    .option('--format <format>', 'Machine-readable output: run status and counts as JSON (--format json)')
+    .action(async (runArg, _opts, command) => {
+    const opts = command.optsWithGlobals();
+    const fetcher = createRunFetcher(runArg, opts);
+    const [run, summary] = await Promise.all([fetcher.fetchRun(), fetcher.countTestrunsByStatus()]).catch(exitOnFetchError);
+    const counts = Object.fromEntries(testruns_js_1.TESTRUN_STATUSES.map(status => [status, summary.byStatus[status] || 0]));
+    if (opts.format === 'json') {
+        const data = { id: run.id, title: run.title, status: run.status, url: fetcher.runUrl, total: summary.total };
+        console.log(JSON.stringify({ ...data, ...counts }, null, 2));
+        return;
+    }
+    const lines = [`run: ${run.title}`, `status: ${run.status}`, `url: ${fetcher.runUrl}`, `total: ${summary.total}`];
+    for (const [status, count] of Object.entries(counts))
+        lines.push(`${status}: ${count}`);
+    console.log(lines.join('\n'));
+});
+fetchCommand
+    .command('count')
+    .description('Print the number of testruns of a run, to pick --limit and filters for fetch report')
+    .argument('<run>', RUN_ARGUMENT_DESCRIPTION)
+    .option('--project <slug>', 'Project slug (or set TESTOMATIO_PROJECT)')
+    .option('--only <statuses>', STATUS_FILTER_DESCRIPTION)
+    .option('--only-failed', 'Only failed testruns (shorthand for --only failed)')
+    .action(async (runArg, _opts, command) => {
+    const opts = command.optsWithGlobals();
+    const fetcher = createRunFetcher(runArg, opts);
+    const statuses = getStatusFilter(opts);
+    const total = await fetcher.countTestruns(statuses).catch(exitOnFetchError);
+    console.log(total);
+});
+fetchCommand
+    .command('report')
+    .description('Print a run with its testruns as a Markdown report')
+    .argument('<run>', RUN_ARGUMENT_DESCRIPTION)
+    .option('--project <slug>', 'Project slug (or set TESTOMATIO_PROJECT)')
+    .option('--only <statuses>', STATUS_FILTER_DESCRIPTION)
+    .option('--only-failed', 'Only failed testruns (shorthand for --only failed)')
+    .option('--stack', 'Include stack traces')
+    .option('--artifacts', 'Download artifacts to --out and link them from the report')
+    .option('--out <dir>', 'Directory for downloaded artifacts (default: ./<run-title>-<run-id>)')
+    .option('--limit <number>', `Max number of testruns, failed first (default ${testruns_js_1.TESTRUNS_DEFAULT_LIMIT}, max ${testruns_js_1.TESTRUNS_MAX_LIMIT})`)
+    .action(async (runArg, _opts, command) => {
+    const opts = command.optsWithGlobals();
+    const fetcher = createRunFetcher(runArg, opts);
+    const statuses = getStatusFilter(opts);
+    const { limit, capped } = (0, testruns_js_1.parseTestrunsLimit)(opts.limit);
+    if (capped)
+        log_js_1.log.warn(picocolors_1.default.yellow(`⚠️  --limit is capped at ${testruns_js_1.TESTRUNS_MAX_LIMIT}`));
+    const run = await fetcher.fetchRun().catch(exitOnFetchError);
+    if (opts.artifacts) {
+        const hasSharedCredentials = await fetcher.applySharedS3Credentials(run);
+        if (!hasSharedCredentials && !process.env.S3_BUCKET) {
+            log_js_1.log.error(picocolors_1.default.red('⚠️  --artifacts needs S3 access: share S3 credentials in project settings or set S3_BUCKET'));
+            process.exit(1);
+        }
+    }
+    const [summary, list] = await Promise.all([
+        fetcher.countTestrunsByStatus(),
+        fetcher.listTestruns({ statuses, limit }),
+    ]).catch(exitOnFetchError);
+    let { testruns } = list;
+    if (list.total > testruns.length) {
+        log_js_1.log.warn(picocolors_1.default.yellow(`⚠️  Showing ${testruns.length} of ${list.total} testruns. Use --limit or --only-failed to narrow it.`));
+    }
+    if (opts.stack || opts.artifacts) {
+        testruns = await fetcher.addTestrunDetails(testruns, (testrun, err) => {
+            log_js_1.log.warn(picocolors_1.default.yellow(`⚠️  Failed to fetch details of testrun ${testrun.id}: ${err.message}`));
+        });
+        if (!opts.stack)
+            testruns = testruns.map(({ stack, ...testrun }) => testrun);
+    }
+    if (opts.artifacts) {
+        const outDir = opts.out || (0, testruns_js_1.defaultArtifactsDir)(run, fetcher.runId);
+        const artifactsCount = testruns.reduce((sum, testrun) => sum + (testrun.artifacts?.length || 0), 0);
+        log_js_1.log.info(`Downloading ${artifactsCount} artifacts to ${outDir}`);
+        testruns = await (0, testruns_js_1.downloadArtifacts)(testruns, outDir, (url, err) => {
+            log_js_1.log.warn(picocolors_1.default.yellow(`⚠️  Failed to download ${url}: ${err.message}`));
+        });
+    }
+    else {
+        testruns = testruns.map(({ artifacts, ...testrun }) => testrun);
+    }
+    process.stdout.write((0, report_js_1.renderRunReport)({ run, runUrl: fetcher.runUrl, summary, testruns, matched: list.total, statuses }));
+});
 program
     .command('run')
     .alias('test')
@@ -188,8 +333,9 @@ program
     .option('--kind <type>', 'Specify run type: automated, manual, mixed, or detect')
     .option('--remote <profile>', 'Trigger run on the named Testomat.io CI profile instead of executing locally')
     .option('--remote-param <kv>', 'key=value pair forwarded to the CI profile config (repeat for multiple)', (value, prev) => prev.concat([value]), [])
-    .option('--warn', 'Exit 0 instead of 1 when the filter matches no tests (warn only)')
+    .option('--warn', 'Exit 0 instead of 1 when the filter matches no tests (warn only); env: TESTOMATIO_WARN')
     .action(async (command, opts) => {
+    opts.warn ||= (0, utils_js_1.transformEnvVarToBoolean)(process.env.TESTOMATIO_WARN);
     if (opts.remote) {
         if (opts.filterList) {
             log_js_1.log.warn(picocolors_1.default.red('⚠️  --filter-list cannot be combined with --remote'));
@@ -203,6 +349,7 @@ program
     const apiKey = process.env['INPUT_TESTOMATIO-KEY'] || config_js_1.config.TESTOMATIO;
     const title = process.env.TESTOMATIO_TITLE;
     const client = new client_js_1.default({ apiKey, title });
+    let filterApplied = false;
     if (opts.filter || opts.filterList) {
         log_js_1.log.info('Filtering tests...');
         // Example of use: npx @testomatio/reporter run "npx jest" --filter "testomatio:tag-name=frontend"
@@ -237,6 +384,7 @@ program
             }
             if (command && command.split && !opts.remote) {
                 command = (0, utils_js_1.applyFilter)(command, tests);
+                filterApplied = true;
             }
         }
         catch (err) {
@@ -310,6 +458,13 @@ program
         }
         return process.exit(0);
     }
+    if ((0, detectRunner_js_1.isPlaceholderCommand)(command)) {
+        log_js_1.log.error(picocolors_1.default.red(`⚠️  The command "${command}" looks like a placeholder.`));
+        log_js_1.log.error('The example command from Testomat.io must be edited:');
+        log_js_1.log.error('replace the placeholder with your actual test runner command.');
+        log_js_1.log.error((0, detectRunner_js_1.runnerHint)());
+        process.exit(1);
+    }
     log_js_1.log.info(`🚀 Running`, picocolors_1.default.green(command));
     const runTests = async () => {
         const testCmds = command.split(' ');
@@ -317,9 +472,28 @@ program
             stdio: 'inherit',
             env: { ...process.env, TESTOMATIO_PROCEED: 'true', runId: client.runId, TESTOMATIO_RUN: client.runId },
         });
+        let errored = false;
+        cmd.on('error', err => {
+            errored = true;
+            const spawnError = /** @type {NodeJS.ErrnoException} */ (err);
+            if (spawnError.code === 'ENOENT') {
+                log_js_1.log.error(picocolors_1.default.red(`🔴 Command not found: ${picocolors_1.default.bold(testCmds[0])}`));
+                log_js_1.log.error((0, detectRunner_js_1.runnerHint)());
+            }
+            else {
+                log_js_1.log.error(picocolors_1.default.red(`🔴 Failed to start command: ${spawnError.message}`));
+            }
+            const finish = apiKey ? client.updateRunStatus('failed').catch(() => { }) : Promise.resolve();
+            finish.then(() => process.exit(1));
+        });
         cmd.on('close', async (code) => {
+            if (errored)
+                return;
             const emoji = code === 0 ? '🟢' : '🔴';
             log_js_1.log.info(emoji, `Runner exited with ${picocolors_1.default.bold(code)}`);
+            if (code !== 0 && filterApplied) {
+                (0, detectRunner_js_1.buildFilterWarning)(command).forEach(line => log_js_1.log.warn(line));
+            }
             if (apiKey) {
                 const status = code === 0 ? 'passed' : 'failed';
                 await client.updateRunStatus(status);

package/lib/fetch/report.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Render a fetched run with its testruns as a Markdown report.
+ *
+ * @param {object} params
+ * @param {object} params.run - Run from GET /api/v2/:project/runs/:id
+ * @param {string} params.runUrl
+ * @param {{total: number, byStatus: Record<string, number>}} params.summary - Counts of all testruns of the run
+ * @param {object[]} params.testruns
+ * @param {number} params.matched - Number of testruns matching the filter
+ * @param {string[]} params.statuses - Status filter, empty for all testruns
+ * @returns {string}
+ */
+export function renderRunReport({ run, runUrl, summary, testruns, matched, statuses }: {
+    run: object;
+    runUrl: string;
+    summary: {
+        total: number;
+        byStatus: Record<string, number>;
+    };
+    testruns: object[];
+    matched: number;
+    statuses: string[];
+}): string;
+/**
+ * Map a testrun of API v2 to the test shape of the Markdown pipe.
+ * Without a suite, the API returns the title as "<suite> ⇒ <title>".
+ *
+ * @param {object} testrun
+ * @returns {object}
+ */
+export function toReportTest(testrun: object): object;

package/lib/fetch/report.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRunReport = renderRunReport;
+exports.toReportTest = toReportTest;
+const markdown_js_1 = require("../pipe/markdown.js");
+const TITLE_SEPARATOR = ' ⇒ ';
+/**
+ * Map a testrun of API v2 to the test shape of the Markdown pipe.
+ * Without a suite, the API returns the title as "<suite> ⇒ <title>".
+ *
+ * @param {object} testrun
+ * @returns {object}
+ */
+function toReportTest(testrun) {
+    let title = String(testrun.test_title || '').trim();
+    let suite = testrun.suiteTitle;
+    if (!suite && title.includes(TITLE_SEPARATOR)) {
+        const [suitePart, ...titleParts] = title.split(TITLE_SEPARATOR);
+        suite = suitePart.trim();
+        title = titleParts.join(TITLE_SEPARATOR).trim();
+    }
+    return {
+        title,
+        suite_title: suite,
+        status: testrun.status,
+        run_time: testrun.run_time,
+        test_id: testrun.testId,
+        message: testrun.message,
+        stack: testrun.stack,
+        artifacts: testrun.artifacts,
+    };
+}
+/**
+ * Render a fetched run with its testruns as a Markdown report.
+ *
+ * @param {object} params
+ * @param {object} params.run - Run from GET /api/v2/:project/runs/:id
+ * @param {string} params.runUrl
+ * @param {{total: number, byStatus: Record<string, number>}} params.summary - Counts of all testruns of the run
+ * @param {object[]} params.testruns
+ * @param {number} params.matched - Number of testruns matching the filter
+ * @param {string[]} params.statuses - Status filter, empty for all testruns
+ * @returns {string}
+ */
+function renderRunReport({ run, runUrl, summary, testruns, matched, statuses }) {
+    const status = String(run.status || 'unknown');
+    const sections = [`# ${run.title || run.id} — ${status.toUpperCase()}`];
+    const rows = [
+        ['Run ID', `\`${run.id}\``],
+        ['Run URL', `<${runUrl}>`],
+        ['Status', status],
+    ];
+    if (run.env)
+        rows.push(['Environment', run.env]);
+    if (run.launched_at)
+        rows.push(['Started', run.launched_at]);
+    if (run.finished_at)
+        rows.push(['Finished', run.finished_at]);
+    let shown = `${testruns.length} of ${matched} shown`;
+    if (statuses.length)
+        shown += ` (only: ${statuses.join(', ')})`;
+    rows.push(['Testruns', shown]);
+    sections.push(['| Key | Value |', '| --- | ----- |', ...rows.map(([key, value]) => `| ${key} | ${value} |`)].join('\n'));
+    if (run.description?.trim())
+        sections.push(`## Description\n\n${run.description.trim()}`);
+    const counts = Object.entries(summary.byStatus).sort(([, a], [, b]) => b - a);
+    sections.push([
+        '## Summary',
+        '',
+        '| Status | Count |',
+        '| ------ | ----- |',
+        ...counts.map(([name, count]) => `| ${name} | ${count} |`),
+        `| total | ${summary.total} |`,
+    ].join('\n'));
+    sections.push((0, markdown_js_1.renderTests)(testruns.map(toReportTest)));
+    return `${sections.join('\n\n')}\n`;
+}
+
+module.exports.renderRunReport = renderRunReport;
+
+module.exports.toReportTest = toReportTest;