@testspectra/cli 1.0.70 → 1.1.1

package/dist/reporter/semantic-formatter.js

@@ -0,0 +1,191 @@
+function extractTargetString(target) {
+    if (!target)
+        return '';
+    if (typeof target === 'string')
+        return target;
+    if (typeof target === 'object') {
+        if (typeof target.selector === 'string')
+            return target.selector;
+        if (typeof target.name === 'string')
+            return target.name;
+        if (typeof target.target === 'string')
+            return target.target;
+    }
+    return String(target);
+}
+function formatElementTarget(target) {
+    const sel = extractTargetString(target);
+    if (!sel)
+        return 'element {target}';
+    if (sel.startsWith('element "') || sel.startsWith('collection "')) {
+        return sel;
+    }
+    return `element "${sel}"`;
+}
+function formatCollectionTarget(target) {
+    const sel = extractTargetString(target);
+    if (!sel)
+        return 'collection "{selector}"';
+    if (sel.startsWith('collection "')) {
+        return sel;
+    }
+    return `collection "${sel}"`;
+}
+/**
+ * Transforms raw matcher assertions and element commands into grammatically correct English sentences.
+ */
+export function formatAction(actionKey, target, args = {}) {
+    const el = formatElementTarget(target);
+    switch (actionKey) {
+        case 'click':
+            return `Click on ${el}`;
+        case 'doubleClick':
+            return `Double-click on ${el}`;
+        case 'rightClick':
+            return `Right-click on ${el}`;
+        case 'type':
+            return `Type "${args.text ?? args.value ?? '{text}'}" into ${el}`;
+        case 'clear':
+            return `Clear text in ${el}`;
+        case 'select':
+        case 'selectOption':
+            return `Select option "${args.option ?? args.value ?? args.text ?? '{option}'}" in ${el}`;
+        case 'hover':
+            return `Hover over ${el}`;
+        case 'dragDrop':
+            const dest = args.dest || args.destination ? formatElementTarget(args.dest || args.destination) : 'element {dest}';
+            return `Drag ${el} and drop onto ${dest}`;
+        case 'scrollIntoView':
+            return `Scroll ${el} into view`;
+        case 'longPress':
+            return `Long-press on ${el} for ${args.durationMs ?? args.ms ?? args.duration ?? '{durationMs}'}ms`;
+        case 'waitForElement':
+            return `Wait for ${el} to be displayed`;
+        case 'navigate':
+            return `Navigate to "${args.url ?? '{url}'}"`;
+        case 'back':
+            return `Navigate back in browser`;
+        case 'forward':
+            return `Navigate forward in browser`;
+        case 'refresh':
+            return `Refresh current page`;
+        case 'setViewport':
+            return `Set viewport to ${args.width ?? '{width}'}x${args.height ?? '{height}'}`;
+        case 'wait':
+            return `Wait for ${args.ms ?? args.durationMs ?? '{ms}'}ms`;
+        case 'pressKey':
+            return `Press keyboard key "${args.key ?? args.value ?? '{key}'}"`;
+        case 'scroll':
+            return `Scroll ${args.direction ?? '{direction}'} by ${args.pixels ?? '{pixels}'}px`;
+        case 'swipe':
+            return `Swipe ${args.direction ?? '{direction}'} by ${args.distance ?? '{distance}'}px`;
+        case 'intercept':
+            return `Intercept ${args.method ?? '{method}'} "${args.url ?? '{url}'}" mock rule registered`;
+        case 'clearCookies':
+            return `Clear all browser cookies`;
+        case 'clearLocalStorage':
+            return `Clear browser localStorage`;
+        default:
+            return `Perform ${actionKey} on ${el}`;
+    }
+}
+export function formatAssertion(assertionKey, target, args = {}) {
+    const el = formatElementTarget(target);
+    const col = formatCollectionTarget(target);
+    switch (assertionKey) {
+        case 'be.visible':
+            return `Expect ${el} to be visible`;
+        case 'not.be.visible':
+            return `Expect ${el} not to be visible`;
+        case 'exist':
+            return `Expect ${el} to exist in DOM`;
+        case 'not.exist':
+            return `Expect ${el} not to exist in DOM`;
+        case 'be.clickable':
+            return `Expect ${el} to be clickable`;
+        case 'not.be.clickable':
+            return `Expect ${el} not to be clickable`;
+        case 'be.enabled':
+            return `Expect ${el} to be enabled`;
+        case 'be.disabled':
+            return `Expect ${el} to be disabled`;
+        case 'be.checked':
+            return `Expect ${el} to be checked`;
+        case 'not.be.checked':
+            return `Expect ${el} not to be checked`;
+        case 'be.selected':
+            return `Expect ${el} to be selected`;
+        case 'not.be.selected':
+            return `Expect ${el} not to be selected`;
+        case 'be.focused':
+            return `Expect ${el} to be focused`;
+        case 'not.be.focused':
+            return `Expect ${el} not to be focused`;
+        case 'have.text':
+            return `Expect ${el} to have text "${args.expected ?? args.text ?? '{str}'}"`;
+        case 'not.have.text':
+            return `Expect ${el} not to have text "${args.expected ?? args.text ?? '{str}'}"`;
+        case 'contain.text':
+            return `Expect ${el} to contain text "${args.expected ?? args.text ?? '{sub}'}"`;
+        case 'not.contain.text':
+            return `Expect ${el} not to contain text "${args.expected ?? args.text ?? '{s}'}"`;
+        case 'have.value':
+            return `Expect ${el} to have value "${args.expected ?? args.value ?? '{val}'}"`;
+        case 'not.have.value':
+            return `Expect ${el} not to have value "${args.expected ?? args.value ?? '{val}'}"`;
+        case 'contain.value':
+            return `Expect ${el} to contain value "${args.expected ?? args.value ?? '{s}'}"`;
+        case 'not.contain.value':
+            return `Expect ${el} not to contain value "${args.expected ?? args.value ?? '{s}'}"`;
+        case 'have.attr':
+            return args.value !== undefined
+                ? `Expect ${el} to have attribute "${args.name ?? args.expected ?? '{k}'}" = "${args.value}"`
+                : `Expect ${el} to have attribute "${args.name ?? args.expected ?? '{k}'}"`;
+        case 'not.have.attr':
+            return `Expect ${el} not to have attribute "${args.name ?? args.expected ?? '{k}'}"`;
+        case 'have.class':
+            return `Expect ${el} to have class "${args.expected ?? args.className ?? '{cls}'}"`;
+        case 'not.have.class':
+            return `Expect ${el} not to have class "${args.expected ?? args.className ?? '{cls}'}"`;
+        case 'have.css':
+            return `Expect ${el} to have CSS "${args.name ?? args.property ?? '{prop}'}" = "${args.value ?? '{val}'}"`;
+        case 'not.have.css':
+            return `Expect ${el} not to have CSS "${args.name ?? args.property ?? '{p}'}" = "${args.value ?? '{v}'}"`;
+        // Collections
+        case 'have.length':
+            return `Expect ${col} count to equal ${args.expected ?? args.length ?? '{n}'}`;
+        case 'not.have.length':
+            return `Expect ${col} count not to equal ${args.expected ?? args.length ?? '{n}'}`;
+        case 'have.length.greaterThan':
+            return `Expect ${col} count to be greater than ${args.expected ?? args.min ?? '{n}'}`;
+        case 'have.length.lessThan':
+            return `Expect ${col} count to be less than ${args.expected ?? args.max ?? '{n}'}`;
+        case 'be.empty':
+            return `Expect ${col} to be empty`;
+        case 'not.be.empty':
+            return `Expect ${col} not to be empty`;
+        // Browser Context
+        case 'have.url':
+        case 'shouldHaveUrl':
+            return `Expect browser URL to be "${args.expected ?? args.url ?? '{url}'}"`;
+        case 'contain.url':
+        case 'shouldContainUrl':
+            return `Expect browser URL to contain "${args.expected ?? args.url ?? '{url}'}"`;
+        case 'have.title':
+        case 'shouldHaveTitle':
+            return `Expect browser title to be "${args.expected ?? args.title ?? '{title}'}"`;
+        case 'contain.title':
+        case 'shouldContainTitle':
+            return `Expect browser title to contain "${args.expected ?? args.title ?? '{title}'}"`;
+        case 'be.loaded':
+        case 'shouldBeLoaded':
+        case 'be.pageLoaded':
+        case 'shouldBePageLoaded':
+            return `Expect page to be fully loaded`;
+        case 'have.noConsoleErrors':
+        case 'shouldHaveNoConsoleErrors':
+            return `Expect browser console to have no errors`;
+        default:
+            return `Expect ${el} to match ${assertionKey}`;
+    }
+}

package/dist/reporter/summary-view.d.ts

@@ -0,0 +1,12 @@
+export interface ExecutionSummary {
+    totalSuites: number;
+    totalTests: number;
+    passedCount: number;
+    failedCount: number;
+    durationMs: number;
+    reportLocation: string;
+}
+/**
+ * Renders the final execution summary box.
+ */
+export declare function renderSummaryView(summary: ExecutionSummary): void;

package/dist/reporter/summary-view.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+/**
+ * Renders the final execution summary box.
+ */
+export function renderSummaryView(summary) {
+    const { totalSuites, totalTests, passedCount, failedCount, durationMs, reportLocation } = summary;
+    const durationSec = (durationMs / 1000).toFixed(2);
+    console.log();
+    console.log(chalk.bold('TestSpectra Execution Summary'));
+    console.log(chalk.gray('────────────────────────────────────────'));
+    console.log(`Suites:    ${chalk.bold(totalSuites)}`);
+    console.log(`Tests:     ${chalk.bold(totalTests)} total, ` +
+        `${passedCount > 0 ? chalk.green.bold(`${passedCount} passed`) : '0 passed'}, ` +
+        `${failedCount > 0 ? chalk.red.bold(`${failedCount} failed`) : '0 failed'}`);
+    console.log(`Duration:  ${durationSec}s`);
+    console.log(`Report:    ${chalk.cyan(reportLocation)}`);
+    console.log(chalk.gray('────────────────────────────────────────'));
+    console.log();
+}

package/dist/reporter/terminal-stream.d.ts

@@ -0,0 +1,32 @@
+export declare class TerminalStream {
+    private spinner;
+    private currentTestTitle;
+    private stepCount;
+    constructor();
+    /**
+     * Starts a new test case, logging the pending bullet and test title.
+     */
+    startTest(title: string): void;
+    /**
+     * Begins a new step, rendering an active spinner on the terminal with 2 spaces indentation.
+     */
+    startStep(text: string): void;
+    /**
+     * Marks the current step as passed, updating the spinner to a green checkmark
+     * and appending the duration in gray with 2 spaces indentation.
+     */
+    passStep(text: string, durationMs: number): void;
+    /**
+     * Marks the current step as failed, updating the spinner to a red cross,
+     * coloring the text red, appending the duration, and optionally logging the error with 2 spaces indentation.
+     */
+    failStep(text: string, durationMs: number, errorMsg?: string): void;
+    /**
+     * Concludes the active test case as passed, overwriting the initial "●" line with "✓" and duration in-place.
+     */
+    passTest(title: string, durationMs: number): void;
+    /**
+     * Concludes the active test case as failed, overwriting the initial "●" line with "✗" and duration in-place.
+     */
+    failTest(title: string, durationMs: number): void;
+}

package/dist/reporter/terminal-stream.js

@@ -0,0 +1,82 @@
+import ora from 'ora';
+import chalk from 'chalk';
+export class TerminalStream {
+    spinner;
+    currentTestTitle = '';
+    stepCount = 0;
+    constructor() {
+        this.spinner = ora({
+            spinner: 'dots',
+            color: 'cyan',
+            prefixText: '  ',
+        });
+    }
+    /**
+     * Starts a new test case, logging the pending bullet and test title.
+     */
+    startTest(title) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        this.currentTestTitle = title;
+        this.stepCount = 0;
+        console.log(`${chalk.hex('#2dd4bf')('●')} ${chalk.white.bold(title)}`);
+    }
+    /**
+     * Begins a new step, rendering an active spinner on the terminal with 2 spaces indentation.
+     */
+    startStep(text) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        this.spinner.start(text);
+    }
+    /**
+     * Marks the current step as passed, updating the spinner to a green checkmark
+     * and appending the duration in gray with 2 spaces indentation.
+     */
+    passStep(text, durationMs) {
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        this.spinner.succeed(`${text} ${durationStr}`);
+        this.stepCount++;
+    }
+    /**
+     * Marks the current step as failed, updating the spinner to a red cross,
+     * coloring the text red, appending the duration, and optionally logging the error with 2 spaces indentation.
+     */
+    failStep(text, durationMs, errorMsg) {
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        this.spinner.fail(`${chalk.red(text)} ${durationStr}`);
+        this.stepCount++;
+        if (errorMsg) {
+            console.error(chalk.red(`    ↳ ${errorMsg}`));
+            this.stepCount++;
+        }
+    }
+    /**
+     * Concludes the active test case as passed, overwriting the initial "●" line with "✓" and duration in-place.
+     */
+    passTest(title, durationMs) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        const testTitle = title || this.currentTestTitle;
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        const completedHeader = `${chalk.hex('#34d399')('✓')} ${chalk.white.bold(testTitle)} ${durationStr}`;
+        const linesToMoveUp = this.stepCount + 1;
+        process.stdout.write(`\x1b[${linesToMoveUp}A\r\x1b[2K${completedHeader}\x1b[${linesToMoveUp}B\r\n`);
+    }
+    /**
+     * Concludes the active test case as failed, overwriting the initial "●" line with "✗" and duration in-place.
+     */
+    failTest(title, durationMs) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        const testTitle = title || this.currentTestTitle;
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        const completedHeader = `${chalk.hex('#f87171')('✗')} ${chalk.white.bold(testTitle)} ${durationStr}`;
+        const linesToMoveUp = this.stepCount + 1;
+        process.stdout.write(`\x1b[${linesToMoveUp}A\r\x1b[2K${completedHeader}\x1b[${linesToMoveUp}B\r\n`);
+    }
+}

package/dist/reporter/types.d.ts

@@ -0,0 +1,2 @@
+export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'intercept' | 'clearCookies' | 'clearLocalStorage';
+export type AssertionKey = 'be.visible' | 'not.be.visible' | 'exist' | 'not.exist' | 'be.clickable' | 'not.be.clickable' | 'be.enabled' | 'be.disabled' | 'be.checked' | 'not.be.checked' | 'be.selected' | 'not.be.selected' | 'be.focused' | 'not.be.focused' | 'have.text' | 'not.have.text' | 'contain.text' | 'not.contain.text' | 'have.value' | 'not.have.value' | 'contain.value' | 'not.contain.value' | 'have.attr' | 'not.have.attr' | 'have.class' | 'not.have.class' | 'have.css' | 'not.have.css' | 'have.length' | 'not.have.length' | 'have.length.greaterThan' | 'have.length.lessThan' | 'be.empty' | 'not.be.empty' | 'shouldHaveUrl' | 'shouldContainUrl' | 'shouldHaveTitle' | 'shouldContainTitle' | 'shouldBeLoaded' | 'shouldBePageLoaded' | 'shouldHaveNoConsoleErrors' | 'have.url' | 'contain.url' | 'have.title' | 'contain.title' | 'be.loaded' | 'be.pageLoaded' | 'have.noConsoleErrors';

package/dist/reporter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/bridge.d.ts

@@ -1,18 +1,23 @@
-import { ConfigData } from "../config/schema.js";
-import { Reporter, TestRunResult } from "./reporter.js";
+import { ConfigData } from '../config/schema.js';
+import { Reporter, TestRunResult } from './reporter.js';
 export interface RunOptions {
     baseDir: string;
     appDataPath: string;
-    platform: "web" | "android" | "ios" | "common";
-    suite: string;
-    testCases: Array<{
+    platform: 'web' | 'android' | 'ios' | 'common' | 'mobile';
+    suite?: string;
+    testCases?: Array<{
         id: string;
         title: string;
         executionOrder?: number;
     }>;
     config: ConfigData;
     targetDevice?: string;
+    licenseKey?: string;
     outputJsonPath?: string;
+    spec?: string;
+    concurrency?: number;
+    failedOnly?: boolean;
+    failedTarget?: string;
 }
 export declare class RustCoreBridge {
     static resolveBinaryPath(): string;

package/dist/runner/bridge.js

@@ -1,19 +1,25 @@
-import { spawn } from "child_process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class RustCoreBridge {
     static resolveBinaryPath() {
         // 1. Look for precompiled release/debug binary in workspace target
-        const workspaceRoot = path.resolve(__dirname, "../../..");
+        const workspaceRoot = path.resolve(__dirname, '../../..');
+        const isWindows = process.platform === 'win32';
+        const binaryName = isWindows ? 'testspectra-runner.exe' : 'testspectra-runner';
         const candidatePaths = [
-            path.join(workspaceRoot, "target/debug/testspectra-runner"),
-            path.join(workspaceRoot, "target/release/testspectra-runner"),
-            path.join(workspaceRoot, "core/test-runner/target/debug/testspectra-runner"),
-            path.join(workspaceRoot, "core/test-runner/target/release/testspectra-runner"),
-            path.join(__dirname, "../../bin/testspectra-runner"),
+            path.join(workspaceRoot, 'core/target/release', binaryName),
+            path.join(workspaceRoot, 'target/release', binaryName),
+            path.join(workspaceRoot, 'cli/bin', binaryName),
+            path.join(__dirname, '../../bin', binaryName),
+            path.join(workspaceRoot, 'core/cli/target/release', binaryName),
+            path.join(workspaceRoot, 'core/target/debug', binaryName),
+            path.join(workspaceRoot, 'target/debug', binaryName),
+            path.join(workspaceRoot, 'core/cli/target/debug', binaryName),
+            path.join(__dirname, '../../bin/testspectra-runner'),
         ];
         for (const p of candidatePaths) {
             if (fs.existsSync(p)) {
@@ -23,7 +29,8 @@ export class RustCoreBridge {
                 return `${p}.exe`;
             }
         }
-        return "cargo"; // Fallback to cargo run
+        throw new Error("[TestSpectra] Native core runner binary 'testspectra-runner' not found.\n" +
+            "Please build the project first using 'pnpm run build' or 'pnpm run build:core'.");
     }
     static async run(options, reporter) {
         const binPath = this.resolveBinaryPath();
@@ -35,9 +42,15 @@ export class RustCoreBridge {
             testCases: options.testCases,
             config: options.config,
             targetDevice: options.targetDevice,
+            licenseKey: options.licenseKey,
+            outputJsonPath: options.outputJsonPath,
+            spec: options.spec,
+            concurrency: options.concurrency,
+            failedOnly: options.failedOnly,
+            failedTarget: options.failedTarget,
         });
-        const home = process.env.HOME || process.env.USERPROFILE || "";
-        const globalDriversDir = path.join(home, ".testspectra", "drivers");
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const globalDriversDir = path.join(home, '.testspectra', 'drivers');
         if (!fs.existsSync(globalDriversDir)) {
             try {
                 fs.mkdirSync(globalDriversDir, { recursive: true });
@@ -47,39 +60,37 @@ export class RustCoreBridge {
         const runnerEnv = {
             ...process.env,
             TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
-            RUST_LOG: "info",
+            RUST_LOG: 'info',
         };
         return new Promise((resolve, reject) => {
-            let child;
-            if (binPath === "cargo") {
-                const workspaceRoot = path.resolve(__dirname, "../../..");
-                child = spawn("cargo", ["run", "--manifest-path", "core/test-runner/Cargo.toml", "--bin", "testspectra-runner", "--", payload], {
-                    cwd: workspaceRoot,
-                    env: runnerEnv,
-                });
-            }
-            else {
-                child = spawn(binPath, [payload], {
-                    env: runnerEnv,
-                });
-            }
-            let runStatus = "failed";
-            let runDuration = "0s";
-            child.stdout.on("data", (data) => {
-                const lines = data.toString().split("\n");
+            const child = spawn(binPath, [payload], {
+                env: runnerEnv,
+            });
+            let runStatus = 'failed';
+            let runDuration = '0s';
+            child.stdout.on('data', (data) => {
+                const lines = data.toString().split('\n');
                 for (const line of lines) {
                     if (!line.trim())
                         continue;
+                    if (line.startsWith('[TESTSPECTRA_')) {
+                        reporter.addLog({
+                            timestamp: new Date().toLocaleTimeString(),
+                            level: 'INFO',
+                            message: line,
+                        });
+                        continue;
+                    }
                     try {
                         const parsed = JSON.parse(line);
-                        if (parsed.type === "log") {
+                        if (parsed.type === 'log') {
                             reporter.addLog({
                                 timestamp: parsed.timestamp,
                                 level: parsed.level,
                                 message: parsed.message,
                             });
                         }
-                        else if (parsed.type === "network") {
+                        else if (parsed.type === 'network') {
                             reporter.addNetwork({
                                 requestId: parsed.requestId,
                                 url: parsed.url,
@@ -87,14 +98,14 @@ export class RustCoreBridge {
                                 status: parsed.status,
                             });
                         }
-                        else if (parsed.type === "complete") {
+                        else if (parsed.type === 'complete') {
                             runStatus = parsed.status;
                             runDuration = parsed.duration;
                         }
-                        else if (parsed.type === "error") {
+                        else if (parsed.type === 'error') {
                             reporter.addLog({
                                 timestamp: new Date().toLocaleTimeString(),
-                                level: "ERROR",
+                                level: 'ERROR',
                                 message: parsed.message,
                             });
                         }
@@ -105,29 +116,43 @@ export class RustCoreBridge {
                     }
                 }
             });
-            child.stderr.on("data", (data) => {
+            child.stderr.on('data', (data) => {
                 const str = data.toString();
                 // Ignore normal compilation progress
-                if (!str.includes("Compiling") && !str.includes("Checking") && !str.includes("Finished")) {
+                if (!str.includes('Compiling') && !str.includes('Checking') && !str.includes('Finished')) {
                     reporter.addLog({
                         timestamp: new Date().toLocaleTimeString(),
-                        level: "DEBUG",
+                        level: 'DEBUG',
                         message: str.trim(),
                     });
                 }
             });
-            child.on("close", (code) => {
-                const result = reporter.generateResult(code === 0 ? "passed" : runStatus, runDuration);
-                if (options.outputJsonPath) {
+            child.on('close', (code) => {
+                let result = reporter.generateResult(code === 0 ? 'passed' : runStatus, runDuration);
+                if (options.outputJsonPath && fs.existsSync(options.outputJsonPath)) {
+                    try {
+                        const raw = fs.readFileSync(options.outputJsonPath, 'utf-8');
+                        const parsed = JSON.parse(raw);
+                        if (parsed.version && parsed.summary) {
+                            result.status = parsed.status || result.status;
+                            result.duration = parsed.duration || result.duration;
+                            result.passedCount = parsed.summary.passed;
+                            result.failedCount = parsed.summary.failed;
+                            return resolve(result);
+                        }
+                    }
+                    catch { }
+                }
+                else if (options.outputJsonPath) {
                     const outDir = path.dirname(options.outputJsonPath);
                     if (!fs.existsSync(outDir)) {
                         fs.mkdirSync(outDir, { recursive: true });
                     }
-                    fs.writeFileSync(options.outputJsonPath, JSON.stringify(result, null, 2), "utf-8");
+                    fs.writeFileSync(options.outputJsonPath, JSON.stringify(result, null, 2), 'utf-8');
                 }
                 resolve(result);
             });
-            child.on("error", (err) => {
+            child.on('error', (err) => {
                 reject(err);
             });
         });

package/dist/runner/reporter.d.ts

@@ -1,6 +1,6 @@
 export interface TestLog {
     timestamp: string;
-    level: "INFO" | "SUCCESS" | "WARNING" | "ERROR" | "DEBUG" | string;
+    level: 'INFO' | 'SUCCESS' | 'WARNING' | 'ERROR' | 'DEBUG' | string;
     message: string;
 }
 export interface NetworkResource {
@@ -10,14 +10,42 @@ export interface NetworkResource {
     status: number;
 }
 export interface TestRunResult {
-    status: "passed" | "failed" | "error" | string;
+    status: 'passed' | 'failed' | 'error' | string;
     duration: string;
+    passedCount: number;
+    failedCount: number;
     logs: TestLog[];
     networkResources?: NetworkResource[];
 }
+export interface PendingStep {
+    text: string;
+    duration: number;
+    passed: boolean;
+}
+export interface PendingTestCase {
+    title: string;
+    workerId?: number;
+    steps: PendingStep[];
+    currentStep?: string;
+    errorMsg?: string;
+    startTime: number;
+}
 export declare class Reporter {
     private logs;
     private networkEvents;
+    private pendingTests;
+    private workerToTest;
+    private passedCount;
+    private failedCount;
+    private isInteractive;
+    private lastRenderedLines;
+    private spinnerFrames;
+    private spinnerIndex;
+    private spinnerTimer;
+    constructor();
+    private clearActiveSlots;
+    private renderActiveSlots;
+    private resolveTestCase;
     addLog(log: TestLog): void;
     addNetwork(res: NetworkResource): void;
     getLogs(): TestLog[];