@testspectra/cli 1.1.8-rc.24 → 1.1.8-rc.28

package/dist/commands/upgrade.js

@@ -3,9 +3,21 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { RustCoreBridge } from '../runner/bridge.js';
+import { checkDriverUpdates } from '../utils/dependency-updates.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PACKAGES = ['@testspectra/cli', '@testspectra/matchers', '@testspectra/react'];
+/** Filters requested package names against the known catalog; empty means "all". */
+function selectPackages(requested) {
+    if (requested.length === 0)
+        return [...PACKAGES];
+    const known = new Set(PACKAGES);
+    const unknown = requested.filter((p) => !known.has(p));
+    if (unknown.length > 0) {
+        console.warn(`\x1b[33mIgnoring unknown TestSpectra package(s): ${unknown.join(', ')}\x1b[0m`);
+    }
+    return requested.filter((p) => known.has(p));
+}
 function getLatestVersion(pkg) {
     try {
         const out = execFileSync('npm', ['view', pkg, 'version', '--json'], {
@@ -43,11 +55,27 @@ function detectPackageManager(cwd) {
         return 'bun';
     return 'npm';
 }
-function buildInstallCmd(pm, pkgSpecs) {
+function collectPackageUpdates(cwd, packages) {
+    return packages.map((pkg) => {
+        const current = getCurrentVersion(pkg, cwd);
+        const latest = getLatestVersion(pkg);
+        return { pkg, current, latest, needsUpdate: !!latest && latest !== current };
+    });
+}
+function printUpdateRow(label, 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[90m(unknown)\x1b[0m';
+    const arrow = needsUpdate ? ` → ${latestStr}` : '';
+    const status = needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
+    console.log(`\x1b[36m│\x1b[0m   ${status} ${label.padEnd(28)} ${currentStr}${arrow}`);
+}
+function buildInstallCmd(pm, pkgSpecs, cwd) {
     const list = pkgSpecs.join(' ');
     switch (pm) {
-        case 'pnpm':
-            return `pnpm add -D ${list}`;
+        case 'pnpm': {
+            const isWorkspaceRoot = fs.existsSync(path.join(cwd, 'pnpm-workspace.yaml'));
+            return isWorkspaceRoot ? `pnpm add -D -w ${list}` : `pnpm add -D ${list}`;
+        }
         case 'bun':
             return `bun add -d ${list}`;
         case 'npm':
@@ -55,9 +83,24 @@ function buildInstallCmd(pm, pkgSpecs) {
             return `npm install -D ${list}`;
     }
 }
-export async function upgradeCommand(options = {}) {
+export async function upgradeCommand(requestedPackages = [], options = {}) {
     const cwd = process.cwd();
     const pm = detectPackageManager(cwd);
+    const selected = selectPackages(requestedPackages);
+    const targeted = requestedPackages.length > 0;
+    if (targeted && selected.length === 0) {
+        console.error(`\x1b[31mNo known TestSpectra package matched: ${requestedPackages.join(', ')}. Known packages: ${PACKAGES.join(', ')}\x1b[0m`);
+        process.exitCode = 1;
+        return;
+    }
+    // Machine-readable mode for the VS Code Preflight panel: implies `--check`, never mutates.
+    if (options.json) {
+        const packages = collectPackageUpdates(cwd, selected);
+        const drivers = targeted ? [] : await checkDriverUpdates();
+        const updatesAvailable = [...packages, ...drivers].filter((u) => u.needsUpdate).length;
+        console.log(JSON.stringify({ packages, drivers, updatesAvailable }, null, 2));
+        return;
+    }
     console.log('\x1b[36m┌  🚀 TestSpectra Self-Upgrade Mechanism\x1b[0m');
     console.log('\x1b[36m│\x1b[0m');
     const updates = [];
@@ -66,11 +109,8 @@ export async function upgradeCommand(options = {}) {
     if (!options.driversOnly) {
         console.log(`\x1b[36m│\x1b[0m  \x1b[1mPhase 1: Workspace Packages\x1b[0m (Manager: \x1b[33m${pm}\x1b[0m)`);
         console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
-        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 });
+        updates.push(...collectPackageUpdates(cwd, selected));
+        for (const { pkg, current, latest, needsUpdate } of updates) {
             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}` : '';
@@ -84,7 +124,7 @@ export async function upgradeCommand(options = {}) {
         }
         else if (toUpdate.length > 0) {
             const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
-            const installCmd = buildInstallCmd(pm, pkgSpecs);
+            const installCmd = buildInstallCmd(pm, pkgSpecs, cwd);
             console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
             try {
                 execSync(installCmd, { cwd, stdio: 'inherit' });
@@ -101,11 +141,21 @@ export async function upgradeCommand(options = {}) {
         console.log('\x1b[36m│\x1b[0m');
     }
     if (options.check) {
+        if (!targeted) {
+            const drivers = await checkDriverUpdates();
+            if (drivers.length > 0) {
+                console.log('\x1b[36m│\x1b[0m  \x1b[1mDriver & Agent Status\x1b[0m');
+                for (const dep of drivers) {
+                    printUpdateRow(dep.name, dep.current, dep.latest, dep.needsUpdate);
+                }
+                console.log('\x1b[36m│\x1b[0m');
+            }
+        }
         console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
         return;
     }
     // Phase 2: Drivers and Binaries
-    if (!options.packagesOnly) {
+    if (!options.packagesOnly && !targeted) {
         console.log(`\x1b[36m│\x1b[0m  \x1b[1mPhase 2: System Binaries & Drivers\x1b[0m`);
         try {
             const binPath = RustCoreBridge.resolveBinaryPath();
@@ -120,8 +170,8 @@ export async function upgradeCommand(options = {}) {
                 env: {
                     ...process.env,
                     TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
-                    TEST_SPECTRA_FORCE_LATEST: '1'
-                }
+                    TEST_SPECTRA_FORCE_LATEST: '1',
+                },
             });
             console.log('\x1b[36m│\x1b[0m  \x1b[32m✓ Drivers updated successfully.\x1b[0m');
         }

package/dist/generator/architecture-doc-generator.js

@@ -64,9 +64,7 @@ export function generateArchitectureDoc(cwd) {
     }
     const sharedScope = scopes.find((s) => s.isShared);
     const featureE2eDirs = scopes.filter((s) => !s.isShared).map((s) => s.dir);
-    const sharedTestingRelPath = sharedScope
-        ? path.relative(cwd, sharedScope.dir).replace(/\\/g, '/')
-        : 'shared/testing';
+    const sharedTestingRelPath = sharedScope ? path.relative(cwd, sharedScope.dir).replace(/\\/g, '/') : 'shared/testing';
     const e2eFolderName = featureE2eDirs.length > 0 ? path.basename(featureE2eDirs[0]) : 'e2e';
     const content = renderArchitectureDoc(path.join(docsTemplateDir, 'ARCHITECTURE.nx.md'), {
         __SHARED_TESTING_REL_PATH__: sharedTestingRelPath,

package/dist/index.js

@@ -25,10 +25,10 @@ export * from './types/generator.js';
 export * from '@testspectra/matchers';
 export function createCliProgram() {
     const program = new Command();
-    program.name('spectra').description('TestSpectra Zero-Config Cross-Platform Test Runner CLI').version('1.0.0');
+    program.name('spectra').description('TestSpectra Cross-Platform Test Runner CLI').version('1.0.0');
     program
         .command('init')
-        .description('Initialize testspectra.config.json and project directories')
+        .description('Initialize spectra.config.ts and project directories')
         .option('-t, --template <template>', 'Project template: default, nx, react-component')
         .option('-f, --force', 'Overwrite existing configuration if present')
         .action(initCommand);
@@ -41,15 +41,16 @@ export function createCliProgram() {
     program
         .command('install [dependency]')
         .description('Install missing testing dependencies, browser drivers, and workspace packages')
-        .option('-f, --force', 'Force re-installation of dependencies')
+        .option('-f, --force', 'Remove existing artifacts and perform a clean reinstall of the dependency')
         .addHelpText('after', `
 Examples:
   $ spectra install                 Install all missing required dependencies automatically
   $ spectra install chrome          Install Google Chrome for Testing & matching Chromedriver
   $ spectra install adb             Install Google Android SDK Platform Tools (ADB)
   $ spectra install bun             Install Bun runtime
-  $ spectra install android-driver  Install Spectra Android Native Driver & WDIO Service
-  $ spectra install wdio            Install WebDriverIO core packages and matchers`)
+  $ spectra install android-agent   Install Spectra Android Native Agent (spectra-agent.jar)
+  $ spectra install android-agent -f  Clean reinstall Spectra Android Native Agent
+  $ spectra install packages        Install TestSpectra CLI, Matchers & Android Agent packages`)
         .action(installCommand);
     program
         .command('demo')
@@ -86,23 +87,31 @@ Examples:
         .action(lintCommand);
     program
         .command('doctor')
-        .description('Verify local environment prerequisites (ADB, Spectra Android Driver, Chrome, Bun)')
+        .description('Verify local environment prerequisites (Bun, Git, ADB, Chrome, Spectra Android Agent, workspace packages)')
         .option('-v, --verbose', 'Show full installation paths for all detected runtimes and packages')
+        .option('--scope <category>', 'Only check one category: core, web, mobile (default: all)')
+        .option('--only <keys>', 'Only check specific dependencies (comma-separated): bun, git, cli, chrome, matchers, adb, agent')
         .option('--fix', 'Attempt automatic fix / download of missing tools')
         .option('--json', 'Output diagnostic results as JSON')
         .action(doctorCommand);
     program
-        .command('upgrade')
+        .command('upgrade [packages...]')
         .alias('update')
         .description('Upgrade TestSpectra ecosystem packages and system drivers to the latest versions')
         .option('--check', 'Only check for available updates without installing')
         .option('--packages-only', 'Only upgrade NPM packages in package.json')
         .option('--drivers-only', 'Only upgrade system binaries and drivers (ADB, Agent, Chrome)')
+        .option('--json', 'Output the update check (packages + drivers) as JSON (implies --check, no changes applied)')
+        .addHelpText('after', `
+Examples:
+  $ spectra upgrade                                    Upgrade all packages and system drivers
+  $ spectra upgrade @testspectra/cli                   Upgrade only the CLI package
+  $ spectra upgrade @testspectra/cli @testspectra/matchers  Upgrade specific packages
+  $ spectra upgrade --check                            Check what is outdated (packages + drivers)`)
         .action(upgradeCommand);
     program
         .command('devices')
-        .description('List connected Android/iOS devices and local browsers')
-        .option('-t, --target <target>', 'Filter scope: android, ios, web, all', 'all')
+        .description('List connected Android devices (ADB)')
         .option('--json', 'Output results as JSON')
         .action(devicesCommand);
     program
@@ -180,23 +189,29 @@ Examples:
         .action(runCommand);
     program
         .command('test')
-        .description('Run React component tests via @testspectra/react (bundled Vitest browser mode)')
+        .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')
         .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)')
         .option('--no-headless', 'Run in headed mode')
         .option('--headed', 'Run the browser in visible GUI mode (alias for --no-headless)')
-        .option('--step-delay <ms>', 'Delay after each action/assertion in milliseconds (slow motion, for observing DOM transitions in --headed mode)')
+        .option('-d, --step-delay <ms>', 'Delay after each action/assertion in milliseconds (slow motion, for observing DOM transitions in --headed mode)')
         .option('--delay <ms>', 'Alias for --step-delay')
-        .option('-c, --concurrency <number>', 'Run spec files sequentially (1) or in parallel (>1, default). Browser mode has no numeric N-worker sizing like `spectra run`.')
-        .option('-o, --output <path>', 'Write a Vitest JSON test report to this path')
+        .option('-c, --concurrency <number>', 'Run spec files sequentially (1) or in parallel (>1, default).')
+        .option('-o, --output <path>', 'Write a JSON test report to this path')
         .action(testCommand);
     return program;
 }
 export async function runCli(args = process.argv) {
-    const { checkUpdateInBackground, displayUpdateNotificationIfNeeded } = await import('./utils/update-notifier.js');
-    checkUpdateInBackground();
     const program = createCliProgram();
     await program.parseAsync(args);
+    // Commands whose stdout must stay machine-readable or is purely diagnostic never emit the
+    // interactive "update available" banner.
+    const silentCommands = ['doctor', 'install', 'upgrade', 'update'];
+    if (silentCommands.includes(program.args[0]))
+        return;
+    const { checkUpdateInBackground, displayUpdateNotificationIfNeeded } = await import('./utils/update-notifier.js');
+    checkUpdateInBackground();
     displayUpdateNotificationIfNeeded();
 }

package/dist/linter/discovery.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { ConfigLoader } from '../config/loader.js';
 /**
  * Scans a workspace directory for all `project.json` files that have the
  * "testspectra:shared" tag, and returns their parent folder paths.
@@ -96,8 +97,7 @@ export function isInsideSharedLibrary(filePath, workspaceDir) {
 export function findProjectRoot(startDir) {
     let current = path.resolve(startDir);
     while (true) {
-        if (fs.existsSync(path.join(current, 'spectra.config.ts')) ||
-            fs.existsSync(path.join(current, 'spectra.config.js'))) {
+        if (ConfigLoader.CONFIG_FILE_NAMES.some((name) => fs.existsSync(path.join(current, name)))) {
             return current;
         }
         const parent = path.dirname(current);

package/dist/linter/schemas/spec.schema.d.ts

@@ -11,11 +11,11 @@ export declare const CoverageSchema: z.ZodObject<{
     web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
     mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
 }, "strip", z.ZodTypeAny, {
-    web?: "automated" | "manual" | "unsupported" | undefined;
     mobile?: "automated" | "manual" | "unsupported" | undefined;
-}, {
     web?: "automated" | "manual" | "unsupported" | undefined;
+}, {
     mobile?: "automated" | "manual" | "unsupported" | undefined;
+    web?: "automated" | "manual" | "unsupported" | undefined;
 }>;
 export declare const SpecFrontmatterSchema: z.ZodObject<{
     id: z.ZodString;
@@ -27,11 +27,11 @@ export declare const SpecFrontmatterSchema: z.ZodObject<{
         web: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
         mobile: z.ZodOptional<z.ZodEnum<["automated", "manual", "unsupported"]>>;
     }, "strip", z.ZodTypeAny, {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
-    }, {
         web?: "automated" | "manual" | "unsupported" | undefined;
+    }, {
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     }>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
@@ -41,8 +41,8 @@ export declare const SpecFrontmatterSchema: z.ZodObject<{
     priority: "Critical" | "High" | "Medium" | "Low";
     caseType: "Positive" | "Negative" | "Edge";
     coverage?: {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     } | undefined;
     tags?: string[] | undefined;
 }, {
@@ -52,8 +52,8 @@ export declare const SpecFrontmatterSchema: z.ZodObject<{
     priority: "Critical" | "High" | "Medium" | "Low";
     caseType: "Positive" | "Negative" | "Edge";
     coverage?: {
-        web?: "automated" | "manual" | "unsupported" | undefined;
         mobile?: "automated" | "manual" | "unsupported" | undefined;
+        web?: "automated" | "manual" | "unsupported" | undefined;
     } | undefined;
     tags?: string[] | undefined;
 }>;

package/dist/runner/bridge.d.ts

@@ -3,7 +3,7 @@ import { Reporter, TestRunResult } from './reporter.js';
 export interface RunOptions {
     baseDir: string;
     appDataPath: string;
-    platform: 'web' | 'android' | 'ios' | 'common' | 'mobile';
+    platform: 'web' | 'android' | 'ios' | 'common' | 'mobile' | 'component';
     suite?: string;
     testCases?: Array<{
         id: string;

package/dist/runner/bridge.js

@@ -16,16 +16,42 @@ function platformPackageName() {
         return '@testspectra/cli-darwin-arm64';
     if (platform === 'linux' && arch === 'x64')
         return '@testspectra/cli-linux-x64';
-    if (platform === 'win32' && arch === 'arm64')
-        return '@testspectra/cli-win32-arm64';
     if (platform === 'win32' && arch === 'x64')
         return '@testspectra/cli-win32-x64';
+    // win32/arm64 has no published native binary (scripts/release-cli-local.sh no longer builds
+    // it) — falls through to `pkgName === null` below, which throws a clear "not currently
+    // supported" error instead of pointing at an optional dependency that doesn't exist.
     return null;
 }
 export class RustCoreBridge {
     static resolveBinaryPath() {
         const isWindows = process.platform === 'win32';
         const binaryName = isWindows ? 'testspectra-runner.exe' : 'testspectra-runner';
+        // In local monorepo development (where core/Cargo.toml exists), prioritize the locally-built
+        // binary in core/target/release or cli/bin over any stale optionalDependency in node_modules.
+        const workspaceRoot = path.resolve(__dirname, '../../..');
+        const isMonorepo = fs.existsSync(path.join(workspaceRoot, 'core/Cargo.toml'));
+        const candidatePaths = [
+            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'),
+        ];
+        if (isMonorepo) {
+            for (const p of candidatePaths) {
+                if (fs.existsSync(p)) {
+                    return p;
+                }
+                if (fs.existsSync(`${p}.exe`)) {
+                    return `${p}.exe`;
+                }
+            }
+        }
         // 1. Production install: resolve the prebuilt binary from the platform-specific
         // optionalDependency package (e.g. @testspectra/cli-darwin-arm64). This is how the
         // published npm package ships native binaries for every supported platform without
@@ -52,20 +78,7 @@ export class RustCoreBridge {
                 // Optional dependency not installed — fall through to the workspace dev paths below.
             }
         }
-        // 2. Monorepo dev fallback: look for a precompiled release/debug binary in the workspace
-        // target, as produced by scripts/ensure-runner-binary.js during local development.
-        const workspaceRoot = path.resolve(__dirname, '../../..');
-        const candidatePaths = [
-            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'),
-        ];
+        // 2. Dev fallback if not already resolved above
         for (const p of candidatePaths) {
             if (fs.existsSync(p)) {
                 return p;
@@ -118,6 +131,8 @@ export class RustCoreBridge {
             });
             let runStatus = 'failed';
             let runDuration = '0s';
+            let completePassedCount;
+            let completeFailedCount;
             child.stdout.on('data', (data) => {
                 const lines = data.toString().split('\n');
                 for (const line of lines) {
@@ -160,6 +175,12 @@ export class RustCoreBridge {
                         else if (parsed.type === 'complete') {
                             runStatus = parsed.status;
                             runDuration = parsed.duration;
+                            if (typeof parsed.passed_count === 'number') {
+                                completePassedCount = parsed.passed_count;
+                            }
+                            if (typeof parsed.failed_count === 'number') {
+                                completeFailedCount = parsed.failed_count;
+                            }
                         }
                         else if (parsed.type === 'error') {
                             reporter.addLog({
@@ -195,6 +216,14 @@ export class RustCoreBridge {
             });
             child.on('close', (code) => {
                 let result = reporter.generateResult(code === 0 ? 'passed' : runStatus, runDuration);
+                if (result.passedCount === 0 && result.failedCount === 0) {
+                    if (completePassedCount !== undefined) {
+                        result.passedCount = completePassedCount;
+                    }
+                    if (completeFailedCount !== undefined) {
+                        result.failedCount = completeFailedCount;
+                    }
+                }
                 // Only trust a pre-existing outputJsonPath when it was actually written during THIS run
                 // (mtime at/after runStartedAt) — NOT just when the process exited with code 0. The
                 // native runner writes its own complete report once the pipeline reaches the report

package/dist/runner/reporter.js

@@ -355,10 +355,14 @@ export class Reporter {
             const err = raw.replace('[TESTSPECTRA_TEST_ERROR]', '').trim();
             const latest = Array.from(this.pendingTests.values()).pop();
             if (latest) {
-                latest.errorMsg = err;
+                latest.errorMsg = latest.errorMsg ? `${latest.errorMsg}\n${err}` : err;
             }
             else {
-                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${err}\x1b[0m`);
+                const errLines = err.split('\n');
+                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${errLines[0]}\x1b[0m`);
+                for (let i = 1; i < errLines.length; i++) {
+                    console.log(`      \x1b[38;2;248;113;113m${errLines[i]}\x1b[0m`);
+                }
             }
             return;
         }
@@ -402,7 +406,11 @@ export class Reporter {
             }
             this.clearActiveSlots();
             if (errorMsg) {
-                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${errorMsg}\x1b[0m`);
+                const errLines = errorMsg.split('\n');
+                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${errLines[0]}\x1b[0m`);
+                for (let i = 1; i < errLines.length; i++) {
+                    console.log(`      \x1b[38;2;248;113;113m${errLines[i]}\x1b[0m`);
+                }
             }
             console.log(`${chalk.hex('#f87171')('✗')} ${chalk.white.bold(title)} ${chalk.gray(`(${duration}ms)`)}`);
             for (const step of steps) {

package/dist/utils/background-update-check.js

@@ -19,13 +19,6 @@ function getLatestVersion(pkg) {
         return null;
     }
 }
-function getCurrentVersion(pkg) {
-    // In a real scenario we'd check the workspace.
-    // For background check, we can check global or try to find it via npm ls,
-    // but simpler to just pull from the currently running CLI package.json for '@testspectra/cli'
-    // For background script it's tricky to know the workspace, so we just check if it's available.
-    return null; // A robust implementation would pass cwd to the background script
-}
 async function run() {
     const updates = [];
     for (const pkg of PACKAGES) {
@@ -43,7 +36,7 @@ async function run() {
     const cacheData = {
         timestamp: Date.now(),
         latestVersions: updates,
-        updatesAvailable: updates // Main thread will filter this properly later or we just mock it for architecture
+        updatesAvailable: updates, // Main thread will filter this properly later or we just mock it for architecture
     };
     fs.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), 'utf-8');
 }

package/dist/utils/dependency-updates.d.ts

@@ -0,0 +1,15 @@
+export interface DependencyUpdateStatus {
+    name: string;
+    kind: 'package' | 'driver';
+    identifier: string;
+    current: string | null;
+    latest: string | null;
+    needsUpdate: boolean;
+}
+/**
+ * Best-effort "installed vs latest" report for the managed system drivers and the Spectra Android
+ * Agent, keyed by the exact `name` `spectra doctor` reports so the VS Code Preflight panel can
+ * attach a per-row update badge. `latest` stays `null` when it cannot be determined (offline,
+ * private registry unavailable) — the row still exposes its reinstall action.
+ */
+export declare function checkDriverUpdates(): Promise<DependencyUpdateStatus[]>;

package/dist/utils/dependency-updates.js

@@ -0,0 +1,107 @@
+import { execFileSync } from 'child_process';
+import { runSystemChecks } from '../commands/doctor.js';
+const CHROME_FOR_TESTING_API = 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json';
+const BUN_RELEASES_API = 'https://api.github.com/repos/oven-sh/bun/releases/latest';
+const PLATFORM_TOOLS_XML = 'https://dl.google.com/android/repository/repository2-3.xml';
+function normalizeVersion(raw) {
+    if (!raw)
+        return null;
+    const match = raw.match(/(\d+\.\d+\.\d+(?:[-.][0-9A-Za-z.-]+)?)/);
+    return match ? match[1] : null;
+}
+async function fetchJson(url) {
+    try {
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(8000),
+            headers: { 'User-Agent': 'testspectra-cli' },
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function latestChromeVersion() {
+    const json = await fetchJson(CHROME_FOR_TESTING_API);
+    return json?.channels?.Stable?.version ?? null;
+}
+async function latestBunVersion() {
+    const json = await fetchJson(BUN_RELEASES_API);
+    const tag = json?.tag_name;
+    return typeof tag === 'string' ? tag.replace(/^bun-v/, '') : null;
+}
+async function latestAdbVersion() {
+    try {
+        const res = await fetch(PLATFORM_TOOLS_XML, {
+            signal: AbortSignal.timeout(8000),
+            headers: { 'User-Agent': 'testspectra-cli' },
+        });
+        if (!res.ok)
+            return null;
+        const xml = await res.text();
+        const block = xml.match(/<remotePackage[^>]*path="platform-tools"[\s\S]*?<\/remotePackage>/);
+        if (!block)
+            return null;
+        const rev = block[0].match(/<revision>[\s\S]*?<major>(\d+)<\/major>[\s\S]*?<minor>(\d+)<\/minor>[\s\S]*?<micro>(\d+)<\/micro>/);
+        return rev ? `${rev[1]}.${rev[2]}.${rev[3]}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function latestAndroidAgentVersion() {
+    try {
+        return (execFileSync('npm', ['view', '@testspectra/android-agent', 'version', '--json'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 10000,
+        })
+            .toString()
+            .trim()
+            .replace(/"/g, '') || null);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Best-effort "installed vs latest" report for the managed system drivers and the Spectra Android
+ * Agent, keyed by the exact `name` `spectra doctor` reports so the VS Code Preflight panel can
+ * attach a per-row update badge. `latest` stays `null` when it cannot be determined (offline,
+ * private registry unavailable) — the row still exposes its reinstall action.
+ */
+export async function checkDriverUpdates() {
+    let installed;
+    try {
+        const result = await runSystemChecks();
+        installed = result.dependencies;
+    }
+    catch {
+        return [];
+    }
+    const [chrome, bun, adb] = await Promise.all([latestChromeVersion(), latestBunVersion(), latestAdbVersion()]);
+    const agent = latestAndroidAgentVersion();
+    const candidates = [
+        { name: 'Google Chrome', latest: chrome },
+        { name: 'Bun', latest: bun },
+        { name: 'ADB (Android Debug Bridge)', latest: adb },
+        { name: 'Spectra Android Agent', latest: agent },
+    ];
+    const updates = [];
+    for (const { name, latest } of candidates) {
+        const dep = installed.find((d) => d.name === name);
+        if (!dep?.installed)
+            continue;
+        const current = normalizeVersion(dep.version);
+        updates.push({
+            name,
+            kind: 'driver',
+            identifier: name,
+            current,
+            latest,
+            needsUpdate: !!latest && !!current && current !== latest,
+        });
+    }
+    return updates;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@testspectra/cli",
-  "version": "1.1.8-rc.24",
-  "description": "TestSpectra Zero-Config Cross-Platform Test Runner CLI",
+  "version": "1.1.8-rc.28",
+  "description": "TestSpectra Cross-Platform Test Runner CLI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -26,9 +26,9 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@testspectra/matchers": "^1.1.8-rc.24",
-    "@testspectra/react": "^1.1.8-rc.24",
-    "@testspectra/skills": "^1.1.8-rc.24",
+    "@testspectra/matchers": "^1.1.8-rc.28",
+    "@testspectra/react": "^1.1.8-rc.28",
+    "@testspectra/skills": "^1.1.8-rc.28",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
@@ -38,10 +38,9 @@
     "zod": "^3.23.8"
   },
   "optionalDependencies": {
-    "@testspectra/cli-darwin-arm64": "1.1.8-rc.24",
-    "@testspectra/cli-linux-x64": "1.1.8-rc.24",
-    "@testspectra/cli-win32-arm64": "1.1.8-rc.24",
-    "@testspectra/cli-win32-x64": "1.1.8-rc.24"
+    "@testspectra/cli-darwin-arm64": "1.1.8-rc.28",
+    "@testspectra/cli-linux-x64": "1.1.8-rc.28",
+    "@testspectra/cli-win32-x64": "1.1.8-rc.28"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",