@testspectra/cli 1.0.69 → 1.1.0

package/dist/commands/install.d.ts

@@ -0,0 +1,4 @@
+export declare function installCommand(item?: string, options?: {
+    force?: boolean;
+    cwd?: string;
+}): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { RustCoreBridge } from '../runner/bridge.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function installCommand(item, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalDriversDir = path.join(home, '.testspectra', 'drivers');
+    const runnerEnv = {
+        ...process.env,
+        TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
+    };
+    const args = ['install'];
+    if (item) {
+        args.push(item);
+    }
+    return new Promise((resolve) => {
+        let child;
+        if (binPath === 'cargo') {
+            const workspaceRoot = path.resolve(__dirname, '../../..');
+            const cargoArgs = [
+                'run',
+                '--manifest-path',
+                'core/test-runner/Cargo.toml',
+                '--bin',
+                'testspectra-runner',
+                '--',
+                ...args,
+            ];
+            child = spawn('cargo', cargoArgs, {
+                cwd: workspaceRoot,
+                env: runnerEnv,
+                stdio: 'inherit',
+            });
+        }
+        else {
+            child = spawn(binPath, args, {
+                cwd,
+                env: runnerEnv,
+                stdio: 'inherit',
+            });
+        }
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                process.exit(code ?? 1);
+            }
+        });
+        child.on('error', (err) => {
+            console.error(`[TestSpectra Install Error] ${err.message}`);
+            process.exit(1);
+        });
+    });
+}

package/dist/commands/license.d.ts

@@ -0,0 +1,4 @@
+export interface LicenseCommandOptions {
+    json?: boolean;
+}
+export declare function licenseCommand(action?: string, key?: string, options?: LicenseCommandOptions): Promise<void>;

package/dist/commands/license.js

@@ -0,0 +1,30 @@
+import { spawn } from 'child_process';
+import { RustCoreBridge } from '../runner/bridge.js';
+export async function licenseCommand(action = 'status', key, options = {}) {
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const normalizedAction = action.toLowerCase().trim();
+    const args = ['license', normalizedAction];
+    if (key && normalizedAction === 'activate') {
+        args.push(key.trim());
+    }
+    if (options.json) {
+        args.push('--json');
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                process.exit(code ?? 1);
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}

package/dist/commands/refactor.d.ts

@@ -0,0 +1,8 @@
+export interface RefactorCommandOptions {
+    cwd?: string;
+    dryRun?: boolean;
+    json?: boolean;
+    from?: string;
+    to?: string;
+}
+export declare function refactorCommand(entityType?: string, oldName?: string, newName?: string, options?: RefactorCommandOptions): Promise<void>;

package/dist/commands/refactor.js

@@ -0,0 +1,78 @@
+import path from 'path';
+import { RefactorEngine } from '../refactor/refactor-engine.js';
+export async function refactorCommand(entityType, oldName, newName, options = {}) {
+    const workspaceRoot = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    let targetType = 'page-object';
+    let fromSymbol = oldName || '';
+    let toSymbol = newName || '';
+    if (options.from && options.to) {
+        // Path-based refactoring
+        if (options.from.includes('page-objects')) {
+            targetType = 'page-object';
+            fromSymbol = path.basename(options.from);
+            toSymbol = path.basename(options.to);
+        }
+        else if (options.from.includes('steps')) {
+            targetType = 'step';
+            fromSymbol = path.basename(options.from);
+            toSymbol = path.basename(options.to);
+        }
+        else if (options.from.includes('actions')) {
+            targetType = 'action';
+            fromSymbol = path.basename(options.from);
+            toSymbol = path.basename(options.to);
+        }
+        else if (options.from.includes('fixtures')) {
+            targetType = 'fixture';
+            fromSymbol = path.parse(options.from).name;
+            toSymbol = path.parse(options.to).name;
+        }
+    }
+    else {
+        if (!entityType || !oldName || !newName) {
+            console.error('Usage: spectra refactor <page-object|step|action|fixture> <oldName> <newName>');
+            process.exit(1);
+        }
+        const normalized = entityType.toLowerCase().replace(/_/g, '-');
+        if (['page-object', 'po', 'page'].includes(normalized)) {
+            targetType = 'page-object';
+        }
+        else if (['step', 'steps'].includes(normalized)) {
+            targetType = 'step';
+        }
+        else if (['action', 'actions'].includes(normalized)) {
+            targetType = 'action';
+        }
+        else if (['fixture', 'fixtures'].includes(normalized)) {
+            targetType = 'fixture';
+        }
+        else {
+            console.error(`Unknown refactor entity type: "${entityType}". Valid types: page-object, step, action, fixture.`);
+            process.exit(1);
+        }
+    }
+    const result = await RefactorEngine.renameSymbol({
+        workspaceRoot,
+        type: targetType,
+        oldName: fromSymbol,
+        newName: toSymbol,
+        dryRun: options.dryRun,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.status === 'success') {
+        const modeStr = options.dryRun ? '[Dry-Run] ' : '';
+        console.log(`\x1b[32m✓ ${modeStr}Refactored ${result.entityType} "${result.oldSymbol}" → "${result.newSymbol}"\x1b[0m`);
+        console.log(`  Modified files: ${result.modifiedFiles.length}`);
+        console.log(`  Occurrences replaced: ${result.occurrencesReplaced}`);
+        for (const f of result.modifiedFiles) {
+            console.log(`    ↳ ${f}`);
+        }
+    }
+    else {
+        console.error(`\x1b[31m✗ Refactoring failed: ${result.error}\x1b[0m`);
+        process.exit(1);
+    }
+}

package/dist/commands/run.d.ts

@@ -1,10 +1,31 @@
 export interface RunCommandOptions {
     spec?: string;
-    target?: "web" | "android" | "ios" | "common";
+    target?: 'web' | 'android' | 'ios' | 'common' | 'mobile';
     device?: string;
+    devices?: string;
+    allDevices?: boolean;
+    multiDevice?: boolean;
     headless?: boolean;
+    headed?: boolean;
+    stepDelay?: string | number;
+    delay?: string | number;
     workdir?: string;
     output?: string;
     demo?: boolean;
+    failed?: boolean | string;
+    concurrency?: string | number;
+    licenseKey?: string;
 }
+export declare function renderTimingBreakdown(performance: {
+    masterBootLatencyMs?: number;
+    avgContextCreationMs?: number;
+    avgCdpHandshakeMs?: number;
+    avgTestExecutionMs?: number;
+    totalTestExecutionMs?: number;
+    runnerOverheadMs?: number;
+    avgTeardownMs?: number;
+    wallClockDurationMs?: number;
+    totalTests?: number;
+    duration?: string;
+}): void;
 export declare function runCommand(specPath?: string, options?: RunCommandOptions): Promise<void>;

package/dist/commands/run.js

@@ -1,134 +1,277 @@
-import fs from "fs";
-import path from "path";
-import { ConfigLoader } from "../config/loader.js";
-import { RustCoreBridge } from "../runner/bridge.js";
-import { Reporter } from "../runner/reporter.js";
-import { TypeGenerator } from "../types/generator.js";
-import { DemoServer } from "../utils/demo-server.js";
+import fs from 'fs';
+import path from 'path';
+import { ConfigLoader } from '../config/loader.js';
+import { RustCoreBridge } from '../runner/bridge.js';
+import { Reporter } from '../runner/reporter.js';
+import { TypeGenerator } from '../types/generator.js';
+import { DemoServer } from '../utils/demo-server.js';
+function renderSummaryCard(options) {
+    const width = 64;
+    const borderColor = options.isPassed ? '\x1b[38;2;52;211;153m' : '\x1b[38;2;248;113;113m';
+    const reset = '\x1b[0m';
+    const boldWhite = '\x1b[1;37m';
+    const dim = '\x1b[90m';
+    const cyan = '\x1b[38;2;45;212;191m';
+    const yellow = '\x1b[38;2;251;191;36m';
+    const green = '\x1b[38;2;52;211;153m';
+    const red = '\x1b[38;2;248;113;113m';
+    const strip = (s) => s.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+    const visualWidth = (s) => {
+        const plain = strip(s);
+        let w = 0;
+        for (const ch of plain) {
+            const code = ch.codePointAt(0) || 0;
+            if (code >= 0x1f300 || (code >= 0x2600 && code <= 0x27bf)) {
+                w += 2;
+            }
+            else {
+                w += 1;
+            }
+        }
+        return w;
+    };
+    const row = (label, value) => {
+        const rawLen = visualWidth(label) + visualWidth(value);
+        const padding = Math.max(1, width - rawLen);
+        return `  ${borderColor}│${reset}  ${label}${' '.repeat(padding)}${value}  ${borderColor}│${reset}`;
+    };
+    const headerRow = (title) => {
+        const rawLen = visualWidth(title);
+        const padding = Math.max(1, width - rawLen);
+        return `  ${borderColor}│${reset}  ${title}${' '.repeat(padding)}  ${borderColor}│${reset}`;
+    };
+    const top = `  ${borderColor}╭${'─'.repeat(width + 4)}╮${reset}`;
+    const mid = `  ${borderColor}├${'─'.repeat(width + 4)}┤${reset}`;
+    const bot = `  ${borderColor}╰${'─'.repeat(width + 4)}╯${reset}`;
+    const statusBadge = options.isPassed ? `${green}✓ PASSED${reset}` : `${red}✗ FAILED${reset}`;
+    const passedSuites = options.passedSuites ?? (options.isPassed ? options.suiteCount : 0);
+    const failedSuites = options.failedSuites ?? (options.isPassed ? 0 : options.suiteCount);
+    console.log(`\n${top}`);
+    console.log(headerRow(`${boldWhite}✨  TESTSPECTRA EXECUTION SUMMARY${reset}`));
+    console.log(mid);
+    console.log(row(`${dim}Status${reset}`, statusBadge));
+    console.log(row(`${dim}Suites${reset}`, `${passedSuites > 0 ? `${green}${passedSuites} passed${reset}` : `${passedSuites} passed`}, ` +
+        `${failedSuites > 0 ? `${red}${failedSuites} failed${reset}` : `${failedSuites} failed`} ` +
+        `${dim}(${options.suiteCount} total)${reset}`));
+    console.log(row(`${dim}Tests${reset}`, `${options.passedCount > 0 ? `${green}${options.passedCount} passed${reset}` : `${options.passedCount} passed`}, ` +
+        `${options.failedCount > 0 ? `${red}${options.failedCount} failed${reset}` : `${options.failedCount} failed`} ` +
+        `${dim}(${options.testCount} total)${reset}`));
+    console.log(row(`${dim}Platform${reset}`, `${cyan}${options.platform}${reset}`));
+    console.log(row(`${dim}Duration${reset}`, `${yellow}${options.duration}${reset}`));
+    console.log(row(`${dim}Report${reset}`, `${dim}${options.reportPath}${reset}`));
+    if (options.networkReportPath) {
+        console.log(row(`${dim}Network${reset}`, `${dim}${options.networkReportPath}${reset}`));
+    }
+    console.log(`${bot}\n`);
+}
+export function renderTimingBreakdown(performance) {
+    const yellowBold = '\x1b[1;38;2;251;191;36m';
+    const reset = '\x1b[0m';
+    const borderColor = '\x1b[38;2;75;85;99m';
+    const pad = (str, width) => {
+        const s = String(str);
+        return ' '.repeat(Math.max(0, width - s.length)) + s;
+    };
+    const padRight = (str, width) => {
+        const s = String(str);
+        return s + ' '.repeat(Math.max(0, width - s.length));
+    };
+    const wallClock = performance.duration
+        ? performance.duration
+        : `${((performance.wallClockDurationMs ?? 0) / 1000).toFixed(2)}s`;
+    const totalTests = performance.totalTests ?? 1;
+    const totalTestExecMs = performance.totalTestExecutionMs ?? (performance.avgTestExecutionMs ?? 0) * totalTests;
+    const avgTestExecMs = performance.avgTestExecutionMs ?? (totalTests > 0 ? Math.round(totalTestExecMs / totalTests) : 0);
+    const contextHandshakeMs = (performance.avgContextCreationMs ?? 0) + (performance.avgCdpHandshakeMs ?? 0);
+    const testLabel = totalTests === 1 ? '4. Total Test Execution (1 test)' : `4. Total Test Execution (${totalTests} tests)`;
+    const testDetail = totalTests <= 1 ? `${pad(totalTestExecMs, 13)} ms` : `${pad(totalTestExecMs, 5)} ms (${pad(avgTestExecMs, 3)}ms/t)`;
+    console.log(`⏱️  ${yellowBold}EXECUTION TIMING BREAKDOWN (PHASE-BY-PHASE)${reset}`);
+    console.log(`${borderColor}┌──────────────────────────────────────────┬───────────────────┐${reset}`);
+    console.log(`${borderColor}│${reset} Execution Phase                          ${borderColor}│${reset} Duration / Detail ${borderColor}│${reset}`);
+    console.log(`${borderColor}├──────────────────────────────────────────┼───────────────────┤${reset}`);
+    console.log(`${borderColor}│${reset} 1. Master Chromium Process Boot          ${borderColor}│${reset} ${pad(performance.masterBootLatencyMs ?? 0, 13)} ms ${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} 2. Worker Spawning & Runtime Overhead    ${borderColor}│${reset} ${pad(performance.runnerOverheadMs ?? 0, 13)} ms ${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} 3. Incognito Context & CDP Handshake     ${borderColor}│${reset} ${pad(contextHandshakeMs, 10)} ms (avg)${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} ${padRight(testLabel, 40)} ${borderColor}│${reset} ${pad(testDetail, 17)} ${borderColor}│${reset}`);
+    console.log(`${borderColor}│${reset} 5. Context Teardown / Cleanup            ${borderColor}│${reset} ${pad(performance.avgTeardownMs ?? 0, 10)} ms (avg)${borderColor}│${reset}`);
+    console.log(`${borderColor}├──────────────────────────────────────────┼───────────────────┤${reset}`);
+    console.log(`${borderColor}│${reset} Total Wall-Clock Execution Time          ${borderColor}│${reset} ${pad(wallClock, 15)} ${borderColor}│${reset}`);
+    console.log(`${borderColor}└──────────────────────────────────────────┴───────────────────┘${reset}\n`);
+}
 export async function runCommand(specPath, options = {}) {
     const cwd = process.cwd();
     const effectiveSpecPath = specPath || options.spec;
     // Ensure latest ambient types are up-to-date
     TypeGenerator.writeDeclarationFiles(cwd);
-    const config = await ConfigLoader.loadConfig(cwd);
-    let demoServer = null;
-    if (options.demo) {
-        demoServer = new DemoServer(5173);
-        try {
-            const { url } = await demoServer.start();
-            config.webConfig.baseUrl = url;
-            console.log(`\x1b[36m[TestSpectra]\x1b[0m 🌐 Demo Web App automatically started at: \x1b[33m${url}\x1b[0m`);
-        }
-        catch (err) {
-            console.warn(`\x1b[33m[TestSpectra] Warning: Could not start built-in demo server: ${err.message}\x1b[0m`);
-        }
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalAppDataPath = path.join(home, '.testspectra');
+    const appDataPath = options.workdir ? path.resolve(options.workdir) : globalAppDataPath;
+    if (!fs.existsSync(appDataPath)) {
+        fs.mkdirSync(appDataPath, { recursive: true });
     }
-    if (options.headless !== undefined) {
-        config.webConfig.headlessMode = options.headless;
+    const projectAppData = path.join(cwd, '.testspectra');
+    const outputJsonPath = options.output
+        ? path.resolve(options.output)
+        : path.join(projectAppData, 'reports', 'result.json');
+    const isFailedMode = options.failed !== undefined;
+    let failedTarget;
+    if (typeof options.failed === 'string' && options.failed !== 'true') {
+        failedTarget = options.failed;
     }
-    const platform = options.target || "web";
-    // Find workspace root for centralized .testspectra (monorepo root or current test project)
-    let workspaceRoot = cwd;
-    let cur = cwd;
-    while (cur !== path.dirname(cur)) {
-        if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml")) || fs.existsSync(path.join(cur, "nx.json"))) {
-            workspaceRoot = cur;
-            break;
+    if (isFailedMode) {
+        if (fs.existsSync(outputJsonPath)) {
+            try {
+                const prev = JSON.parse(fs.readFileSync(outputJsonPath, 'utf8'));
+                const failedItems = (prev.suites || []).flatMap((s) => (s.tests || []).filter((t) => t.passed === false || t.status === 'failed'));
+                if (failedItems.length === 0) {
+                    console.log(`\x1b[32m✨ [TestSpectra] No failed tests found in previous test session! Everything is already passing.\x1b[0m\n`);
+                    return;
+                }
+                const targetDesc = failedTarget ? `target '${failedTarget}' in` : '';
+                console.log(`\x1b[36m[TestSpectra]\x1b[0m 🔄 Re-running ${targetDesc} ${failedItems.length} failed test(s) with session state carry-over...`);
+            }
+            catch { }
         }
-        cur = path.dirname(cur);
-    }
-    const appDataPath = options.workdir ? path.resolve(options.workdir) : path.join(workspaceRoot, ".testspectra");
-    if (!fs.existsSync(appDataPath)) {
-        fs.mkdirSync(appDataPath, { recursive: true });
     }
-    // Determine suite/test case name
-    let suiteName = "default";
-    let testCases = [];
-    if (effectiveSpecPath) {
-        const relSpec = path.isAbsolute(effectiveSpecPath) ? path.relative(cwd, effectiveSpecPath) : effectiveSpecPath;
-        const normalized = relSpec.replace(/\\/g, "/");
-        const parts = normalized.split("/");
-        if (parts.length >= 2 && (parts[0] === "specs" || parts[0] === "suites")) {
-            suiteName = parts[1];
+    const config = await ConfigLoader.loadConfig(cwd);
+    let demoServer = null;
+    try {
+        if (options.demo) {
+            demoServer = new DemoServer(5173);
+            try {
+                const { url } = await demoServer.start();
+                config.webConfig.baseUrl = url;
+                console.log(`\x1b[36m[TestSpectra]\x1b[0m 🌐 Demo Web App automatically started at: \x1b[33m${url}\x1b[0m`);
+            }
+            catch (err) {
+                console.warn(`\x1b[33m[TestSpectra] Warning: Could not start built-in demo server: ${err.message}\x1b[0m`);
+            }
         }
-        else {
-            const parsed = path.parse(normalized);
-            suiteName = parsed.name.replace(/\.(web|android|ios|common|test|spec)/g, "") || "default";
+        if (options.headed) {
+            config.webConfig.headless = false;
         }
-        testCases.push({
-            id: normalized,
-            title: normalized,
-            executionOrder: 1,
-        });
-    }
-    else {
-        // 1. Scan specs/ directory (specs/<Suite>/<CaseId>/web.test.ts)
-        const specsDir = path.join(cwd, "specs");
-        if (fs.existsSync(specsDir)) {
-            const suiteEntries = fs.readdirSync(specsDir, { withFileTypes: true });
-            for (const sEntry of suiteEntries) {
-                if (sEntry.name.startsWith(".") || !sEntry.isDirectory())
-                    continue;
-                const currentSuite = sEntry.name;
-                const suitePath = path.join(specsDir, currentSuite);
-                const caseEntries = fs.readdirSync(suitePath, { withFileTypes: true });
-                for (const cEntry of caseEntries) {
-                    if (cEntry.name.startsWith(".") || cEntry.name === "hooks")
-                        continue;
-                    if (cEntry.isDirectory()) {
-                        testCases.push({ id: path.join("specs", currentSuite, cEntry.name).replace(/\\/g, "/"), title: `${currentSuite} / ${cEntry.name}` });
-                    }
-                    else if (cEntry.isFile() && (cEntry.name.endsWith(".test.ts") || cEntry.name.endsWith(".spec.ts"))) {
-                        const id = path.join("specs", currentSuite, cEntry.name).replace(/\\/g, "/");
-                        testCases.push({ id, title: `${currentSuite} / ${cEntry.name}` });
-                    }
-                }
+        else if (options.headless !== undefined) {
+            config.webConfig.headless = options.headless;
+        }
+        const rawDelay = options.stepDelay ?? options.delay;
+        if (rawDelay !== undefined) {
+            const delayNum = parseInt(String(rawDelay), 10);
+            if (!isNaN(delayNum) && delayNum >= 0) {
+                config.webConfig.stepDelay = delayNum;
+                config.androidConfig.stepDelay = delayNum;
+                config.iosConfig.stepDelay = delayNum;
             }
         }
-        // 2. Fallback: Scan suites/ directory
-        const suitesDir = path.join(cwd, "suites");
-        if (fs.existsSync(suitesDir)) {
-            const suiteEntries = fs.readdirSync(suitesDir, { withFileTypes: true });
-            for (const sEntry of suiteEntries) {
-                if (sEntry.name.startsWith(".") || !sEntry.isDirectory())
-                    continue;
-                const currentSuite = sEntry.name;
-                const suitePath = path.join(suitesDir, currentSuite);
-                const caseEntries = fs.readdirSync(suitePath, { withFileTypes: true });
-                for (const cEntry of caseEntries) {
-                    if (cEntry.name.startsWith(".") || cEntry.name === "hooks" || !cEntry.isDirectory())
-                        continue;
-                    testCases.push({ id: path.join("suites", currentSuite, cEntry.name).replace(/\\/g, "/"), title: `${currentSuite} / ${cEntry.name}` });
-                }
+        const platform = options.target || 'web';
+        const userConcurrency = options.concurrency ? parseInt(String(options.concurrency), 10) : undefined;
+        console.log(`\x1b[36m[TestSpectra]\x1b[0m Starting execution on target \x1b[1m${platform}\x1b[0m...`);
+        if (options.devices || options.device) {
+            const rawDevices = (options.devices || options.device);
+            const devIds = rawDevices.includes(',')
+                ? rawDevices
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+                : [rawDevices.trim()].filter(Boolean);
+            const mappedDevices = devIds.map((id) => ({ id }));
+            if (platform === 'ios') {
+                config.iosConfig.devices = mappedDevices;
+            }
+            else {
+                config.androidConfig.devices = mappedDevices;
             }
+            const count = devIds.length;
+            const desc = devIds.join(', ');
+            console.log(`\x1b[36m[TestSpectra Grid]\x1b[0m Mobile device target configured (${count} device(s)): ${desc}`);
         }
-    }
-    if (testCases.length === 0) {
-        testCases.push({
-            id: suiteName,
-            title: suiteName,
-            executionOrder: 1,
-        });
-    }
-    const outputJsonPath = options.output
-        ? path.resolve(options.output)
-        : path.join(appDataPath, "reports/result.json");
-    console.log(`\x1b[36m[TestSpectra]\x1b[0m Starting execution on target \x1b[1m${platform}\x1b[0m...`);
-    console.log(`\x1b[36m[TestSpectra]\x1b[0m Base URL: \x1b[33m${config.webConfig.baseUrl}\x1b[0m`);
-    console.log(`\x1b[36m[TestSpectra]\x1b[0m Suite: ${suiteName} (${testCases.length} case(s))\n`);
-    const reporter = new Reporter();
-    try {
+        else if (options.allDevices || options.multiDevice) {
+            if (platform === 'ios') {
+                config.iosConfig.devices = 'auto';
+            }
+            else {
+                config.androidConfig.devices = 'auto';
+            }
+            console.log('\x1b[36m[TestSpectra Grid]\x1b[0m Multi-device grid enabled (auto-detecting connected devices)');
+        }
+        console.log(`\x1b[36m[TestSpectra]\x1b[0m Base URL: \x1b[33m${config.webConfig.baseUrl}\x1b[0m\n`);
+        const reporter = new Reporter();
+        const targetDevice = options.devices || options.device || (options.allDevices || options.multiDevice ? 'auto' : undefined);
         const result = await RustCoreBridge.run({
             baseDir: cwd,
             appDataPath,
             platform,
-            suite: suiteName,
-            testCases,
             config,
-            targetDevice: options.device,
+            targetDevice,
+            licenseKey: options.licenseKey,
             outputJsonPath,
+            spec: effectiveSpecPath,
+            concurrency: userConcurrency,
+            failedOnly: isFailedMode,
+            failedTarget,
         }, reporter);
-        console.log(`\n\x1b[36m[TestSpectra]\x1b[0m Run finished: \x1b[1m${result.status.toUpperCase()}\x1b[0m in ${result.duration}`);
+        const isPassed = result.status.toLowerCase() === 'passed';
+        const relReport = path.relative(cwd, outputJsonPath);
+        const networkReportFile = path.join(path.dirname(outputJsonPath), 'network-resources.json');
+        const relNetworkReport = fs.existsSync(networkReportFile) ? path.relative(cwd, networkReportFile) : undefined;
+        let suiteCount = 1;
+        let passedSuites = isPassed ? 1 : 0;
+        let failedSuites = isPassed ? 0 : 1;
+        let testCount = (result.passedCount ?? 0) + (result.failedCount ?? 0);
+        if (fs.existsSync(outputJsonPath)) {
+            try {
+                const fullReport = JSON.parse(fs.readFileSync(outputJsonPath, 'utf8'));
+                if (fullReport.summary) {
+                    suiteCount = fullReport.summary.totalSuites ?? 1;
+                    testCount = fullReport.summary.totalTests ?? testCount;
+                }
+                if (fullReport.suites && Array.isArray(fullReport.suites)) {
+                    failedSuites = fullReport.suites.filter((s) => (typeof s.failed === 'number' && s.failed > 0) ||
+                        s.status === 'failed' ||
+                        s.tests?.some((t) => t.passed === false || t.status === 'failed')).length;
+                    passedSuites = fullReport.suites.length - failedSuites;
+                }
+                if (fullReport.performance) {
+                    renderSummaryCard({
+                        isPassed,
+                        statusText: isPassed ? 'PASSED' : 'FAILED',
+                        duration: result.duration,
+                        platform,
+                        suiteCount,
+                        passedSuites,
+                        failedSuites,
+                        testCount,
+                        passedCount: result.passedCount ?? (isPassed ? testCount : 0),
+                        failedCount: result.failedCount ?? (isPassed ? 0 : testCount),
+                        reportPath: relReport,
+                        networkReportPath: relNetworkReport,
+                    });
+                    renderTimingBreakdown({
+                        ...fullReport.performance,
+                        wallClockDurationMs: fullReport.wallClockDurationMs,
+                        duration: fullReport.duration,
+                        totalTests: fullReport.summary?.totalTests ?? testCount,
+                    });
+                    return;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        renderSummaryCard({
+            isPassed,
+            statusText: isPassed ? 'PASSED' : 'FAILED',
+            duration: result.duration,
+            platform,
+            suiteCount,
+            passedSuites,
+            failedSuites,
+            testCount,
+            passedCount: result.passedCount ?? (isPassed ? testCount : 0),
+            failedCount: result.failedCount ?? (isPassed ? 0 : testCount),
+            reportPath: relReport,
+            networkReportPath: relNetworkReport,
+        });
     }
     catch (e) {
         console.error(`\x1b[31m[TestSpectra] Execution error:\x1b[0m`, e);

package/dist/commands/sync-types.d.ts

@@ -0,0 +1,4 @@
+export interface SyncTypesCommandOptions {
+    cwd?: string;
+}
+export declare function syncTypesCommand(options?: SyncTypesCommandOptions): Promise<void>;

package/dist/commands/sync-types.js

@@ -0,0 +1,14 @@
+import path from 'path';
+import chalk from 'chalk';
+import { TypeGenerator } from '../types/generator.js';
+export async function syncTypesCommand(options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    try {
+        TypeGenerator.generateAll(cwd);
+        console.log(chalk.green('✔ Successfully synchronized TestSpectra ambient type declarations in .testspectra/types/'));
+    }
+    catch (err) {
+        console.error(chalk.red(`✖ Failed to synchronize ambient declarations: ${err?.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,3 @@
+export declare function updateCommand(options?: {
+    check?: boolean;
+}): Promise<void>;