@testomatio/reporter 2.19.0 → 2.21.0

package/lib/utils/detectRunner.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlaceholderCommand = isPlaceholderCommand;
+exports.detectRunner = detectRunner;
+exports.runnerHint = runnerHint;
+exports.buildFilterWarning = buildFilterWarning;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const LAUNCHER_PREFIXES = ['npx', 'npm', 'yarn', 'pnpm', 'bun', 'node', 'bunx'];
+const PLACEHOLDER_PHRASE_RE = /^<?-*(?:run|your|test)\s+(?:[\w-]+\s+)?(?:tests?|command|runner)>?$/i;
+const RUNNERS = [
+    {
+        name: 'Playwright',
+        configs: ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs', 'playwright.config.cjs'],
+        dependencies: ['@playwright/test'],
+        command: 'npx playwright test',
+    },
+    {
+        name: 'CodeceptJS',
+        configs: ['codecept.conf.js', 'codecept.conf.ts'],
+        dependencies: ['codeceptjs'],
+        command: 'npx codeceptjs run',
+    },
+    {
+        name: 'WebdriverIO',
+        configs: ['wdio.conf.js', 'wdio.conf.ts'],
+        dependencies: ['@wdio/cli'],
+        dependencyPrefix: '@wdio/',
+        command: 'npx wdio run ./wdio.conf.js',
+    },
+    {
+        name: 'Cypress',
+        configs: ['cypress.config.js', 'cypress.config.ts'],
+        dependencies: ['cypress'],
+        command: 'npx cypress run',
+    },
+    {
+        name: 'Jest',
+        configs: ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs', 'jest.config.json'],
+        dependencies: ['jest'],
+        command: 'npx jest',
+    },
+    {
+        name: 'Vitest',
+        configs: ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'],
+        dependencies: ['vitest'],
+        command: 'npx vitest run',
+    },
+    {
+        name: 'Mocha',
+        configs: ['.mocharc.js', '.mocharc.cjs', '.mocharc.json', '.mocharc.yml', '.mocharc.yaml'],
+        dependencies: ['mocha'],
+        command: 'npx mocha',
+    },
+    {
+        name: 'Cucumber',
+        configs: ['cucumber.js', 'cucumber.cjs'],
+        dependencies: ['@cucumber/cucumber'],
+        command: 'npx cucumber-js',
+    },
+];
+/**
+ * @param {string} command
+ * @returns {boolean}
+ */
+function isPlaceholderCommand(command) {
+    const cmd = (command || '').trim();
+    if (!cmd)
+        return false;
+    if (cmd.includes('<') || cmd.includes('>'))
+        return true;
+    const firstToken = cmd.split(/\s+/)[0].toLowerCase();
+    if (LAUNCHER_PREFIXES.includes(firstToken))
+        return false;
+    return PLACEHOLDER_PHRASE_RE.test(cmd);
+}
+/**
+ * @param {string} cwd
+ * @returns {Record<string, string>}
+ */
+function readPackageDependencies(cwd) {
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(cwd, 'package.json'), 'utf8'));
+        return { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * @param {string} [cwd]
+ * @returns {{ name: string, command: string } | null}
+ */
+function detectRunner(cwd = process.cwd()) {
+    const dependencies = readPackageDependencies(cwd);
+    for (const runner of RUNNERS) {
+        const config = runner.configs.find(file => fs_1.default.existsSync(path_1.default.join(cwd, file)));
+        const hasDependency = runner.dependencies?.some(dep => dependencies[dep])
+            || (runner.dependencyPrefix && Object.keys(dependencies).some(dep => dep.startsWith(runner.dependencyPrefix)));
+        if (!config && !hasDependency)
+            continue;
+        let command = runner.command;
+        if (runner.name === 'WebdriverIO') {
+            command = `npx wdio run ./${config || 'wdio.conf.js'}`;
+        }
+        return { name: runner.name, command };
+    }
+    return null;
+}
+/**
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+function runnerHint(cwd = process.cwd()) {
+    const runner = detectRunner(cwd);
+    if (runner) {
+        return `💡 Looks like this project uses ${runner.name}. Try: ${picocolors_1.default.green(runner.command)}`;
+    }
+    return `💡 Replace the placeholder with your test runner command, e.g. ${picocolors_1.default.green('npx playwright test')}`;
+}
+/**
+ * @param {string} command
+ * @returns {string[]}
+ */
+function buildFilterWarning(command) {
+    return [
+        '⚠️  The runner exited with a non-zero code while a Testomat.io filter was applied.',
+        'Your command was modified to run only tests matching Testomat IDs:',
+        `  ${picocolors_1.default.bold(command)}`,
+        'This usually means no local tests matched the filter:',
+        '  - tests are not annotated with the matching @Txxxxxx IDs in their titles',
+        '  - the filter selected tests from another repository or branch',
+        '  - the test runner does not support the appended --grep / --testNamePattern option',
+        '💡 Hint: run the printed command without the appended filter option to see all your tests,',
+        'then annotate them with Testomat IDs.',
+    ];
+}
+
+module.exports.isPlaceholderCommand = isPlaceholderCommand;
+
+module.exports.detectRunner = detectRunner;
+
+module.exports.runnerHint = runnerHint;
+
+module.exports.buildFilterWarning = buildFilterWarning;

package/lib/utils/pipe_utils.d.ts

@@ -139,16 +139,29 @@ export function formatRunOutput(store: {
 }, format?: string): string;
 /**
  * Format the runs fetched via the `fetch` command for machine-readable output.
- * `json` prints the full array of run objects; `id` prints one run id per line;
+ * `json` prints the full array of run objects (a single object for one run); `id` prints one run id per line;
  * any other format prints a human-readable multi-line summary per run.
  *
- * @param {{data?: Array}} body - Parsed response body from GET /api/v2/:project/runs.
+ * @param {{data?: Array|Object}} body - Parsed response body from GET /api/v2/:project/runs[/:id].
  * @param {string} [format] - Value of the CLI `--format` option.
  * @returns {string}
  */
 export function formatFetchRunsOutput(body: {
-    data?: any[];
+    data?: any[] | any;
 }, format?: string): string;
+/**
+ * Parse a Testomat.io app URL of a run (/projects/:project/runs/:id)
+ * or of a runs page (/projects/:project/runs?filterParam=...) into API v2 request parts.
+ *
+ * @param {string} pageUrl
+ * @returns {{baseUrl: string, project: string, runId?: string, params: string[][]}|null}
+ */
+export function parseRunsUrl(pageUrl: string): {
+    baseUrl: string;
+    project: string;
+    runId?: string;
+    params: string[][];
+} | null;
 /**
  * Calculate the approximate size of data in bytes (JSON stringified, UTF-8 encoded length).
  * @param {Object} data - Data to measure

package/lib/utils/pipe_utils.js

@@ -18,6 +18,7 @@ exports.parsePipeOptions = parsePipeOptions;
 exports.formatFilterListIds = formatFilterListIds;
 exports.formatRunOutput = formatRunOutput;
 exports.formatFetchRunsOutput = formatFetchRunsOutput;
+exports.parseRunsUrl = parseRunsUrl;
 exports.getObjectSize = getObjectSize;
 exports.splitTestsIntoChunks = splitTestsIntoChunks;
 const humanize_duration_1 = __importDefault(require("humanize-duration"));
@@ -362,17 +363,18 @@ function formatRunOutput(store, format) {
 }
 /**
  * Format the runs fetched via the `fetch` command for machine-readable output.
- * `json` prints the full array of run objects; `id` prints one run id per line;
+ * `json` prints the full array of run objects (a single object for one run); `id` prints one run id per line;
  * any other format prints a human-readable multi-line summary per run.
  *
- * @param {{data?: Array}} body - Parsed response body from GET /api/v2/:project/runs.
+ * @param {{data?: Array|Object}} body - Parsed response body from GET /api/v2/:project/runs[/:id].
  * @param {string} [format] - Value of the CLI `--format` option.
  * @returns {string}
  */
 function formatFetchRunsOutput(body, format) {
-    const runs = body?.data || [];
+    const data = body?.data || [];
+    const runs = [data].flat();
     if (format === 'json')
-        return JSON.stringify(runs, null, 2);
+        return JSON.stringify(data, null, 2);
     if (format === 'id')
         return runs.map(run => run.id).filter(Boolean).join('\n');
     return runs
@@ -380,6 +382,8 @@ function formatFetchRunsOutput(body, format) {
         const lines = [`* ID: ${run.id}`];
         if (run.title)
             lines.push(`  title: ${run.title}`);
+        if (run.rungroup_id)
+            lines.push(`  rungroup: ${run.rungroup_id}`);
         if (run.launched_at)
             lines.push(`  started at: ${run.launched_at}`);
         if (run.finished_at)
@@ -400,6 +404,41 @@ function formatFetchRunsOutput(body, format) {
     })
         .join('\n');
 }
+// filterParam keys of the runs page which are API params on their own; the rest go under filter[...]
+const RUNS_PAGE_PARAMS = ['search', 'tql', 'groupId'];
+/**
+ * Parse a Testomat.io app URL of a run (/projects/:project/runs/:id)
+ * or of a runs page (/projects/:project/runs?filterParam=...) into API v2 request parts.
+ *
+ * @param {string} pageUrl
+ * @returns {{baseUrl: string, project: string, runId?: string, params: string[][]}|null}
+ */
+function parseRunsUrl(pageUrl) {
+    let url;
+    try {
+        url = new URL(pageUrl);
+    }
+    catch (e) {
+        return null;
+    }
+    const match = url.pathname.match(/\/projects\/([^/]+)\/runs(?:\/([^/]+))?\/?$/);
+    if (!match)
+        return null;
+    const [, project, runId] = match;
+    const params = [];
+    for (const [key, value] of new URLSearchParams(url.searchParams.get('filterParam') || '')) {
+        // "groups" only switches the page to the grouped view
+        if (!value || key === 'groups')
+            continue;
+        if (RUNS_PAGE_PARAMS.includes(key)) {
+            params.push([key, value]);
+            continue;
+        }
+        const [name, ...nested] = key.split('[');
+        params.push([`filter[${name}]${nested.map(part => `[${part}`).join('')}`, value]);
+    }
+    return { baseUrl: url.origin, project, runId, params };
+}
 
 module.exports.updateFilterType = updateFilterType;
 
@@ -431,6 +470,8 @@ module.exports.formatRunOutput = formatRunOutput;
 
 module.exports.formatFetchRunsOutput = formatFetchRunsOutput;
 
+module.exports.parseRunsUrl = parseRunsUrl;
+
 module.exports.getObjectSize = getObjectSize;
 
 module.exports.splitTestsIntoChunks = splitTestsIntoChunks;

package/lib/xmlReader.js

@@ -432,6 +432,8 @@ class XmlReader {
             }
             this.adapter.formatTest(t);
             t.title = (0, utils_js_1.humanize)(t.title);
+            // meta must always include reporter version and adapter used
+            t.meta = { ...t.meta, reporterVersion: this.version, adapter: 'xml' };
         });
     }
     formatErrors() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.19.0",
+  "version": "2.21.0",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=22"
@@ -65,7 +65,8 @@
     "test:playwright": "mocha tests/adapter/playwright.test.js",
     "test:codecept": "mocha tests/adapter/codecept.test.js tests/adapter/codecept_comprehensive.test.js tests/adapter/codecept_steps_sections.test.js",
     "test:vitest": "mocha tests/adapter/vitest.test.js",
-    "test:frameworks": "npm run test:playwright && npm run test:codecept && npm run test:vitest",
+    "test:e2e": "mocha tests/adapter/e2e.test.js",
+    "test:frameworks": "npm run test:playwright && npm run test:codecept && npm run test:vitest && npm run test:e2e",
     "test:all": "npm run test && npm run test:frameworks",
     "test:adapters": "mocha tests/adapter/*.test.js",
     "test:codecept:bug948": "mocha tests/adapter/codecept_aftersuite_failure.test.js",
@@ -101,7 +102,7 @@
     "jasmine": "^5.2.0",
     "jest": "^27.4.7",
     "jsdom": "^22.1.0",
-    "mocha": "^9.2.0",
+    "mocha": "^12.0.3",
     "mock-http-server": "^1.4.5",
     "pino": "^8.15.0",
     "prettier": "^3.2.5",
@@ -129,6 +130,10 @@
     "./lib/adapter/cypress-plugin": "./lib/adapter/cypress-plugin/index.js",
     "./cypress-plugin": "./lib/adapter/cypress-plugin/index.js",
     "./cypress": "./lib/adapter/cypress-plugin/index.js",
+    "./e2e": {
+      "import": "./src/adapter/e2e.js",
+      "require": "./lib/adapter/e2e.js"
+    },
     "./lib/adapter/jasmine.js": "./lib/adapter/jasmine.js",
     "./jasmine": "./lib/adapter/jasmine.js",
     "./lib/adapter/jest.js": "./lib/adapter/jest.js",

package/src/adapter/codecept.js

@@ -11,6 +11,8 @@ import codeceptjs from 'codeceptjs';
 import { log } from '../utils/log.js';
 
 const debug = createDebugMessages('@testomatio/reporter:adapter:codeceptjs');
+
+global.TESTOMATIO_ADAPTER = 'codeceptjs';
 // @ts-ignore
 if (!global.codeceptjs) {
   // @ts-ignore
@@ -18,7 +20,7 @@ if (!global.codeceptjs) {
 }
 
 // @ts-ignore
-const { event, recorder, codecept, output } = global.codeceptjs;
+const { event, recorder, codecept, output, container } = global.codeceptjs;
 
 const [, MAJOR_VERSION, MINOR_VERSION] = codecept
   .version()
@@ -57,6 +59,7 @@ function CodeceptReporter(config) {
   let isRunFinalized = false;
 
   const testTimeMap = {};
+  const failedUrls = new Map();
   const clientConfig = buildCodeceptClientConfig(config);
   const client = new TestomatClient(clientConfig);
 
@@ -241,6 +244,22 @@ function CodeceptReporter(config) {
     }, 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();
 
@@ -272,6 +291,9 @@ function CodeceptReporter(config) {
     const keyValues = services.keyValues.get(test.fullTitle());
     const links = services.links.get(test.fullTitle());
     const screenshotOnFailPath = artifacts.screenshot || null;
+    const meta = { ...keyValues, ...test.meta };
+    if (test.state === STATUS.FAILED && failedUrls.has(uid)) meta.failedUrl = failedUrls.get(uid);
+    failedUrls.delete(uid);
 
     // Build step hierarchy with screenshot from screenshotOnFail
     const stepHierarchy = buildUnifiedStepHierarchy(
@@ -295,7 +317,7 @@ function CodeceptReporter(config) {
       logs,
       links,
       manuallyAttachedArtifacts,
-      meta: { ...keyValues, ...test.meta },
+      meta,
     });
     reportTestPromises.push(reportTestPromise);
 

package/src/adapter/cucumber/current.js

@@ -8,6 +8,8 @@ import { getTestomatIdFromTestTitle, fileSystem } from '../../utils/utils.js';
 import { config } from '../../config.js';
 import { services } from '../../services/index.js';
 
+global.TESTOMATIO_ADAPTER = 'cucumber';
+
 const { GherkinDocumentParser, PickleParser } = formatterHelpers;
 const { getGherkinScenarioLocationMap, getGherkinStepMap } = GherkinDocumentParser;
 const { getPickleStepMap } = PickleParser;

package/src/adapter/cypress-plugin/index.js

@@ -3,6 +3,8 @@ import { getTestomatIdFromTestTitle, parseSuite } from '../../utils/utils.js';
 import TestomatClient from '../../client.js';
 import { config } from '../../config.js';
 
+global.TESTOMATIO_ADAPTER = 'cypress';
+
 const testomatioReporter = on => {
   if (!config.TESTOMATIO) {
     console.log('TESTOMATIO key is empty, ignoring reports');

package/src/adapter/e2e.js

@@ -0,0 +1,248 @@
+import path from 'path';
+import createDebugMessages from 'debug';
+import TestomatioClient from '../client.js';
+import { STATUS, SCREENSHOTS_ON_STEPS } from '../constants.js';
+import { getTestomatIdFromTestTitle, truncate } from '../utils/utils.js';
+import { formatStep, addStatusToStep, addArtifactsToStep } from './utils/step-formatter.js';
+import { log } from '../utils/log.js';
+
+const debug = createDebugMessages('@testomatio/reporter:adapter-e2e');
+
+/**
+ * Reporter for the e2e framework (https://github.com/tester-army/e2e).
+ * Add it to `reporters` in `e2e.config.ts`: `reporters: ['list', testomatio()]`.
+ *
+ * The config is loaded by every worker, so the client is created only inside
+ * handlers, which run in the runner process.
+ *
+ * @param {{ apiKey?: string }} [options]
+ */
+export function testomatio(options = {}) {
+  let client = null;
+  let runPromise = null;
+
+  function getClient() {
+    if (!client) client = new TestomatioClient({ apiKey: options.apiKey });
+    return client;
+  }
+
+  function startRun() {
+    if (!runPromise) {
+      runPromise = getClient()
+        .createRun()
+        .catch(err => log.error('Failed to create Testomat.io run:', err?.message || err));
+    }
+    return runPromise;
+  }
+
+  return {
+    name: 'testomatio',
+
+    onEvent(event) {
+      try {
+        if (event?.type === 'run-started') startRun();
+      } catch (err) {
+        debug('onEvent failed', err);
+      }
+    },
+
+    async onRunFinished(run, signal) {
+      const reporter = getClient();
+      await startRun();
+
+      const { report, artifactsRoot } = run;
+      const groups = new Map((report.run.serialGroups || []).map(group => [group.id, group]));
+
+      const promises = [];
+      for (const result of report.run.results) {
+        if (signal?.aborted) break;
+        // results left out by `--last-failed` belong to the previous run
+        if (result.selected === false) continue;
+        const { status, data } = toTestData(result, groups, artifactsRoot);
+        promises.push(reporter.addTestRun(status, data));
+      }
+      await Promise.all(promises);
+
+      const duration = (Date.parse(report.run.finishedAt) - Date.parse(report.run.startedAt)) / 1000;
+      await reporter.updateRunStatus(runStatus(report.run.status), { duration });
+
+      const runUrl = reporter.pipeStore?.runUrl;
+      if (runUrl) return [{ label: 'Testomat.io', text: runUrl }];
+    },
+  };
+}
+
+/**
+ * Converts one report-1 result into Testomat.io test data.
+ * Only the final attempt is reported; earlier attempts are counted as retries.
+ */
+export function toTestData(result, groups, artifactsRoot) {
+  const attempts = attemptsOf(result, groups);
+  const final = attempts.at(-1);
+  const titlePath = [...result.titlePath];
+  const title = titlePath.pop();
+
+  let suiteTitle = titlePath.join(' › ');
+  if (!suiteTitle) suiteTitle = path.basename(result.file);
+
+  const meta = {
+    target: result.targetId,
+    platform: result.platform,
+    browser: final?.environment?.browser,
+  };
+  if (result.agent && result.agent !== 'default') meta.agent = result.agent;
+  if (result.repeat) meta.repeat = result.repeat;
+  if (attempts.length > 1) meta.retryCount = attempts.length - 1;
+  if (result.status === 'flaky') meta.isFlaky = true;
+  const status = testStatus(result.status);
+  if (status === STATUS.FAILED && final?.failure?.url) meta.failedUrl = final.failure.url;
+
+  const filesById = new Map();
+  for (const artifact of final?.artifacts || []) {
+    if (artifact.path) {
+      filesById.set(artifact.id, {
+        path: path.join(artifactsRoot, artifact.path),
+        type: artifact.mediaType,
+        title: artifact.kind,
+      });
+    } else if (artifact.url) {
+      // hosted engines keep videos remotely
+      meta[artifact.kind] = artifact.url;
+    }
+  }
+  const files = [...filesById.values()];
+
+  const steps = (final?.steps || []).map(step => toStep(step, filesById));
+
+  const data = {
+    rid: result.id,
+    title,
+    suite_title: suiteTitle,
+    file: result.file,
+    test_id: getTestomatIdFromTestTitle(title),
+    tags: result.tags || [],
+    time: final?.durationMs || 0,
+    timestamp: timestampOf(final),
+    error: toError(final?.error, final?.secondaryErrors),
+    steps: steps.length ? steps : undefined,
+    logs: logsOf(result, final),
+    files: files.length ? files : undefined,
+    meta,
+  };
+
+  return { status, data };
+}
+
+/** Attempts of a result; a serial member keeps its part of the group's attempts. */
+function attemptsOf(result, groups) {
+  if (!result.serialGroupId) return result.attempts || [];
+  const groupAttempts = groups.get(result.serialGroupId)?.attempts || [];
+  return groupAttempts.map(attempt => {
+    const member = attempt.members?.find(candidate => candidate.testId === result.testId);
+    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,
+      durationMs: member?.durationMs,
+      startedAt: member?.startedAt || attempt.startedAt,
+      artifacts: attempt.artifacts || [],
+      secondaryErrors: [...(member?.secondaryErrors || []), ...(attempt.secondaryErrors || [])],
+      environment: attempt.environment,
+    };
+  });
+}
+
+function timestampOf(attempt) {
+  if (!attempt?.startedAt) return undefined;
+  return Date.parse(attempt.startedAt);
+}
+
+function testStatus(status) {
+  if (status === 'passed' || status === 'flaky') return STATUS.PASSED;
+  if (status === 'skipped') return STATUS.SKIPPED;
+  // failed, timed-out, interrupted: the test reached no passing verdict
+  return STATUS.FAILED;
+}
+
+function runStatus(status) {
+  if (status === 'passed') return STATUS.PASSED;
+  return STATUS.FAILED;
+}
+
+function toError(error, secondaryErrors = []) {
+  if (!error) return undefined;
+  /** @type {Error & { expected?: string, actual?: string }} */
+  const err = new Error(error.message);
+  err.name = error.code;
+  err.stack = `${error.code}: ${error.message}\n${error.stack || sourceFrame(error.source)}`;
+  if (error.details?.expected && error.details?.observed) {
+    err.expected = error.details.expected;
+    err.actual = error.details.observed;
+  }
+  for (const secondary of secondaryErrors) {
+    err.stack += `\n\nAlso failed (${secondary.phase || secondary.category}) ${secondary.code}: ${secondary.message}`;
+  }
+  return err;
+}
+
+function sourceFrame(source) {
+  if (!source) return '';
+  return `    at ${source.file}:${source.line}:${source.column}`;
+}
+
+function toStep(step, filesById) {
+  let category = 'user';
+  if (step.phase === 'beforeEach' || step.phase === 'afterEach') category = 'hook';
+
+  let title = step.api;
+  if (step.label) title = `${step.api} ${step.label}`;
+
+  const formatted = formatStep({
+    category,
+    title,
+    duration: step.durationMs,
+    log: stepLog(step),
+  });
+
+  let status = 'failed';
+  if (step.status === 'passed') status = 'passed';
+  addStatusToStep(formatted, status, step.error);
+
+  if (step.error) {
+    formatted.error = { message: truncate(`${step.error.code}: ${step.error.message}`, 250) };
+  }
+
+  if (SCREENSHOTS_ON_STEPS) {
+    const screenshot = (step.artifacts || []).map(id => filesById.get(id)).find(file => file?.type === 'image/png');
+    if (screenshot) addArtifactsToStep(formatted, { screenshot: screenshot.path });
+  }
+
+  return formatted;
+}
+
+/** Agent reasoning and non-binary step statuses, which a passed/failed step would lose. */
+function stepLog(step) {
+  const lines = [];
+  if (step.status !== 'passed' && step.status !== 'failed') lines.push(`status: ${step.status}`);
+  if (step.explanation) lines.push(step.explanation);
+  for (const event of step.events || []) {
+    if (event.reasoning) lines.push(event.reasoning);
+  }
+  return lines.join('\n');
+}
+
+function logsOf(result, final) {
+  const lines = [];
+  const skip = final?.skip || result.skip;
+  if (skip) lines.push(`Skipped (${skip.cause}): ${skip.reason}`);
+  if (final?.appLog?.length) {
+    lines.push('App log:');
+    for (const line of final.appLog) lines.push(`[${line.source}] ${line.level}: ${line.text}`);
+  }
+  return lines.join('\n');
+}
+
+export default testomatio;

package/src/adapter/jasmine.js

@@ -2,6 +2,8 @@ import TestomatClient from '../client.js';
 import { getTestomatIdFromTestTitle, ansiRegExp } from '../utils/utils.js';
 import { STATUS } from '../constants.js';
 
+global.TESTOMATIO_ADAPTER = 'jasmine';
+
 class JasmineReporter {
   constructor(options) {
     this.testTimeMap = {};

package/src/adapter/jest.js

@@ -8,6 +8,8 @@ import createDebugMessages from 'debug';
 
 const debug = createDebugMessages('@testomatio/reporter:adapter-jest');
 
+global.TESTOMATIO_ADAPTER = 'jest';
+
 export class JestReporter {
   constructor(globalConfig, options) {
     this._globalConfig = globalConfig;