@testomatio/reporter 2.9.3-beta.4-allure-links → 2.9.4

package/README.md

@@ -76,7 +76,6 @@ npx testomatio-reporter <command> [options]
 | [TestCafe](./docs/frameworks.md#testcafe)       | [Detox](./docs/frameworks.md#detox)           | [Codeception](https://github.com/testomatio/php-reporter) |
 | [Newman (Postman)](./docs/frameworks.md#newman) | [JUnit](./docs/junit.md#junit)                | [NUnit](./docs/junit.md#nunit)                            |
 | [PyTest](./docs/junit.md#pytest)                | [PHPUnit](./docs/junit.md#phpunit)            | [Protractor](./docs/frameworks.md#protractor)             |
-| [Allure](./docs/allure.md)                      |                                               |                                                           |
 
 or **any [other via JUnit](./docs/junit.md)** report....
 
@@ -138,10 +137,9 @@ Bring this reporter on CI and never lose test results again!
   - [HTML report](./docs/pipes/html.md)
   - [Markdown report](./docs/pipes/markdown.md)
   - [Bitbucket](./docs/pipes/bitbucket.md)
-- 📓 [JUnit Reports](./docs/junit.md)
-- 🗄️ [Artifacts](./docs/artifacts.md)
-- 🔬 [Allure Reports](./docs/allure.md)
 - 🔗 [Linking Tests](./docs/linking-tests.md)
+- 📓 [JUnit](./docs/junit.md)
+- 🗄️ [Artifacts](./docs/artifacts.md)
 - 🔂 [Workflows](./docs/workflows.md)
 - 🖊️ [Logger](./docs/logger.md)
 - 🪲 [Debug File Format](./docs/debug-file-format.md)

package/lib/adapter/codecept.js

@@ -135,20 +135,36 @@ function CodeceptReporter(config) {
     });
     // mark as failed all tests inside the failed hook
     event.dispatcher.on(event.hook.failed, hook => {
-        if (hook.name !== 'BeforeSuiteHook' && hook.name !== 'BeforeHook')
-            return;
-        const suite = hook.runnable.parent;
-        if (!suite)
-            return;
-        const error = hook?.ctx?.currentTest?.err;
-        for (const test of suite.tests) {
-            reportedTestUids.add(test.uid);
+        const error = hook?.ctx?.currentTest?.err || hook?.err;
+        // Handle BeforeSuite and Before hooks: mark all tests in suite as failed
+        if (hook.name === 'BeforeSuiteHook' || hook.name === 'BeforeHook') {
+            const suite = hook.runnable.parent;
+            if (!suite)
+                return;
+            for (const test of suite.tests) {
+                reportedTestUids.add(test.uid);
+                const reportTestPromise = client.addTestRun('failed', {
+                    ...stripExampleFromTitle(test.title),
+                    rid: test.uid,
+                    test_id: (0, utils_js_1.getTestomatIdFromTestTitle)(test.title),
+                    suite_title: stripTagsFromTitle(suite.title),
+                    error,
+                    time: hook?.runnable?.duration,
+                });
+                reportTestPromises.push(reportTestPromise);
+            }
+        }
+        if (hook.name === 'AfterSuiteHook') {
+            const suite = hook.runnable?.parent || hook.suite;
+            const suiteTitle = suite ? stripTagsFromTitle(suite.title) : 'Unknown Suite';
+            const stepHierarchy = buildUnifiedStepHierarchy(null, hookSteps);
+            // Report the hook failure as a separate test entry
             const reportTestPromise = client.addTestRun('failed', {
-                ...stripExampleFromTitle(test.title),
-                rid: test.uid,
-                test_id: (0, utils_js_1.getTestomatIdFromTestTitle)(test.title),
-                suite_title: stripTagsFromTitle(suite.title),
+                title: 'AfterSuite Hook',
+                suite_title: suiteTitle,
                 error,
+                message: error?.message || 'AfterSuite hook failed',
+                steps: stepHierarchy,
                 time: hook?.runnable?.duration,
             });
             reportTestPromises.push(reportTestPromise);
@@ -169,8 +185,10 @@ function CodeceptReporter(config) {
         testTimeMap[test.uid] = Date.now();
     });
     event.dispatcher.on(event.all.after, () => {
-        recorder.add('Finishing run', async () => {
-            await finalizeRun('all.after');
+        setImmediate(() => {
+            finalizeRun('all.after').catch(err => {
+                debug('Error finalizing run:', err);
+            });
         });
     });
     event.dispatcher.on(event.test.skipped, test => {
@@ -237,6 +255,7 @@ async function uploadAttachments(client, attachments, messagePrefix, attachmentT
     if (client.uploader.isEnabled) {
         log_js_1.log.info(`Attachments: ${messagePrefix} ${attachments.length} ${attachmentType} ...`);
     }
+    await Promise.all(client.pipes?.map(pipe => pipe.addArtifacts?.(attachments)) || []);
     const promises = attachments.map(async (attachment) => {
         const { rid, title, path, type } = attachment;
         const file = { path, type, title };

package/lib/adapter/playwright.js

@@ -51,13 +51,8 @@ class PlaywrightReporter {
         const { title } = test;
         const { error, duration } = result;
         const pwAttachments = (result.attachments || []).filter(a => a.body || a.path);
-        const files = pwAttachments
-            .map(att => ({
-            path: this.#getArtifactPath(att),
-            title: att.name || title,
-            type: att.contentType,
-        }))
-            .filter(f => f.path);
+        const files = buildArtifactFiles(pwAttachments, attachment => this.#getArtifactPath(attachment), title);
+        const artifactsForUpload = processArtifactsForUpload(pwAttachments);
         const suite_title = test.parent ? test.parent?.title : path_1.default.basename(test?.location?.file);
         const rid = test.id || test.testId || (0, uuid_1.v4)();
         /**
@@ -144,7 +139,7 @@ class PlaywrightReporter {
         this.uploads.push({
             rid: `${rid}-${project.name}`,
             title: test.title,
-            files: pwAttachments,
+            files: artifactsForUpload,
             file: test.location?.file,
         });
         // remove empty uploads
@@ -210,6 +205,22 @@ function checkStatus(status) {
         passed: constants_js_1.STATUS.PASSED,
     }[status] || constants_js_1.STATUS.FAILED);
 }
+function buildArtifactFiles(attachments, getArtifactPath, title) {
+    return attachments
+        .filter(isScreenshotArtifact)
+        .map(attachment => ({
+        path: getArtifactPath(attachment),
+        title: attachment.name || title,
+        type: attachment.contentType,
+    }))
+        .filter(file => file.path);
+}
+function processArtifactsForUpload(attachments) {
+    return attachments.filter(attachment => !isScreenshotArtifact(attachment));
+}
+function isScreenshotArtifact(attachment) {
+    return attachment?.contentType === 'image/png' && attachment?.name === 'screenshot';
+}
 function appendStep(step, shift = 0) {
     // nesting too deep, ignore those steps
     if (shift >= 10)

package/lib/bin/cli.js

@@ -10,7 +10,6 @@ const glob_1 = require("glob");
 const debug_1 = __importDefault(require("debug"));
 const client_js_1 = __importDefault(require("../client.js"));
 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 config_js_1 = require("../config.js");
@@ -21,6 +20,8 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const replay_js_1 = __importDefault(require("../replay.js"));
 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 debug = (0, debug_1.default)('@testomatio/reporter:cli');
 const version = (0, utils_js_1.getPackageVersion)();
 const program = new commander_1.Command();
@@ -319,44 +320,54 @@ program
     if (timeoutTimer)
         clearTimeout(timeoutTimer);
 });
-program
-    .command('allure')
-    .description('Parse Allure result files and upload to Testomat.io')
-    .argument('<pattern>', 'Allure result directory pattern')
-    .option('-d, --dir <dir>', 'Project directory')
-    .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
-    .option('--with-package', 'Keep full package path in file names (default: strip package prefix)')
-    .option('--java-tests [path]', 'Path to test sources; links cases from @TmsLink in source for skipped tests (default: src/test)')
-    .option('--lang <lang>', 'Language used (java, kotlin, ...)')
-    .action(async (pattern, opts) => {
-    let javaTests = opts.javaTests;
-    if (javaTests === true)
-        javaTests = 'src/test';
-    const runReader = new allureReader_js_1.default({ withPackage: opts.withPackage, javaTests, lang: opts.lang });
-    let timeoutTimer;
-    if (opts.timelimit) {
-        timeoutTimer = setTimeout(() => {
-            console.log(`⚠️  Reached timeout of ${opts.timelimit}s. Exiting... (Exit code is 0 to not fail the pipeline)`);
-            process.exit(0);
-        }, parseInt(opts.timelimit, 10) * 1000);
-    }
-    try {
-        await runReader.parse(pattern);
-        await runReader.createRun();
-        await runReader.uploadData();
-    }
-    catch (err) {
-        console.log(constants_js_1.APP_PREFIX, 'Error uploading Allure results:', err);
-    }
-    if (timeoutTimer)
-        clearTimeout(timeoutTimer);
-});
 program
     .command('upload-artifacts')
     .description('Upload artifacts to Testomat.io')
+    .argument('[jsonl-file]', 'Path to JSONL debug file (optional)')
     .option('--force', 'Re-upload artifacts even if they were uploaded before')
-    .action(async (opts) => {
+    .action(async (jsonlFile, opts) => {
     const apiKey = config_js_1.config.TESTOMATIO;
+    // JSONL file mode: upload artifacts from debug file
+    if (jsonlFile) {
+        if (!fs_1.default.existsSync(jsonlFile)) {
+            log_js_1.log.error(`JSONL file not found: ${jsonlFile}`);
+            return process.exit(1);
+        }
+        const replay = new replay_js_1.default({ apiKey });
+        const { tests, runId } = replay.parseDebugFile(jsonlFile);
+        if (!runId) {
+            log_js_1.log.error('runId not found in JSONL file');
+            return process.exit(1);
+        }
+        log_js_1.log.info(`Processing ${tests.length} tests from ${jsonlFile}`);
+        const client = new client_js_1.default({
+            apiKey,
+            runId,
+            batchMode: constants_js_1.BATCH_MODE.DISABLED,
+        });
+        await client.createRun();
+        client.uploader.checkEnabled();
+        client.uploader.disableLogStorage();
+        let uploadedCount = 0;
+        let failedCount = 0;
+        for (const test of tests) {
+            if (!hasExistingArtifacts(test))
+                continue;
+            try {
+                await client.addTestRun(undefined, { ...test, overwrite: true });
+                uploadedCount++;
+            }
+            catch (e) {
+                log_js_1.log.error(`Failed ${test.test_id || test.rid || test.title}: ${e.message}`);
+                failedCount++;
+            }
+        }
+        log_js_1.log.info(`🗄️ ${uploadedCount} tests with artifacts uploaded`);
+        if (failedCount > 0) {
+            log_js_1.log.warn(`⚠️ ${failedCount} tests failed to upload artifacts`);
+        }
+        return;
+    }
     process.env.TESTOMATIO_DISABLE_ARTIFACTS = '';
     const runId = process.env.TESTOMATIO_RUN || process.env.runId || (0, utils_js_2.readLatestRunId)();
     if (!runId) {
@@ -459,6 +470,29 @@ program
         process.exit(1);
     }
 });
+function hasExistingArtifacts(test) {
+    const hasExistingFile = items => {
+        for (const item of items || []) {
+            const artifactPath = typeof item === 'object' ? item?.path : item;
+            if (artifactPath && fs_1.default.existsSync(artifactPath))
+                return true;
+        }
+        return false;
+    };
+    if (hasExistingFile(test.files))
+        return true;
+    const stack = [...(test.steps || [])];
+    while (stack.length) {
+        const step = stack.pop();
+        if (!step)
+            continue;
+        if (hasExistingFile(step.artifacts))
+            return true;
+        if (Array.isArray(step.steps))
+            stack.push(...step.steps);
+    }
+    return false;
+}
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
     program.outputHelp();

package/lib/client.js

@@ -148,10 +148,11 @@ class Client {
                 }
                 const uploadedArtifacts = [];
                 for (const artifact of step.artifacts) {
-                    if (typeof artifact === 'string' && !(0, utils_js_1.isHttpUrl)(artifact)) {
-                        const filename = (0, step_formatter_js_1.generateShortFilename)(artifact);
+                    const artifactPath = typeof artifact === 'object' ? artifact?.path : artifact;
+                    if (typeof artifactPath === 'string' && !(0, utils_js_1.isHttpUrl)(artifactPath)) {
+                        const filename = (0, step_formatter_js_1.generateShortFilename)(artifactPath);
                         try {
-                            const uploadResult = await this.uploader.uploadFileByPath(artifact, [this.runId, testRid, 'steps', filename]);
+                            const uploadResult = await this.uploader.uploadFileByPath(artifactPath, [this.runId, testRid, 'steps', filename]);
                             if (uploadResult) {
                                 uploadedArtifacts.push(uploadResult);
                             }

package/lib/junit-adapter/index.js

@@ -9,7 +9,6 @@ const java_js_1 = __importDefault(require("./java.js"));
 const python_js_1 = __importDefault(require("./python.js"));
 const ruby_js_1 = __importDefault(require("./ruby.js"));
 const csharp_js_1 = __importDefault(require("./csharp.js"));
-const kotlin_js_1 = __importDefault(require("./kotlin.js"));
 function AdapterFactory(lang, opts) {
     if (lang === 'java') {
         return new java_js_1.default(opts);
@@ -26,9 +25,6 @@ function AdapterFactory(lang, opts) {
     if (lang === 'c#' || lang === 'csharp') {
         return new csharp_js_1.default(opts);
     }
-    if (lang === 'kotlin') {
-        return new kotlin_js_1.default(opts);
-    }
     return new adapter_js_1.default(opts);
 }
 module.exports = AdapterFactory;

package/lib/pipe/debug.d.ts

@@ -22,6 +22,12 @@ export class DebugPipe {
     createRun(params?: {}): Promise<void>;
     addTest(data: any): Promise<void>;
     finishRun(params: any): Promise<void>;
+    /**
+     * Logs artifacts data to the debug file.
+     * Used for trace.zip, video files and other artifacts uploaded after tests finish.
+     * @param {Array} artifacts - Array of artifacts with { rid, title, path, type }
+     */
+    addArtifacts(artifacts: any[]): void;
     sync(): Promise<void>;
     /**
      * Writes any buffered tests to the debug file as a single batch.

package/lib/pipe/debug.js

@@ -109,6 +109,17 @@ class DebugPipe {
         log_js_1.log.info(`🪲 Debug file: ${this.rootPath}`);
         log_js_1.log.info(`History: ${this.historyDir}`);
     }
+    /**
+     * Logs artifacts data to the debug file.
+     * Used for trace.zip, video files and other artifacts uploaded after tests finish.
+     * @param {Array} artifacts - Array of artifacts with { rid, title, path, type }
+     */
+    addArtifacts(artifacts) {
+        if (!this.isEnabled || !artifacts?.length)
+            return;
+        const logData = { action: 'addArtifacts', artifacts, runId: this.store.runId };
+        this.logToFile(logData);
+    }
     async sync() {
         this.flushBufferedTests();
     }

package/lib/pipe/html.d.ts

@@ -6,6 +6,7 @@ declare class HtmlPipe {
     description: any;
     apiKey: any;
     isHtml: any;
+    htmlCopyArtifacts: any;
     isEnabled: boolean;
     htmlOutputPath: string;
     filenameMsg: string;

package/lib/pipe/html.js

@@ -15,6 +15,7 @@ const utils_js_1 = require("../utils/utils.js");
 const constants_js_1 = require("../constants.js");
 const node_url_1 = require("node:url");
 const debug = (0, debug_1.default)('@testomatio/reporter:pipe:html');
+const HTML_ARTIFACTS_DIR = 'artifacts';
 // @ts-ignore – this line will be removed in compiled code (already defined in the global scope of commonjs)
 class HtmlPipe {
     constructor(params, store = {}) {
@@ -23,6 +24,7 @@ class HtmlPipe {
         this.description = params.description || process.env.TESTOMATIO_DESCRIPTION;
         this.apiKey = params.apiKey || process.env.TESTOMATIO;
         this.isHtml = params.html ?? process.env.TESTOMATIO_HTML_REPORT_SAVE;
+        this.htmlCopyArtifacts = params.htmlCopyArtifacts;
         debug('HTML Pipe: ', this.apiKey ? 'API KEY' : '*no api key provided*');
         this.isEnabled = false;
         this.htmlOutputPath = '';
@@ -124,6 +126,8 @@ class HtmlPipe {
             console.log(picocolors_1.default.blue(msg));
         }
         const aggregatedTests = aggregateTestRetries(tests);
+        const copyLocalArtifacts = resolveHtmlCopyArtifacts(this.htmlCopyArtifacts);
+        const portableArtifacts = new Map();
         aggregatedTests.forEach(test => {
             const logsRaw = test.logs || test.meta?.logs || test.meta?.console || test.meta?.stdout || test.meta?.stderr || '';
             const stackRaw = test.stack || '';
@@ -180,7 +184,11 @@ class HtmlPipe {
             if (!test.title?.trim()) {
                 test.title = 'Unknown test title';
             }
+            test.title = buildExampleTitle(test.title, test.example);
             test.artifacts = normalizeArtifacts(test);
+            if (copyLocalArtifacts) {
+                makeLocalArtifactsPortable(test, outputPath, portableArtifacts);
+            }
             const allPossibleArtifacts = [
                 ...(test.artifacts || []),
                 ...(test.manuallyAttachedArtifacts || []),
@@ -373,6 +381,20 @@ function parseRetryInfo(test) {
             test.retries.retryCount = n;
     }
 }
+function buildExampleTitle(title, example) {
+    if (example == null)
+        return title;
+    let exampleText;
+    try {
+        exampleText = JSON.stringify(example);
+    }
+    catch (e) {
+        return title;
+    }
+    if (!exampleText || title.includes(exampleText))
+        return title;
+    return `${title} | ${exampleText}`;
+}
 function escapeHtml(str = '') {
     return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -864,51 +886,7 @@ function normalizeArtifacts(test) {
         ...(test.meta?.manuallyAttachedArtifacts || []),
     ];
     return allArtifacts
-        .map(artifact => {
-        if (typeof artifact === 'string') {
-            if (/^https?:\/\//i.test(artifact)) {
-                const base = path_1.default.basename(new URL(artifact).pathname) || artifact;
-                return {
-                    name: base,
-                    title: base,
-                    path: artifact,
-                    fsPath: null,
-                    relativePath: artifact,
-                };
-            }
-            const abs = path_1.default.isAbsolute(artifact) ? artifact : path_1.default.resolve(process.cwd(), artifact);
-            const href = artifact.startsWith('file://') ? artifact : (0, file_url_1.default)(abs, { resolve: true });
-            const base = path_1.default.basename(abs);
-            return {
-                name: base,
-                title: base,
-                path: href,
-                fsPath: abs,
-                relativePath: artifact,
-            };
-        }
-        if (artifact?.path) {
-            const raw = String(artifact.path);
-            const isFileUrl = raw.startsWith('file://');
-            const isHttpUrl = /^https?:\/\//i.test(raw);
-            const abs = isFileUrl || isHttpUrl ? null : path_1.default.isAbsolute(raw) ? raw : path_1.default.resolve(process.cwd(), raw);
-            const href = isFileUrl || isHttpUrl ? raw : (0, file_url_1.default)(abs, { resolve: true });
-            const base = abs
-                ? path_1.default.basename(abs)
-                : isHttpUrl
-                    ? path_1.default.basename(new URL(raw).pathname) || artifact.name || artifact.title || 'attachment'
-                    : artifact.name || artifact.title || 'attachment';
-            return {
-                ...artifact,
-                name: artifact.name || artifact.title || base,
-                title: artifact.title || artifact.name || base,
-                path: href,
-                fsPath: abs || artifact.fsPath || null,
-                relativePath: artifact.relativePath || raw,
-            };
-        }
-        return artifact;
-    })
+        .map(normalizeArtifact)
         .filter(Boolean)
         .filter(artifact => {
         const isTrace = (artifact.title === 'trace' || artifact.name === 'trace') &&
@@ -918,6 +896,135 @@ function normalizeArtifacts(test) {
         return !isTrace;
     });
 }
+function resolveHtmlCopyArtifacts(value) {
+    if (value !== undefined)
+        return (0, utils_js_1.transformEnvVarToBoolean)(value);
+    if (process.env.TESTOMATIO_HTML_REPORT_COPY_ARTIFACTS !== undefined) {
+        return (0, utils_js_1.transformEnvVarToBoolean)(process.env.TESTOMATIO_HTML_REPORT_COPY_ARTIFACTS);
+    }
+    return !isS3ArtifactsUploadEnabled();
+}
+function isS3ArtifactsUploadEnabled() {
+    return Boolean(process.env.S3_BUCKET && !(0, utils_js_1.transformEnvVarToBoolean)(process.env.TESTOMATIO_DISABLE_ARTIFACTS));
+}
+function normalizeArtifact(artifact) {
+    if (typeof artifact === 'string') {
+        return normalizeArtifactPath({ raw: artifact });
+    }
+    if (artifact?.path) {
+        return normalizeArtifactPath({
+            raw: String(artifact.path),
+            artifact,
+        });
+    }
+    return artifact;
+}
+/**
+ * @param {{
+ *   raw: string,
+ *   artifact?: { name?: string, title?: string, relativePath?: string, [key: string]: any }
+ * }} params
+ */
+function normalizeArtifactPath({ raw, artifact = {} }) {
+    const url = parseUrl(raw);
+    const fsPath = getLocalArtifactPath(raw, url);
+    const base = getArtifactBaseName({ raw, url, fsPath, artifact });
+    const href = fsPath && url?.protocol !== 'file:' ? (0, file_url_1.default)(fsPath, { resolve: true }) : raw;
+    return {
+        ...artifact,
+        name: artifact.name || artifact.title || base,
+        title: artifact.title || artifact.name || base,
+        path: href,
+        fsPath,
+        relativePath: artifact.relativePath || raw,
+    };
+}
+function makeLocalArtifactsPortable(test, outputPath, portableArtifacts) {
+    const reportDir = path_1.default.dirname(path_1.default.resolve(outputPath));
+    test.artifacts = makeArtifactsPortable(test.artifacts, reportDir, portableArtifacts);
+    if (Array.isArray(test.stepsArray)) {
+        makeStepArtifactsPortable(test.stepsArray, reportDir, portableArtifacts);
+    }
+}
+function makeStepArtifactsPortable(steps, reportDir, portableArtifacts) {
+    steps.forEach(step => {
+        if (Array.isArray(step.artifacts)) {
+            const normalizedArtifacts = step.artifacts.map(normalizeArtifact).filter(Boolean);
+            step.artifacts = makeArtifactsPortable(normalizedArtifacts, reportDir, portableArtifacts);
+        }
+        if (Array.isArray(step.steps)) {
+            makeStepArtifactsPortable(step.steps, reportDir, portableArtifacts);
+        }
+    });
+}
+function makeArtifactsPortable(artifacts, reportDir, portableArtifacts) {
+    if (!Array.isArray(artifacts))
+        return artifacts;
+    return artifacts.map(artifact => {
+        const fsPath = artifact?.fsPath;
+        if (!fsPath || !fs_1.default.existsSync(fsPath))
+            return artifact;
+        const relativePath = copyArtifactToReport(fsPath, reportDir, portableArtifacts);
+        return { ...artifact, path: relativePath, relativePath };
+    });
+}
+function copyArtifactToReport(fsPath, reportDir, portableArtifacts) {
+    const absoluteSource = path_1.default.resolve(fsPath);
+    if (portableArtifacts.has(absoluteSource))
+        return portableArtifacts.get(absoluteSource);
+    const artifactsDir = path_1.default.join(reportDir, HTML_ARTIFACTS_DIR);
+    const ext = path_1.default.extname(absoluteSource);
+    const baseName = path_1.default.basename(absoluteSource, ext) || 'attachment';
+    let destinationPath = path_1.default.join(artifactsDir, `${baseName}${ext}`);
+    let index = 1;
+    while (Array.from(portableArtifacts.values()).includes(getRelativeArtifactPath(reportDir, destinationPath))) {
+        destinationPath = path_1.default.join(artifactsDir, `${baseName}-${index}${ext}`);
+        index += 1;
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(destinationPath), { recursive: true });
+    fs_1.default.copyFileSync(absoluteSource, destinationPath);
+    const relativePath = getRelativeArtifactPath(reportDir, destinationPath);
+    portableArtifacts.set(absoluteSource, relativePath);
+    return relativePath;
+}
+function getLocalArtifactPath(raw, url = parseUrl(raw)) {
+    if (path_1.default.isAbsolute(raw))
+        return raw;
+    if (isRemoteUrl(url))
+        return null;
+    if (url?.protocol === 'file:') {
+        try {
+            return (0, node_url_1.fileURLToPath)(url);
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    if (url)
+        return null;
+    return path_1.default.resolve(process.cwd(), raw);
+}
+function getArtifactBaseName({ raw, url, fsPath, artifact }) {
+    if (fsPath)
+        return path_1.default.basename(fsPath);
+    if (url?.pathname)
+        return path_1.default.basename(url.pathname) || artifact.name || artifact.title || 'attachment';
+    return artifact.name || artifact.title || path_1.default.basename(raw) || 'attachment';
+}
+function parseUrl(value) {
+    try {
+        return new URL(String(value));
+    }
+    catch (_) {
+        return null;
+    }
+}
+function isRemoteUrl(url) {
+    return url?.protocol === 'http:' || url?.protocol === 'https:';
+}
+function getRelativeArtifactPath(reportDir, artifactPath) {
+    return `./${String(path_1.default.relative(reportDir, artifactPath)).split(path_1.default.sep).join('/')}`;
+}
 /**
  * Loads trace files from test.files and converts them to base64 data URLs
  * @param {object} test - Test object with files array

package/lib/replay.js

@@ -49,6 +49,7 @@ class Replay {
         const testsWithoutRid = []; // For tests without rid (backward compatibility)
         const envVars = {};
         let runId = null;
+        const artifactsToAdd = []; // Store artifacts to add after all tests are loaded
         // Parse debug file line by line
         for (const [lineIndex, line] of lines.entries()) {
             try {
@@ -125,6 +126,12 @@ class Replay {
                         testsWithoutRid.push({ ...test });
                     }
                 }
+                else if (logEntry.action === 'addArtifacts' && logEntry.artifacts) {
+                    if (logEntry.runId && !runId) {
+                        runId = logEntry.runId;
+                    }
+                    artifactsToAdd.push(...logEntry.artifacts);
+                }
                 else if (logEntry.action === 'finishRun') {
                     finishParams = logEntry.params || {};
                     if (logEntry.runId && !runId) {
@@ -143,6 +150,20 @@ class Replay {
         if (parseErrors > 3) {
             this.onError(`${parseErrors - 3} more parse errors occurred`);
         }
+        for (const artifact of artifactsToAdd) {
+            if (artifact.rid) {
+                const ridToFind = artifact.rid;
+                const fullRid = runId ? `${runId}-${ridToFind}` : ridToFind;
+                const test = testsMap.get(fullRid) || testsMap.get(ridToFind);
+                if (test && artifact.path) {
+                    if (!test.files)
+                        test.files = [];
+                    if (!test.files.includes(artifact.path)) {
+                        test.files.push(artifact.path);
+                    }
+                }
+            }
+        }
         // Combine tests with rid and tests without rid
         const allTests = [...Array.from(testsMap.values()), ...testsWithoutRid];
         return {