@testspectra/cli 1.1.8-rc.9 → 1.1.10

package/dist/index.js

@@ -7,12 +7,13 @@ import { initCommand } from './commands/init.js';
 import { installCommand } from './commands/install.js';
 import { runCommand } from './commands/run.js';
 import { testCommand } from './commands/test.js';
-import { updateCommand } from './commands/update.js';
+import { upgradeCommand } from './commands/upgrade.js';
 import { watchCommand } from './commands/watch.js';
 import { syncTypesCommand } from './commands/sync-types.js';
 import { refactorCommand } from './commands/refactor.js';
 import { lintCommand } from './commands/lint.js';
 import { licenseCommand } from './commands/license.js';
+import { docsUpdateCommand } from './commands/docs.js';
 import { skillsInitCommand, skillsListCommand, skillsAddCommand, skillsUpdateCommand, skillsRemoveCommand, } from './commands/skills.js';
 export * from './config/schema.js';
 export * from './config/loader.js';
@@ -24,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);
@@ -40,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')
@@ -85,20 +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('update')
-        .description('Update @testspectra/cli and @testspectra/matchers to the latest version from npm')
+        .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')
-        .action(updateCommand);
+        .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
@@ -147,11 +160,19 @@ Examples:
         .option('-w, --cwd <dir>', 'Custom workspace directory')
         .option('-a, --agent <ids>', 'One-off override: comma-separated agent(s) to target, bypassing the saved "init" selection (claude, opencode, kilo, agents, gemini)')
         .action(skillsRemoveCommand);
+    const docs = program.command('docs').description('Manage generated TestSpectra workspace documentation');
+    docs
+        .command('update')
+        .description('Regenerate ARCHITECTURE.md from the current workspace state, without re-running init')
+        .option('-w, --cwd <dir>', 'Custom workspace directory')
+        .action(docsUpdateCommand);
     program
         .command('run [paths...]')
         .description('Execute test suite or individual test case')
         .option('-s, --spec <path>', 'Spec file path to execute')
         .option('-t, --target <target>', 'Target platform: web, android, ios, common', 'web')
+        .option('--host <name>', 'Target specific named host defined in spectra.config.ts (webConfig.hosts)')
+        .option('--base-url <url>', 'Override webConfig.baseUrl')
         .option('-d, --device <device>', 'Target device name or UDID')
         .option('--all-devices', 'Distribute test execution across all connected devices')
         .option('--multi-device', 'Distribute test execution across all connected devices (alias for --all-devices)')
@@ -170,20 +191,42 @@ 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 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 isJson = args.includes('--json');
+    const silentCommands = [
+        'doctor',
+        'install',
+        'upgrade',
+        'update',
+        'license',
+        'devices',
+        'lint',
+        'sync-types',
+        'refactor',
+        'watch',
+    ];
+    const isSilent = isJson || silentCommands.includes(program.args[0]);
+    const { checkUpdateInBackground, displayUpdateNotificationIfNeeded } = await import('./utils/update-notifier.js');
+    checkUpdateInBackground();
+    if (!isSilent) {
+        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,54 @@ 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.
+        let workspaceRoot = null;
+        let curr = __dirname;
+        while (curr !== path.dirname(curr)) {
+            if (fs.existsSync(path.join(curr, 'core/Cargo.toml')) || fs.existsSync(path.join(curr, 'pnpm-workspace.yaml'))) {
+                workspaceRoot = curr;
+                break;
+            }
+            curr = path.dirname(curr);
+        }
+        const candidatePaths = [
+            ...(workspaceRoot
+                ? [
+                    path.join(workspaceRoot, 'core/target/release', binaryName),
+                    path.join(workspaceRoot, 'target/release', binaryName),
+                    path.join(workspaceRoot, 'cli/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', binaryName),
+            path.join(__dirname, '../../bin', binaryName),
+            path.join(__dirname, '../../bin/testspectra-runner'),
+        ];
+        if (workspaceRoot) {
+            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 +90,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;
@@ -114,9 +139,12 @@ export class RustCoreBridge {
         return new Promise((resolve, reject) => {
             const child = spawn(binPath, [payload], {
                 env: runnerEnv,
+                windowsHide: true,
             });
             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) {
@@ -159,6 +187,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({
@@ -194,6 +228,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.d.ts

@@ -35,6 +35,7 @@ export declare class Reporter {
     private networkEvents;
     private pendingTests;
     private workerToTest;
+    private pendingErrorMsg?;
     private passedCount;
     private failedCount;
     private isInteractive;

package/dist/runner/reporter.js

@@ -155,6 +155,7 @@ export class Reporter {
     networkEvents = [];
     pendingTests = new Map();
     workerToTest = new Map();
+    pendingErrorMsg;
     passedCount = 0;
     failedCount = 0;
     isInteractive;
@@ -355,10 +356,10 @@ 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`);
+                this.pendingErrorMsg = this.pendingErrorMsg ? `${this.pendingErrorMsg}\n${err}` : err;
             }
             return;
         }
@@ -394,16 +395,14 @@ export class Reporter {
             this.failedCount++;
             const testCase = this.pendingTests.get(title) || this.resolveTestCase(title);
             const steps = testCase?.steps || [];
-            const errorMsg = testCase?.errorMsg;
+            const errorMsg = testCase?.errorMsg || this.pendingErrorMsg;
+            this.pendingErrorMsg = undefined;
             const workerId = testCase?.workerId;
             this.pendingTests.delete(title);
             if (workerId !== undefined) {
                 this.workerToTest.delete(workerId);
             }
             this.clearActiveSlots();
-            if (errorMsg) {
-                console.log(`    \x1b[38;2;251;191;36m↳ Error:\x1b[0m \x1b[38;2;248;113;113m${errorMsg}\x1b[0m`);
-            }
             console.log(`${chalk.hex('#f87171')('✗')} ${chalk.white.bold(title)} ${chalk.gray(`(${duration}ms)`)}`);
             for (const step of steps) {
                 if (step.passed) {
@@ -413,6 +412,13 @@ export class Reporter {
                     console.log(`  ${chalk.red('✖')} ${chalk.red(step.text)} ${chalk.gray(`(${step.duration}ms)`)}`);
                 }
             }
+            if (errorMsg) {
+                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('');
             this.renderActiveSlots();
             return;

package/dist/utils/__tests__/dev-server-manager.test.d.ts

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

package/dist/utils/__tests__/dev-server-manager.test.js

@@ -0,0 +1,72 @@
+import http from 'node:http';
+import { describe, expect, it, vi } from 'vitest';
+import { DevServerManager } from '../dev-server-manager.js';
+describe('DevServerManager', () => {
+    it('parses command strings into binary and argv array without shell', () => {
+        expect(DevServerManager.parseCommand('pnpm --filter sso dev')).toEqual({
+            bin: 'pnpm',
+            args: ['--filter', 'sso', 'dev'],
+        });
+        expect(DevServerManager.parseCommand('nx run auth-e2e:serve --port=5174')).toEqual({
+            bin: 'nx',
+            args: ['run', 'auth-e2e:serve', '--port=5174'],
+        });
+        expect(DevServerManager.parseCommand('node "./scripts/serve.js" --mode "dev test"')).toEqual({
+            bin: 'node',
+            args: ['./scripts/serve.js', '--mode', 'dev test'],
+        });
+    });
+    it('probes listening HTTP server and detects readiness', async () => {
+        const server = http.createServer((_req, res) => {
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('OK');
+        });
+        await new Promise((resolve) => {
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const addr = server.address();
+        const url = `http://127.0.0.1:${addr.port}`;
+        const isReady = await DevServerManager.probeUrl(url, 1000);
+        expect(isReady).toBe(true);
+        const isNonExistentReady = await DevServerManager.probeUrl('http://127.0.0.1:49999', 200);
+        expect(isNonExistentReady).toBe(false);
+        await new Promise((resolve) => server.close(() => resolve()));
+    });
+    it('reuses existing running server without spawning new process', async () => {
+        const server = http.createServer((_req, res) => {
+            res.writeHead(200);
+            res.end('OK');
+        });
+        await new Promise((resolve) => {
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const addr = server.address();
+        const url = `http://127.0.0.1:${addr.port}`;
+        const manager = new DevServerManager();
+        const result = await manager.ensureServer({
+            name: 'test-server',
+            command: 'echo "should not run"',
+            url,
+            reuseExistingServer: true,
+        });
+        expect(result.reused).toBe(true);
+        expect(result.name).toBe('test-server');
+        expect(result.url).toBe(url);
+        await manager.stopAll();
+        await new Promise((resolve) => server.close(() => resolve()));
+    });
+    it('filters dev servers by target host filter', async () => {
+        const manager = new DevServerManager();
+        const spy = vi.spyOn(manager, 'ensureServer').mockResolvedValue({
+            name: 'sso',
+            url: 'https://sso.local:5174',
+            reused: true,
+        });
+        await manager.startAll([
+            { name: 'sso', command: 'pnpm sso:dev', url: 'https://sso.local:5174' },
+            { name: 'fam', command: 'pnpm fam:dev', url: 'https://fam.local:5175' },
+        ], 'sso');
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy).toHaveBeenCalledWith(expect.objectContaining({ name: 'sso' }), expect.any(String));
+    });
+});

package/dist/utils/background-update-check.d.ts

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

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

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+const cachePath = process.argv[2];
+if (!cachePath)
+    process.exit(0);
+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;
+    }
+}
+async function run() {
+    const updates = [];
+    for (const pkg of PACKAGES) {
+        const latest = getLatestVersion(pkg);
+        if (latest) {
+            // Hardcode a check or let the main thread do the actual diff
+            // For now, let's just record the latest versions.
+            updates.push({ pkg, latest });
+        }
+    }
+    // To properly do a diff, we should read package.json of the project.
+    // Since we don't have cwd here, we just save the latest versions and let the main thread diff it,
+    // OR we can pass the current versions as arguments to this script.
+    // For simplicity, we just save the latest versions.
+    const cacheData = {
+        timestamp: Date.now(),
+        latestVersions: updates,
+        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');
+}
+run().catch(() => { });

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;
+}