@testspectra/cli 1.1.11-rc.5 → 1.1.12

package/dist/commands/test.js

@@ -9,15 +9,15 @@ import { RustCoreBridge } from '../runner/bridge.js';
 import { TypeGenerator } from '../generator/type-generator.js';
 import { runSystemChecks } from './doctor.js';
 /**
- * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before Vitest starts.
+ * Guarantees the `.testspectra` solution-tsconfig scaffolding exists before the component
+ * runner starts.
  *
- * The bundled Vitest browser runner transpiles raw TypeScript specs/page-objects Just-In-Time.
- * When it does, `vite:esbuild` walks the nearest `tsconfig.json` and tries to read every entry in
+ * The bundled component runner transpiles raw TypeScript specs/page-objects Just-In-Time.
+ * When it does, esbuild walks the nearest `tsconfig.json` and tries to read every entry in
  * its `references` — including `./.testspectra/tsconfig.json`. That directory is gitignored, so on
  * a clean clone / fresh CI checkout the reference points at a file that does not exist, esbuild
- * throws `ENOENT`, Vite answers HTTP 500, and every suite dies with "Failed to fetch dynamically
- * imported module" before a single assertion runs. Regenerating the scaffolding up front (same
- * output as `spectra sync-types`) keeps the reference resolvable.
+ * throws `ENOENT`, and every suite dies before a single assertion runs. Regenerating the
+ * scaffolding up front (same output as `spectra sync-types`) keeps the reference resolvable.
  */
 export function ensureTestSpectraScaffolding(cwd) {
     const masterConfigPath = path.join(cwd, '.testspectra', 'tsconfig.json');
@@ -28,17 +28,16 @@ export function ensureTestSpectraScaffolding(cwd) {
 /**
  * Finds the Chrome-for-Testing binary that `spectra doctor` already installs/manages for the
  * E2E CDP driver (`core/driver-cdp`) — same install, same binary. `@testspectra/react` must not
- * contain any browser-discovery logic of its own (see the package-level comment in
- * tools/react/vitest.config.ts): this is the one place that resolves the path, passed down to
- * the bundled Vitest/Playwright runner as a plain argument (env var), so component testing never
- * requires a separate `playwright install` download alongside TestSpectra's own browser.
+ * contain any browser-discovery logic of its own: this is the one place that resolves the path,
+ * passed down to the native CDP component runner as a plain argument, so component testing never
+ * requires a separate browser download alongside TestSpectra's own browser.
  */
 async function resolveBrowserExecutable(cwd) {
     try {
         // `--only chrome` runs exactly one check — no adb/bun/git spawns, no Matchers lookup — since
         // this call exists solely to locate the managed browser binary.
         const { dependencies } = await runSystemChecks(cwd, { only: 'chrome' });
-        const chrome = dependencies.find((d) => d.category === 'web' && d.name.includes('Chrome'));
+        const chrome = dependencies.find((d) => d.category === 'web' && (d.name.includes('Chrome') || d.name.includes('Chromium')));
         return chrome?.installed && chrome.location ? chrome.location : null;
     }
     catch {
@@ -46,8 +45,9 @@ async function resolveBrowserExecutable(cwd) {
     }
 }
 /**
- * `spectra test` — delegates to `@testspectra/react`'s bundled Vitest browser-mode runner for
- * component testing. Deliberately separate from `spectra run` (E2E via core/orchestrator): see
+ * `spectra test` — runs React component tests via the native CDP engine
+ * (`@testspectra/react` bundle server + Rust `core/orchestrator::component_runner`).
+ * Deliberately separate from `spectra run` (E2E via core/orchestrator): see
  * docs/v2/features/component-testing/react/README.md §2 for why these are two independent
  * runners rather than one extended pipeline.
  */
@@ -116,71 +116,36 @@ export async function testCommand(options = {}) {
     // / setup.ts), so the same Reporter class parses them with zero changes on either side.
     const reporter = new Reporter();
     const runStartedAt = Date.now();
+    logPhase('Starting component test runner (Spectra Native CDP Engine)…');
+    const bundleServer = await reactPkg.startBundleServer({
+        testRoot: cwd,
+        stepDelayMs: stepDelayMs ?? 0,
+    });
     let ok = false;
-    if (options.runner === 'vitest') {
-        logPhase('Starting component test runner (Vitest Browser Mode)…');
-        ok = await reactPkg.runComponentTests({
-            runner: 'vitest',
-            cwd,
-            headless,
-            stepDelayMs,
-            spec: options.spec,
-            outputFile,
-            concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
-            browserExecutablePath,
-            onLine: (line) => {
-                const cleanLine = line.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '').trim();
-                if (!cleanLine)
-                    return;
-                if (cleanLine.startsWith('[TESTSPECTRA_')) {
-                    reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'INFO', message: cleanLine });
-                    if (!reporter.isInteractiveMode()) {
-                        console.log(cleanLine);
-                    }
-                    return;
-                }
-                if (reactPkg.isVitestNoise?.(cleanLine)) {
-                    return;
-                }
-                const sanitized = reactPkg.sanitizeErrorMessage?.(cleanLine) ?? cleanLine;
-                reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'ERROR', message: sanitized });
-                if (!reporter.isInteractiveMode()) {
-                    console.error(chalk.red(sanitized));
-                }
+    try {
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        const globalAppDataPath = path.join(home, '.testspectra');
+        const appDataPath = globalAppDataPath;
+        const runResult = await RustCoreBridge.run({
+            baseDir: cwd,
+            appDataPath,
+            platform: 'component',
+            config: {
+                bundleServerUrl: bundleServer.url,
+                webConfig: {
+                    headless,
+                    stepDelay: stepDelayMs,
+                    browserExecutablePath,
+                },
             },
-        });
+            specs: options.spec ? [options.spec] : undefined,
+            concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
+            outputJsonPath: outputFile,
+        }, reporter);
+        ok = runResult.status.toLowerCase() === 'passed';
     }
-    else {
-        logPhase('Starting component test runner (Spectra Native CDP Engine)…');
-        const bundleServer = await reactPkg.startBundleServer({
-            testRoot: cwd,
-            stepDelayMs: stepDelayMs ?? 0,
-        });
-        try {
-            const home = process.env.HOME || process.env.USERPROFILE || '';
-            const globalAppDataPath = path.join(home, '.testspectra');
-            const appDataPath = globalAppDataPath;
-            const runResult = await RustCoreBridge.run({
-                baseDir: cwd,
-                appDataPath,
-                platform: 'component',
-                config: {
-                    bundleServerUrl: bundleServer.url,
-                    webConfig: {
-                        headless,
-                        stepDelay: stepDelayMs,
-                        browserExecutablePath,
-                    },
-                },
-                specs: options.spec ? [options.spec] : undefined,
-                concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
-                outputJsonPath: outputFile,
-            }, reporter);
-            ok = runResult.status.toLowerCase() === 'passed';
-        }
-        finally {
-            bundleServer.stop();
-        }
+    finally {
+        bundleServer.stop();
     }
     const durationMs = Date.now() - runStartedAt;
     const result = reporter.generateResult(ok ? 'passed' : 'failed', `${(durationMs / 1000).toFixed(1)}s`);

package/dist/commands/update.d.ts

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

package/dist/commands/update.js

@@ -0,0 +1,109 @@
+import { execSync, execFileSync } 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);
+const PACKAGES = ['@testspectra/cli', '@testspectra/matchers'];
+function getLatestVersion(pkg) {
+    try {
+        const out = execFileSync('npm', ['view', pkg, 'version', '--json'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10000,
+        })
+            .toString()
+            .trim()
+            .replace(/"/g, '');
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getCurrentVersion(pkg, cwd) {
+    // Walk up to find the installed version
+    let cur = path.resolve(cwd);
+    while (cur && cur !== path.dirname(cur)) {
+        const pkgJson = path.join(cur, 'node_modules', pkg, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const p = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+                return p.version ?? null;
+            }
+            catch { }
+        }
+        cur = path.dirname(cur);
+    }
+    return null;
+}
+function detectPackageManager(cwd) {
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock')))
+        return 'bun';
+    return 'npm';
+}
+function buildInstallCmd(pm, pkgSpecs) {
+    const list = pkgSpecs.join(' ');
+    switch (pm) {
+        case 'pnpm':
+            return `pnpm add -D ${list}`;
+        case 'bun':
+            return `bun add -d ${list}`;
+        case 'npm':
+        default:
+            return `npm install -D ${list}`;
+    }
+}
+export async function updateCommand(options = {}) {
+    const cwd = process.cwd();
+    const pm = detectPackageManager(cwd);
+    console.log('\x1b[36m┌  🔄 TestSpectra Self-Update\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m');
+    console.log(`\x1b[36m│\x1b[0m  Package Manager: \x1b[33m${pm}\x1b[0m`);
+    console.log('\x1b[36m│\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
+    const updates = [];
+    for (const pkg of PACKAGES) {
+        const current = getCurrentVersion(pkg, cwd);
+        const latest = getLatestVersion(pkg);
+        const needsUpdate = !!latest && latest !== current;
+        updates.push({ pkg, current, latest, needsUpdate });
+        const currentStr = current ? `\x1b[33mv${current}\x1b[0m` : '\x1b[90m(not installed)\x1b[0m';
+        const latestStr = latest ? `\x1b[32mv${latest}\x1b[0m` : '\x1b[31m(unavailable)\x1b[0m';
+        const arrow = needsUpdate ? ` → ${latestStr}` : '';
+        const status = !latest ? '\x1b[31m✗\x1b[0m' : needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
+        console.log(`\x1b[36m│\x1b[0m   ${status} ${pkg.padEnd(28)} ${currentStr}${arrow}`);
+    }
+    const toUpdate = updates.filter((u) => u.needsUpdate && u.latest);
+    console.log('\x1b[36m│\x1b[0m');
+    if (toUpdate.length === 0) {
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m\n');
+        return;
+    }
+    if (options.check) {
+        console.log(`\x1b[36m│\x1b[0m  \x1b[33m${toUpdate.length} update(s) available. Run \x1b[36mspectra update\x1b[33m to install.\x1b[0m`);
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
+        return;
+    }
+    const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
+    const installCmd = buildInstallCmd(pm, pkgSpecs);
+    console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
+    console.log('\x1b[36m│\x1b[0m');
+    try {
+        execSync(installCmd, { cwd, stdio: 'inherit' });
+        console.log('\x1b[36m│\x1b[0m');
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m🎉 TestSpectra updated successfully!\x1b[0m');
+        for (const u of toUpdate) {
+            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? '?'} → v${u.latest}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.error(`\x1b[31m✗ Update failed: ${err.message}\x1b[0m\n`);
+        process.exit(1);
+    }
+}

package/dist/config/loader.js

@@ -41,12 +41,39 @@ export class ConfigLoader {
             }
             else if (configPath.endsWith('.ts') || configPath.endsWith('.js')) {
                 try {
-                    const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
-                    const mod = await import(fileUrl);
-                    loaded = mod.default || mod.config || mod;
+                    const raw = fs.readFileSync(configPath, 'utf-8');
+                    const ts = (await import('typescript')).default || (await import('typescript'));
+                    const transpiled = ts.transpileModule(raw, {
+                        compilerOptions: {
+                            module: ts.ModuleKind.CommonJS,
+                            target: ts.ScriptTarget.ES2022,
+                        },
+                    });
+                    const mod = { exports: {} };
+                    const mockRequire = (id) => {
+                        if (id === '@testspectra/cli' || id.endsWith('defineConfig')) {
+                            return { defineConfig: (c) => c };
+                        }
+                        try {
+                            return require(id);
+                        }
+                        catch {
+                            return {};
+                        }
+                    };
+                    const fn = new Function('exports', 'require', 'module', '__filename', '__dirname', transpiled.outputText);
+                    fn(mod.exports, mockRequire, mod, configPath, path.dirname(configPath));
+                    loaded = mod.exports.default || mod.exports.config || mod.exports;
                 }
                 catch (e) {
-                    console.warn(`[TestSpectra] Warning: Failed to import ${configPath}:`, e);
+                    try {
+                        const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
+                        const mod = await import(fileUrl);
+                        loaded = mod.default || mod.config || mod;
+                    }
+                    catch {
+                        console.warn(`[TestSpectra] Warning: Failed to import ${configPath}:`, e);
+                    }
                 }
             }
         }

package/dist/config/schema.d.ts

@@ -37,6 +37,46 @@ export interface DevServerConfig {
      */
     env?: Record<string, string>;
 }
+/**
+ * Configuration options for failure-only video recording.
+ */
+export interface VideoConfig {
+    /**
+     * Video container format ('webm' | 'mp4').
+     * @default "webm"
+     */
+    format?: 'webm' | 'mp4';
+    /**
+     * Target frame rate in frames per second (15 | 30 | 60).
+     * @default 30
+     */
+    fps?: 15 | 30 | 60 | number;
+    /**
+     * Compression quality (1 - 100).
+     * @default 80
+     */
+    quality?: number;
+    /**
+     * Maximum video width in pixels.
+     * @default 1280
+     */
+    maxWidth?: number;
+    /**
+     * Maximum video height in pixels.
+     * @default 720
+     */
+    maxHeight?: number;
+    /**
+     * Bitrate in Mbps (Android screen recording).
+     * @default 4
+     */
+    bitRateMbps?: number;
+    /**
+     * Maximum recording time limit per test case in seconds (Android screen recording).
+     * @default 180
+     */
+    timeLimitSeconds?: number;
+}
 /**
  * Configuration for web automation and browser test runners.
  */
@@ -90,6 +130,14 @@ export interface WebConfig {
      * @default "testcase"
      */
     parallelizationMode: 'testcase' | 'suite';
+    /**
+     * Failure-only video recording configuration.
+     * - `true`: Records screencast and persists video only when a test case fails (default).
+     * - `false`: Disables video recording completely for maximum execution speed.
+     * - `VideoConfig`: Detailed video format and quality settings.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Target Android device specification for multi-device parallel execution.
@@ -203,6 +251,11 @@ export interface AndroidConfig {
      * @default 0
      */
     stepDelay?: number;
+    /**
+     * Failure-only video recording configuration.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Configuration for iOS mobile test automation with Appium & XCUITest.
@@ -273,6 +326,11 @@ export interface IosConfig {
      * @default "suite"
      */
     parallelizationMode: 'testcase' | 'suite';
+    /**
+     * Failure-only video recording configuration.
+     * @default true
+     */
+    video?: boolean | VideoConfig;
 }
 /**
  * Specific domain filter for real-time network interception and recording.

package/dist/config/schema.js

@@ -28,6 +28,7 @@ export const DEFAULT_CONFIG_DATA = {
         headless: true,
         implicitWait: '5000',
         parallelizationMode: 'testcase',
+        video: true,
     },
     androidConfig: {
         driverServer: 'http://127.0.0.1:4800',
@@ -36,6 +37,7 @@ export const DEFAULT_CONFIG_DATA = {
         noReset: false,
         implicitWait: 10000,
         parallelizationMode: 'suite',
+        video: true,
         devices: [
             {
                 id: 'emulator-5554',
@@ -53,6 +55,7 @@ export const DEFAULT_CONFIG_DATA = {
         noReset: false,
         implicitWait: 10000,
         parallelizationMode: 'suite',
+        video: true,
         devices: [
             {
                 id: 'iphone-15-pro',
@@ -68,6 +71,6 @@ export const DEFAULT_CONFIG_DATA = {
         fastResponseTime: '200',
         normalResponseTime: '1000',
         monitoredDomains: [],
-        environmentVariables: {},
+        environmentVariables: { DEMO_API_MODE: 'sandbox' },
     },
 };

package/dist/generator/__tests__/tsconfig-isolation.test.js

@@ -262,6 +262,27 @@ describe('Platform TSConfigs & Type Isolation (docs/v2/cli/tsconfig-platform-iso
         expect(threw).toBe(true);
         expect(errorMessage).toContain("Cannot find name 'AuthLoginPage'");
     });
+    it('feature-scoped configs enable JSX so .tsx component tests type-check (regression: getScopedConfig omitted jsx)', () => {
+        const featureDir = path.join(tmpDir, 'packages', 'catalog', 'e2e');
+        fs.mkdirSync(path.join(featureDir, 'page-objects', 'RowComponent'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'page-objects', 'RowComponent', 'web.ts'), 'export default class RowComponent { static title = "row"; }');
+        fs.mkdirSync(path.join(featureDir, 'specs'), { recursive: true });
+        TypeGenerator.generateAll(tmpDir);
+        const scopedWebConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig', 'features', 'catalog', 'web.json'), 'utf-8'));
+        expect(scopedWebConfig.compilerOptions.jsx).toBe('react-jsx');
+    });
+    it('E2E: compiles a .tsx component test inside a feature scope via tsc -b with 0 errors', () => {
+        linkNodeModules(tmpDir);
+        const featureDir = path.join(tmpDir, 'packages', 'catalog', 'e2e');
+        fs.mkdirSync(path.join(featureDir, 'page-objects', 'RowComponent'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'page-objects', 'RowComponent', 'web.ts'), 'export default class RowComponent { static title = "row"; }');
+        fs.mkdirSync(path.join(featureDir, 'specs', 'Row', 'TC-0001'), { recursive: true });
+        fs.writeFileSync(path.join(featureDir, 'specs', 'Row', 'TC-0001', 'web.test.tsx'), 'const el = <div>{RowComponent.title}</div>;\n');
+        TypeGenerator.generateAll(tmpDir);
+        expect(() => {
+            execSync(`npx tsc -b ${tmpDir}`, { stdio: 'pipe' });
+        }).not.toThrow();
+    });
     it('E2E: compiles the full Nx monorepo template via tsc -b with 0 errors', async () => {
         let root = process.cwd();
         while (root && root !== path.dirname(root)) {

package/dist/generator/__tests__/type-generator.test.js

@@ -421,4 +421,18 @@ async function verifyZeroImport() {
         // Verify packages/features/auth is NOT in scopes
         expect(scopes.some((s) => s.dir === path.resolve(featureLibDir))).toBe(false);
     });
+    it('generates ambient types for non-JSON fixtures including images and PDF files', () => {
+        const fixDir = path.join(tmpDir, 'fixtures');
+        fs.mkdirSync(fixDir, { recursive: true });
+        fs.writeFileSync(path.join(fixDir, 'sampleImage.png'), 'fake-png-bytes');
+        fs.writeFileSync(path.join(fixDir, 'sampleDocument.pdf'), 'fake-pdf-bytes');
+        fs.writeFileSync(path.join(fixDir, 'dataset.csv'), 'id,name\n1,Alice');
+        fs.writeFileSync(path.join(fixDir, 'users.json'), JSON.stringify({ count: 1 }));
+        TypeGenerator.generateAll(tmpDir);
+        const fixturesDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'fixtures.d.ts'), 'utf-8');
+        expect(fixturesDts).toContain('readonly sampleImage: string;');
+        expect(fixturesDts).toContain('readonly sampleDocument: string;');
+        expect(fixturesDts).toContain('readonly dataset: string;');
+        expect(fixturesDts).toContain('readonly users: typeof import(');
+    });
 });

package/dist/generator/tsconfig-generator.js

@@ -260,6 +260,7 @@ export class TsConfigGenerator {
                 target: 'ES2022',
                 module: 'NodeNext',
                 moduleResolution: 'NodeNext',
+                jsx: 'react-jsx',
                 composite: true,
                 noEmit: true,
                 skipLibCheck: true,

package/dist/generator/type-generator.js

@@ -579,6 +579,8 @@ export class TypeGenerator {
                         scanFixtureDir(path.join(dir, entry.name));
                     }
                     else if (entry.isFile()) {
+                        if (entry.name.endsWith('.d.ts'))
+                            continue;
                         const parsed = path.parse(entry.name);
                         const varName = parsed.name.replace(/[^a-zA-Z0-9_$]/g, '_');
                         if (declaredFixtures.has(varName))

package/dist/index.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { addCommand } from './commands/add.js';
 import { demoCommand } from './commands/demo.js';
+import { DEFAULT_DEMO_PORT } from './utils/demo-server.js';
 import { devicesCommand } from './commands/devices.js';
 import { doctorCommand } from './commands/doctor.js';
 import { initCommand } from './commands/init.js';
@@ -54,8 +55,8 @@ Examples:
         .action(installCommand);
     program
         .command('demo')
-        .description('Launch the built-in TestSpectra Demo Web App server on localhost:5173')
-        .option('-p, --port <port>', 'Port to bind server (default: 5173)')
+        .description(`Launch the built-in TestSpectra Demo Web App server on localhost:${DEFAULT_DEMO_PORT}`)
+        .option('-p, --port <port>', `Port to bind server (default: ${DEFAULT_DEMO_PORT})`)
         .action(demoCommand);
     program
         .command('watch')
@@ -187,15 +188,18 @@ Examples:
         .option('--skip-dev-servers', 'Skip auto-starting local development servers')
         .option('--step-delay <ms>', 'Delay between consecutive actions and commands in milliseconds (slow motion)')
         .option('--delay <ms>', 'Alias for --step-delay')
+        .option('--video', 'Enable failure video recording (default: true)')
+        .option('--no-video', 'Disable video recording completely')
         .option('--failed [targets]', 'Re-run failed tests from previous run (accepts comma-separated test IDs or spec paths)')
         .option('-c, --concurrency <number>', 'Maximum parallel worker concurrency (auto-detected if omitted)')
+        .option('--debug', 'Run in debug mode (headed browser, single worker, inspector attached for breakpoints)')
+        .option('--inspect-port <port>', 'Bun inspector port for debug mode (default: 9229)')
         .option('-w, --workdir <dir>', 'Custom app data / temp workdir')
         .option('-o, --output <path>', 'Custom test report JSON output path')
         .action(runCommand);
     program
         .command('test')
-        .description('Run React component tests via @testspectra/react')
-        .option('-r, --runner <engine>', 'Component test runner engine: spectra (default, native CDP) or vitest (Playwright browser mode)', 'spectra')
+        .description('Run React component tests via the native CDP engine')
         .option('-w, --cwd <dir>', 'Custom workspace directory')
         .option('-s, --spec <path>', 'Spec file path (or substring filter) to execute')
         .option('--headless', 'Run in headless mode (default)')