@testomatio/reporter 2.7.0 → 2.7.2-beta.1

package/src/adapter/playwright.js

@@ -3,14 +3,16 @@ import os from 'os';
 import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import fs from 'fs';
-import { APP_PREFIX, STATUS as Status, TESTOMAT_TMP_STORAGE_DIR } from '../constants.js';
+import { APP_PREFIX, STATUS as Status, TESTOMAT_TMP_STORAGE_DIR, SCREENSHOTS_ON_STEPS } from '../constants.js';
 import TestomatioClient from '../client.js';
-import { getTestomatIdFromTestTitle, fileSystem } from '../utils/utils.js';
+import { getTestomatIdFromTestTitle, fileSystem, truncate } from '../utils/utils.js';
 import { services } from '../services/index.js';
 import { dataStorage } from '../data-storage.js';
 import { extensionMap } from '../utils/constants.js';
 import pc from 'picocolors';
 import { fetchLinksFromLogs } from './utils/playwright.js';
+import { formatStep, addStatusToStep, addArtifactsToStep } from './utils/step-formatter.js';
+import { log } from '../utils/log.js';
 
 const reportTestPromises = [];
 
@@ -35,7 +37,7 @@ class PlaywrightReporter {
     dataStorage.setContext(fullTestTitle);
   }
 
-  onTestEnd(test, result) {
+  async onTestEnd(test, result) {
     // test.parent.project().__projectId
 
     if (!this.client) return;
@@ -54,13 +56,26 @@ class PlaywrightReporter {
 
     const suite_title = test.parent ? test.parent?.title : path.basename(test?.location?.file);
 
-    const steps = [];
-    for (const step of result.steps) {
-      const appendedStep = appendStep(step);
-      if (appendedStep) {
-        steps.push(appendedStep);
-      }
-    }
+    const rid = test.id || test.testId || uuidv4();
+
+    /**
+     * @type {{
+     * browser?: string,
+     * dependencies: string[],
+     * isMobile?: boolean
+     * metadata: Record<string, any>,
+     * name: string,
+     * }}
+     */
+    const project = {
+      browser: test.parent.project().use.defaultBrowserType,
+      dependencies: test.parent.project().dependencies,
+      isMobile: test.parent.project().use.isMobile,
+      metadata: test.parent.project().metadata,
+      name: test.parent.project().name,
+    };
+
+    const steps = result.steps.map(step => appendStep(step, 0)).filter(step => step !== null);
 
     // Extract and normalize tags
     const tags = extractTags(test);
@@ -86,24 +101,6 @@ class PlaywrightReporter {
     */
     const manuallyAttachedArtifacts = services.artifacts.get(fullTestTitle);
     const testMeta = services.keyValues.get(fullTestTitle);
-    const rid = test.id || test.testId || uuidv4();
-
-    /**
-     * @type {{
-     * browser?: string,
-     * dependencies: string[],
-     * isMobile?: boolean
-     * metadata: Record<string, any>,
-     * name: string,
-     * }}
-     */
-    const project = {
-      browser: test.parent.project().use.defaultBrowserType,
-      dependencies: test.parent.project().dependencies,
-      isMobile: test.parent.project().use.isMobile,
-      metadata: test.parent.project().metadata,
-      name: test.parent.project().name,
-    };
 
     let status = result.status;
     // process test.fail() annotation
@@ -179,7 +176,7 @@ class PlaywrightReporter {
     await Promise.all(reportTestPromises);
 
     if (this.uploads.length) {
-      if (this.client.uploader.isEnabled) console.log(APP_PREFIX, `🎞️  Uploading ${this.uploads.length} files...`);
+      if (this.client.uploader.isEnabled) log.info(`🎞️ Uploading ${this.uploads.length} files...`);
 
       const promises = [];
 
@@ -242,6 +239,44 @@ function appendStep(step, shift = 0) {
       newCategory = 'framework';
   }
 
+  const resultStep = formatStep({
+    category: newCategory,
+    title: step.title,
+    duration: step.duration,
+  });
+
+  // Add status based on error
+  addStatusToStep(resultStep, step.error ? 'failed' : 'passed', step.error);
+
+  // Add error if present
+  if (step.error !== undefined) {
+    if (typeof step.error === 'object') {
+      resultStep.error = {
+        message: truncate(String(step.error.message), 250),
+        stack: truncate(String(step.error.stack || ''), 250),
+      };
+    } else {
+      resultStep.error = truncate(String(step.error), 250);
+    }
+  }
+
+  // Add log if present
+  if (step.log) {
+    resultStep.log = truncate(String(step.log), 250);
+  }
+
+  // Add artifacts from attachments
+  if (step.attachments && step.attachments.length > 0 && SCREENSHOTS_ON_STEPS) {
+    const screenshotAttachment = step.attachments.find(att =>
+      att.contentType === 'image/png' && att.name === 'screenshot'
+    );
+    if (screenshotAttachment && screenshotAttachment.path) {
+      const artifacts = { screenshot: screenshotAttachment.path };
+      addArtifactsToStep(resultStep, artifacts);
+    }
+  }
+
+  // Process nested steps
   const formattedSteps = [];
   for (const child of step.steps || []) {
     const appendedChild = appendStep(child, shift + 2);
@@ -250,20 +285,10 @@ function appendStep(step, shift = 0) {
     }
   }
 
-  const resultStep = {
-    category: newCategory,
-    title: step.title,
-    duration: step.duration,
-  };
-
   if (formattedSteps.length) {
     resultStep.steps = formattedSteps.filter(s => !!s);
   }
 
-  if (step.error !== undefined) {
-    resultStep.error = step.error;
-  }
-
   return resultStep;
 }
 

package/src/adapter/utils/step-formatter.js

@@ -0,0 +1,232 @@
+import { truncate } from '../../utils/utils.js';
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+
+/**
+ * Generates a short unique filename from screenshot path
+ * If original filename is too long, uses hash-based name
+ *
+ * @param {string} screenshotPath - Path to screenshot file
+ * @returns {string} Short filename (max 80 chars)
+ */
+export function generateShortFilename(screenshotPath) {
+  const originalFilename = path.basename(screenshotPath);
+  const stepPrefix = originalFilename.match(/^(\d{3,4}_)/)?.[1] || '';
+
+  if (originalFilename.length < 40) {
+    return originalFilename;
+  }
+
+  const ext = path.extname(screenshotPath);
+
+  const hash = crypto
+    .createHash('sha256')
+    .update(screenshotPath)
+    .digest('hex')
+    .slice(0, 16);
+
+  return `${stepPrefix}screenshot_${hash}${ext}`;
+}
+
+/**
+ * Formats a step object according to Testomat.io Step Schema
+ *
+ * This function transforms a raw step object from test frameworks (CodeceptJS, Playwright, etc.)
+ * into a standardized format compatible with Testomat.io API. It ensures all text fields are
+ * truncated to 250 characters as defined in testomat-api-definition.yml.
+ *
+ * Processed fields:
+ * - category: step type (framework, user, hook) - defaults to 'user'
+ * - title: step name/description, truncated to 250 chars
+ * - duration: step execution time in seconds
+ * - log: optional log output, truncated to 250 chars
+ * - artifacts: optional array of artifact URLs (screenshots), each truncated to 250 chars
+ * - error: error details (message + stack) if step failed, each truncated to 250 chars
+ * - steps: recursively formats nested steps
+ *
+ * Schema reference: testomat-api-definition.yml (Step object)
+ *
+ * @param {Object} step - Raw step object from test framework
+ * @param {string} [step.category] - Step category: 'user', 'framework', or 'hook'
+ * @param {string} [step.title] - Step title/name
+ * @param {number} [step.duration] - Step duration in seconds
+ * @param {string} [step.log] - Log output for this step
+ * @param {string[]} [step.artifacts] - Array of artifact URLs (screenshots)
+ * @param {string|Object} [step.error] - Error details - can be string or object with message/stack
+ * @param {Object[]} [step.steps] - Array of nested child steps
+ * @returns {Object} Formatted step object matching Testomat.io Step Schema with:
+ * category, title, duration, and optional log, artifacts, error, and steps fields
+ *
+ * @example
+ * const rawStep = {
+ *   category: 'user',
+ *   title: 'I click on button',
+ *   duration: 1.5,
+ *   error: { message: 'Element not found', stack: 'at test.js:10:5' }
+ * };
+ * const formatted = formatStep(rawStep);
+ * // Returns: { category: 'user', title: 'I click on button', duration: 1.5, error: {...} }
+ */
+export function formatStep(step) {
+  const formattedStep = {
+    category: step.category || 'user',
+    title: truncate(String(step.title || ''), 250),
+    duration: step.duration || 0,
+  };
+
+  if (step.log) {
+    formattedStep.log = truncate(String(step.log), 250);
+  }
+
+  if (step.artifacts && Array.isArray(step.artifacts)) {
+    formattedStep.artifacts = step.artifacts.map(artifact => truncate(String(artifact), 250));
+  }
+
+  if (step.error) {
+    if (typeof step.error === 'object') {
+      formattedStep.error = {
+        message: truncate(String(step.error.message || 'Step failed'), 250),
+        stack: truncate(String(step.error.stack || ''), 250),
+      };
+    } else {
+      formattedStep.error = truncate(String(step.error), 250);
+    }
+  }
+
+  if (step.steps && Array.isArray(step.steps)) {
+    formattedStep.steps = step.steps.map(s => formatStep(s));
+  }
+
+  return formattedStep;
+}
+
+/**
+ * Adds status field to step
+ *
+ * Normalizes step status from test frameworks to Testomat.io standard format.
+ * Maps framework-specific statuses ('success', 'failed', 'passed') to Testomat.io
+ * standard values ('passed', 'failed').
+ *
+ * Status mapping:
+ * - 'success' → 'passed'
+ * - 'passed' → 'passed'
+ * - 'failed' → 'failed'
+ * - Any other value → 'passed' (default)
+ *
+ * If step already has a status, it won't be overwritten. If error is provided
+ * and step doesn't have status, it will be set to 'failed'.
+ *
+ * Schema reference: testomat-api-definition.yml (Step.status enum)
+ *
+ * @param {Object} step - Step object to add status to (modified in place)
+ * @param {string} [step.status] - Existing status (won't be overwritten if present)
+ * @param {string} status - Status from test framework: 'success', 'failed', or 'passed'
+ * @param {Error|Object|null} err - Error object if step failed
+ * @returns {Object} The same step object with added status field
+ *
+ * @example
+ * const step = { title: 'Click button' };
+ * addStatusToStep(step, 'success', null);
+ * // step.status === 'passed'
+ *
+ * @example
+ * const step2 = { title: 'Find element' };
+ * addStatusToStep(step2, 'failed', new Error('Not found'));
+ * // step2.status === 'failed'
+ */
+export function addStatusToStep(step, status, err) {
+  if (step.status) return step;
+
+  const statusMap = {
+    'success': 'passed',
+    'failed': 'failed',
+    'passed': 'passed',
+  };
+
+  step.status = statusMap[status] || 'passed';
+
+  if (err && !step.status) {
+    step.status = 'failed';
+  }
+
+  return step;
+}
+
+/**
+ * Adds screenshot to step as artifacts array
+ *
+ * Extracts screenshot path from artifacts and adds it to the step's artifacts array.
+ * The actual upload will happen in the client's addTestRun method.
+ *
+ * Artifact format supports:
+ * - Array format: [{ screenshot: '/path/to/screenshot.png' }]
+ * - Object format: { screenshot: '/path/to/screenshot.png' }
+ *
+ * Screenshot path can be specified as:
+ * - Object with path property: { screenshot: { path: '/path/to/file.png' } }
+ * - Object with screenshot property: { screenshot: { screenshot: '/path/to/file.png' } }
+ * - Direct string path: { screenshot: '/path/to/file.png' }
+ *
+ * @param {Object} step - Step object to add artifacts to (modified in place)
+ * @param {string[]} [step.artifacts] - Existing artifacts array (won't be overwritten if present)
+ * @param {Object|Object[]|null} artifacts - Artifacts from test framework
+ * @returns {Object} The same step object with artifacts array added
+ *
+ * @example
+ * const step = { title: 'Click button' };
+ * const artifacts = { screenshot: '/tmp/screenshot.png' };
+ * addArtifactsToStep(step, artifacts);
+ * // step.artifacts === ['/tmp/screenshot.png']
+ */
+export function addArtifactsToStep(step, artifacts) {
+  if (!artifacts) return step;
+
+  let screenshotPath = null;
+
+  if (Array.isArray(artifacts)) {
+    const screenshotArtifact = artifacts.find(a => a.screenshot);
+    if (screenshotArtifact && screenshotArtifact.path) {
+      screenshotPath = screenshotArtifact.path;
+    } else if (screenshotArtifact && screenshotArtifact.screenshot) {
+      screenshotPath = screenshotArtifact.screenshot;
+    }
+  } else if (artifacts.screenshot) {
+    screenshotPath = artifacts.screenshot;
+  }
+
+  if (screenshotPath && fs.existsSync(screenshotPath)) {
+    const truncatedPath = truncate(String(screenshotPath), 250);
+    if (step.artifacts && Array.isArray(step.artifacts)) {
+      step.artifacts.push(truncatedPath);
+    } else {
+      step.artifacts = [truncatedPath];
+    }
+  }
+
+  return step;
+}
+
+/**
+ * Appends one artifact path to a step.
+ *
+ * Unlike addArtifactsToStep, this helper accepts a direct path (or URL-like string)
+ * and does not check file existence, so callers can attach fallback artifacts
+ * collected from logs or async trace outputs.
+ *
+ * @param {Object} step - Step object to update (modified in place)
+ * @param {string} artifactPath - Artifact path to append
+ * @returns {Object} The same step object with updated artifacts
+ */
+export function addArtifactPathToStep(step, artifactPath) {
+  if (!step || !artifactPath) return step;
+
+  const truncatedPath = truncate(String(artifactPath), 250);
+  if (step.artifacts && Array.isArray(step.artifacts)) {
+    if (!step.artifacts.includes(truncatedPath)) step.artifacts.push(truncatedPath);
+  } else {
+    step.artifacts = [truncatedPath];
+  }
+
+  return step;
+}

package/src/bin/cli.js

@@ -14,6 +14,7 @@ import pc from 'picocolors';
 import { filesize as prettyBytes } from 'filesize';
 import dotenv from 'dotenv';
 import Replay from '../replay.js';
+import { log } from '../utils/log.js';
 
 const debug = createDebugMessages('@testomatio/reporter:cli');
 const version = getPackageVersion();
@@ -89,7 +90,7 @@ program
     const client = new TestomatClient({ apiKey, title });
 
     if (opts.filter || opts.filterList) {
-      console.log(APP_PREFIX,'Filtering tests...');
+      log.info('Filtering tests...');
       // Example of use: npx @testomatio/reporter run "npx jest" --filter "testomatio:tag-name=frontend"
       // Example of use: npx @testomatio/reporter run "npx jest" --filter "coverage:file=coverage.yml"
       // Example of use: npx @testomatio/reporter run "npx jest" --filter-list "coverage:file=coverage.yml"
@@ -105,7 +106,7 @@ program
         const tests = await client.prepareRun(prepareRunParams);
 
         if (!tests || tests.length === 0) {
-          console.log(APP_PREFIX, pc.yellow('No tests found.'));
+          log.info( pc.yellow('No tests found.'));
           return;
         }
 
@@ -115,8 +116,8 @@ program
         debug(`Execution pattern: "${pattern}"`);
 
         if(opts.filterList) {
-          console.log(APP_PREFIX, pc.blue(`Matched test/suite IDs: ${tests.join(', ')}`));
-          if (command) console.log(APP_PREFIX, pc.green(`Full Running Command: ${filteredCommand}`));
+          log.info( pc.blue(`Matched test/suite IDs: ${tests.join(', ')}`));
+          if (command) log.info( pc.green(`Full Running Command: ${filteredCommand}`));
           return;
         }
 
@@ -125,7 +126,7 @@ program
         }
       }
       catch (err) {
-        console.log(APP_PREFIX, err.message || err);
+        log.info( err.message || err);
         return;
       }
     }
@@ -143,20 +144,20 @@ program
       if (apiKey) {
         await client.createRun(createRunParams);
         const runId = process.env.TESTOMATIO_RUN || process.env.runId;
-        if (client.pipeStore.runUrl) console.log(APP_PREFIX, `📊 Report URL: ${pc.magenta(client.pipeStore.runUrl)}`);
+        if (client.pipeStore.runUrl) log.info( `📊 Report URL: ${pc.magenta(client.pipeStore.runUrl)}`);
 
         if (opts.kind !== 'manual') {
-          console.log(APP_PREFIX, `No command passed, so you need to run tests yourself:`);
-          console.log(APP_PREFIX, `TESTOMATIO_RUN=${runId} <command>`);
+          log.info( `No command passed, so you need to run tests yourself:`);
+          log.info( `TESTOMATIO_RUN=${runId} <command>`);
         }
       } else {
-        console.log(APP_PREFIX, '⚠️  No API key provided. Cannot create run without TESTOMATIO key.');
+        log.info( '⚠️  No API key provided. Cannot create run without TESTOMATIO key.');
         process.exit(1);
       }
       return process.exit(0);
     }
 
-    console.log(APP_PREFIX, `🚀 Running`, pc.green(command));
+    log.info( `🚀 Running`, pc.green(command));
 
     const runTests = async () => {
       const testCmds = command.split(' ');
@@ -167,7 +168,7 @@ program
 
       cmd.on('close', async code => {
         const emoji = code === 0 ? '🟢' : '🔴';
-        console.log(APP_PREFIX, emoji, `Runner exited with ${pc.bold(code)}`);
+        log.info( emoji, `Runner exited with ${pc.bold(code)}`);
         if (apiKey) {
           const status = code === 0 ? 'passed' : 'failed';
           await client.updateRunStatus(status);
@@ -209,7 +210,7 @@ program
 //   const runReader = new XmlReader({ javaTests, lang });
 //   const files = glob.sync(pattern, { cwd: opts.dir || process.cwd() });
 //   if (!files.length) {
-//     console.log(APP_PREFIX, `Report can't be created. No XML files found 😥`);
+//     log.info( `Report can't be created. No XML files found 😥`);
 //     process.exit(1);
 //   }
 
@@ -231,12 +232,12 @@ program
     const runReader = new XmlReader({ javaTests, lang });
     const files = glob.sync(pattern, { cwd: opts.dir || process.cwd() });
     if (!files.length) {
-      console.log(APP_PREFIX, `Report can't be created. No XML files found 😥`);
+      log.info( `Report can't be created. No XML files found 😥`);
       process.exit(1);
     }
 
     for (const file of files) {
-      console.log(APP_PREFIX, `Parsed ${file}`);
+      log.info( `Parsed ${file}`);
       runReader.parse(file);
     }
 
@@ -257,7 +258,7 @@ program
       await runReader.createRun();
       await runReader.uploadData();
     } catch (err) {
-      console.log(APP_PREFIX, 'Error updating status, skipping...', err);
+      log.info( 'Error updating status, skipping...', err);
     }
 
     if (timeoutTimer) clearTimeout(timeoutTimer);
@@ -292,10 +293,10 @@ program
     if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
 
     if (!testruns.length) {
-      console.log(APP_PREFIX, '🗄️ Total artifacts:', numTotalArtifacts);
+      log.info( '🗄️ Total artifacts:', numTotalArtifacts);
       if (numTotalArtifacts) {
-        console.log(APP_PREFIX, 'No new artifacts to upload');
-        console.log(APP_PREFIX, 'To re-upload artifacts run this command with --force flag');
+        log.info( 'No new artifacts to upload');
+        log.info( 'To re-upload artifacts run this command with --force flag');
       }
       process.exit(0);
     }
@@ -317,7 +318,7 @@ program
       await client.addTestRun(undefined, { rid, files });
     }
 
-    console.log(APP_PREFIX, '🗄️', client.uploader.successfulUploads.length, 'artifacts 🟢uploaded');
+    log.info( '🗄️', client.uploader.successfulUploads.length, 'artifacts 🟢uploaded');
 
     if (client.uploader.successfulUploads.length) {
       debug('\n', APP_PREFIX, `🗄️ ${client.uploader.successfulUploads.length} artifacts uploaded to S3 bucket`);
@@ -376,11 +377,11 @@ program
       const replayService = new Replay({
         apiKey: config.TESTOMATIO,
         dryRun: opts.dryRun,
-        onLog: message => console.log(APP_PREFIX, message),
-        onError: message => console.error(APP_PREFIX, '⚠️ ', message),
+        onLog: message => log.info( message),
+        onError: message => log.error( '⚠️ ', message),
         onProgress: ({ current, total }) => {
           if (current % 10 === 0 || current === total) {
-            console.log(APP_PREFIX, `📊 Progress: ${current}/${total} tests processed`);
+            log.info( `📊 Progress: ${current}/${total} tests processed`);
           }
         },
       });
@@ -388,23 +389,25 @@ program
       const result = await replayService.replay(debugFile);
 
       if (result.dryRun) {
-        console.log(APP_PREFIX, '🔍 Dry run completed:');
-        console.log(APP_PREFIX, `  - Tests found: ${result.testsCount}`);
-        console.log(APP_PREFIX, `  - Environment variables: ${Object.keys(result.envVars).length}`);
-        console.log(APP_PREFIX, `  - Run parameters:`, result.runParams);
-        console.log(APP_PREFIX, '  Use without --dry-run to actually send the data');
+        log.info(
+          '🔍 Dry run completed:\n',
+          `  - Tests found: ${result.testsCount}\n`,
+          `  - Environment variables: ${Object.keys(result.envVars).length}\n`,
+          '  - Run parameters:', result.runParams, '\n',
+          '  Use without --dry-run to actually send the data',
+        );
       } else {
-        console.log(APP_PREFIX, `✅ Successfully replayed ${result.successCount}/${result.testsCount} tests`);
+        log.info( `✅ Successfully replayed ${result.successCount}/${result.testsCount} tests`);
         if (result.failureCount > 0) {
-          console.log(APP_PREFIX, `⚠️  ${result.failureCount} tests failed to upload`);
+          log.info( `⚠️  ${result.failureCount} tests failed to upload`);
         }
       }
 
       process.exit(0);
     } catch (err) {
-      console.error(APP_PREFIX, '❌ Error replaying debug data:', err.message);
+      log.error( '❌ Error replaying debug data:', err.message);
       if (err.message.includes('Debug file not found')) {
-        console.error(APP_PREFIX, '💡 Hint: Run tests with TESTOMATIO_DEBUG=1 to generate debug files');
+        log.error( '💡 Hint: Run tests with TESTOMATIO_DEBUG=1 to generate debug files');
       }
       process.exit(1);
     }

package/src/bin/reportXml.js

@@ -3,11 +3,10 @@ import { Command } from 'commander';
 import pc from 'picocolors';
 import { glob } from 'glob';
 import createDebugMessages from 'debug';
-import { APP_PREFIX } from '../constants.js';
 import XmlReader from '../xmlReader.js';
 import { getPackageVersion } from '../utils/utils.js';
 import dotenv from 'dotenv';
-import path from 'path';
+import { log } from '../utils/log.js';
 
 const version = getPackageVersion();
 
@@ -28,7 +27,7 @@ program
     }
     let { javaTests, lang } = opts;
     if (opts.envFile) {
-      console.log(APP_PREFIX, 'Loading env file:', opts.envFile);
+      log.info( 'Loading env file:', opts.envFile);
       debug('Loading env file: %s', opts.envFile);
       dotenv.config({ path: opts.envFile });
     }
@@ -40,13 +39,13 @@ program
     });
     const files = glob.sync(pattern, { cwd: opts.dir || process.cwd() });
     if (!files.length) {
-      console.log(APP_PREFIX, `Report can't be created. No XML files found 😥`);
+      log.info( `Report can't be created. No XML files found 😥`);
       process.exitCode = 1;
       return;
     }
 
     for (const file of files) {
-      console.log(APP_PREFIX, `Parsed ${file}`);
+      log.info( `Parsed ${file}`);
       runReader.parse(file);
     }
 
@@ -67,7 +66,7 @@ program
       await runReader.createRun();
       await runReader.uploadData();
     } catch (err) {
-      console.log(APP_PREFIX, 'Error updating status, skipping...', err);
+      log.info( 'Error updating status, skipping...', err);
     }
 
     if (timeoutTimer) clearTimeout(timeoutTimer);

package/src/bin/startTest.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { getPackageVersion } from '../utils/utils.js';
 import pc from 'picocolors';
 
-// Define __dirname - this will be replaced by build script with actual __dirname for CommonJS
-const __dirname = typeof globalThis.__dirname !== 'undefined' ? globalThis.__dirname : '.';
+// @ts-ignore
+const __dirname = typeof global.__dirname !== 'undefined' ? global.__dirname : dirname(fileURLToPath(import.meta.url));
 const cliPath = join(__dirname, 'cli.js');
 
 const version = getPackageVersion();

package/src/bin/uploadArtifacts.js

@@ -4,11 +4,11 @@ import { Command } from 'commander';
 import pc from 'picocolors';
 import createDebugMessages from 'debug';
 import TestomatClient from '../client.js';
-import { APP_PREFIX } from '../constants.js';
 import { getPackageVersion } from '../utils/utils.js';
 import { config } from '../config.js';
 import { readLatestRunId } from '../utils/utils.js';
 import dotenv from 'dotenv';
+import { log } from '../utils/log.js';
 
 const debug = createDebugMessages('@testomatio/reporter:upload-cli');
 const version = getPackageVersion();
@@ -48,10 +48,10 @@ program
     if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
 
     if (!testruns.length) {
-      console.log(APP_PREFIX, 'Total artifacts:', numTotalArtifacts);
+      log.info('Total artifacts:', numTotalArtifacts);
       if (numTotalArtifacts) {
-        console.log(APP_PREFIX, 'No new artifacts to upload');
-        console.log(APP_PREFIX, 'To re-upload artifacts run this command with --force flag');
+        log.info('No new artifacts to upload');
+        log.info('To re-upload artifacts run this command with --force flag');
       }
       process.exit(0);
     }
@@ -78,9 +78,9 @@ program
       });
     }
 
-    console.log(APP_PREFIX, client.uploader.successfulUploads.length, 'artifacts uploaded');
+    log.info(client.uploader.successfulUploads.length, 'artifacts uploaded');
     if (client.uploader.failedUploads.length) {
-      console.log(APP_PREFIX, client.uploader.failedUploads.length, 'artifacts failed to upload');
+      log.info(client.uploader.failedUploads.length, 'artifacts failed to upload');
     }
   });