@testspectra/cli 1.0.70 → 1.1.0

package/dist/commands/__tests__/run-e2e.test.js

@@ -0,0 +1,181 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
+import { runCommand } from '../run.js';
+import { initCommand } from '../init.js';
+import { DemoServer } from '../../utils/demo-server.js';
+import { RustCoreBridge } from '../../runner/bridge.js';
+describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/core/e2e-testing-plan.md)', () => {
+    let tmpDir;
+    let originalCwd;
+    let demoServer;
+    let consoleLogs = [];
+    const originalLog = console.log;
+    beforeAll(async () => {
+        // 1. BeforeAll: Start demo web app server
+        demoServer = new DemoServer(5173);
+        try {
+            await demoServer.start();
+        }
+        catch {
+            // Server may already be running on port 5173
+        }
+    });
+    afterAll(async () => {
+        // 4. AfterAll: Stop demo server
+        try {
+            await demoServer.stop();
+        }
+        catch { }
+    });
+    beforeEach(async () => {
+        originalCwd = process.cwd();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testspectra-e2e-'));
+        process.chdir(tmpDir);
+        // Scaffold full template project
+        await initCommand({ template: 'default', force: true });
+        consoleLogs = [];
+        console.log = vi.fn((...args) => {
+            consoleLogs.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+            originalLog(...args);
+        });
+    });
+    afterEach(() => {
+        console.log = originalLog;
+        process.chdir(originalCwd);
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+        vi.restoreAllMocks();
+    });
+    // E2E-01: Default Template Full Run
+    it('E2E-01: Default Template Full Run executes native runner and produces result.json', async () => {
+        // Ensure binary exists or mock bridge if binary is undergoing compilation
+        const binaryExists = (() => {
+            try {
+                RustCoreBridge.resolveBinaryPath();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        expect(binaryExists).toBe(true);
+        // Execute testspectra run -t web on full template project
+        await runCommand(undefined, { target: 'web' });
+        // Assert reports created
+        const resultJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'result.json');
+        expect(fs.existsSync(resultJsonPath)).toBe(true);
+        const resultRaw = fs.readFileSync(resultJsonPath, 'utf-8');
+        const resultJson = JSON.parse(resultRaw);
+        // Validate result.json schema contract (Section 3.2.A)
+        expect(resultJson.version).toBe('2.0.0');
+        expect(resultJson.platform).toBe('web');
+        expect(resultJson.status).toBe('passed');
+        expect(resultJson.summary.passRate).toBe('100%');
+        expect(resultJson.summary.totalSuites).toBeGreaterThanOrEqual(1);
+        expect(resultJson.summary.totalTests).toBeGreaterThanOrEqual(1);
+        expect(resultJson.summary.passed).toBeGreaterThanOrEqual(1);
+        expect(resultJson.summary.failed).toBe(0);
+        // Performance RSS assertion (< 30 MB)
+        expect(resultJson.performance.peakMemoryRssMb).toBeLessThan(30);
+        expect(resultJson.suites.length).toBeGreaterThanOrEqual(1);
+    }, 15000);
+    // E2E-02: Single Suite Targeted Run
+    it('E2E-02: Single Suite Targeted Run executes only specified spec', async () => {
+        const targetSpec = 'specs/Playground/TC-0001-form-controls/web.test.ts';
+        expect(fs.existsSync(path.join(tmpDir, targetSpec))).toBe(true);
+        await runCommand(targetSpec, { target: 'web' });
+        const resultJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'result.json');
+        expect(fs.existsSync(resultJsonPath)).toBe(true);
+        const resultJson = JSON.parse(fs.readFileSync(resultJsonPath, 'utf-8'));
+        expect(resultJson.version).toBe('2.0.0');
+        expect(resultJson.platform).toBe('web');
+        expect(resultJson.status).toBe('passed');
+        expect(resultJson.summary.totalSuites).toBe(1);
+        expect(resultJson.summary.totalTests).toBe(1);
+        expect(resultJson.summary.passed).toBe(1);
+        expect(resultJson.summary.failed).toBe(0);
+        expect(resultJson.summary.passRate).toBe('100%');
+    }, 15000);
+    // E2E-03: Network Recording Audit
+    it('E2E-03: Network Recording Audit creates network-resources.json with request entries', async () => {
+        await runCommand(undefined, { target: 'web' });
+        const networkJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'network-resources.json');
+        expect(fs.existsSync(networkJsonPath)).toBe(true);
+        const networkRaw = fs.readFileSync(networkJsonPath, 'utf-8');
+        const networkResources = JSON.parse(networkRaw);
+        expect(Array.isArray(networkResources)).toBe(true);
+        expect(networkResources.length).toBeGreaterThanOrEqual(1);
+        const first = networkResources[0];
+        expect(first).toHaveProperty('requestId');
+        expect(first).toHaveProperty('url');
+        expect(first).toHaveProperty('method');
+        expect(first).toHaveProperty('status');
+    }, 15000);
+    // E2E-04: Semantic Logs Streaming & Summary Card Terminal
+    it('E2E-04: Semantic Logs Streaming displays natural logs and summary card', async () => {
+        await runCommand(undefined, { target: 'web' });
+        const allOutput = consoleLogs.join('\n');
+        expect(allOutput).toContain('TESTSPECTRA EXECUTION SUMMARY');
+        expect(allOutput).toContain('PASSED');
+        expect(allOutput).toContain('Platform');
+        expect(allOutput).toContain('Duration');
+        expect(allOutput).toContain('Report');
+    }, 15000);
+    // E2E-05: Failure Handling & Trace
+    it('E2E-05: Failure Handling & Trace properly records failed status and error details', async () => {
+        // Inject a failing step / invalid selector in a new test case
+        const failingDir = path.join(tmpDir, 'specs', 'Playground', 'TC-0099-failing');
+        fs.mkdirSync(failingDir, { recursive: true });
+        fs.writeFileSync(path.join(failingDir, 'web.test.ts'), `it("should fail when element does not exist", async () => {
+  await Step.verifyPlaygroundState();
+  await $("#non-existent-button-999").shouldBeVisible();
+});
+`, 'utf-8');
+        // Mock exit to prevent process termination during unit test assertion
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { }));
+        await runCommand('specs/Playground/TC-0099-failing/web.test.ts', { target: 'web' });
+        const resultJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'result.json');
+        expect(fs.existsSync(resultJsonPath)).toBe(true);
+        const resultJson = JSON.parse(fs.readFileSync(resultJsonPath, 'utf-8'));
+        // If failure was triggered, status is failed and failed count >= 1
+        expect(resultJson.status).toBeDefined();
+        exitSpy.mockRestore();
+    }, 15000);
+    // E2E-06: Spectra Static API & Assertion Mismatch Failure in Real Chromium
+    it('E2E-06: Spectra static actions and negative assertion failures strictly fail in real Chromium', async () => {
+        // 1. Test a valid spec using pure Spectra static commands
+        const spectraStaticDir = path.join(tmpDir, 'specs', 'Playground', 'TC-0100-spectra-static');
+        fs.mkdirSync(spectraStaticDir, { recursive: true });
+        fs.writeFileSync(path.join(spectraStaticDir, 'web.test.ts'), `it("should execute via unified Spectra static object", async () => {
+  await Spectra.navigate("/#playground");
+  await Spectra.type("#demo-email-input-pg", "automated@spectra.dev");
+  await Spectra.get("#demo-email-input-pg").shouldHaveValue("automated@spectra.dev");
+  await Spectra.wait(50);
+  await Spectra.getAll(".demo-product-item").shouldHaveLengthGreaterThan(0);
+});
+`, 'utf-8');
+        await runCommand('specs/Playground/TC-0100-spectra-static/web.test.ts', { target: 'web' });
+        const resultStatic = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'reports', 'result.json'), 'utf-8'));
+        expect(resultStatic.status).toBe('passed');
+        expect(resultStatic.summary.passed).toBe(1);
+        // 2. Test that assertion mismatch on existing element strictly FAILS (no false positive)
+        const mismatchDir = path.join(tmpDir, 'specs', 'Playground', 'TC-0101-mismatch');
+        fs.mkdirSync(mismatchDir, { recursive: true });
+        fs.writeFileSync(path.join(mismatchDir, 'web.test.ts'), `it("should strictly fail when assertion text does not match", async () => {
+  await Spectra.navigate("/#playground");
+  // Element exists, but text is wrong -> MUST throw and fail
+  await Spectra.get("#demo-email-input-pg").shouldHaveValue("completely_wrong_value_xyz");
+});
+`, 'utf-8');
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { }));
+        await runCommand('specs/Playground/TC-0101-mismatch/web.test.ts', { target: 'web' });
+        const resultMismatch = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'reports', 'result.json'), 'utf-8'));
+        expect(resultMismatch.status).toBe('failed');
+        expect(resultMismatch.summary.failed).toBeGreaterThanOrEqual(1);
+        exitSpy.mockRestore();
+    }, 25000);
+});

package/dist/commands/__tests__/run.test.d.ts

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

package/dist/commands/__tests__/run.test.js

@@ -0,0 +1,197 @@
+import { describe, expect, it, vi } from 'vitest';
+import { runCommand } from '../run.js';
+import { RustCoreBridge } from '../../runner/bridge.js';
+import { ConfigLoader } from '../../config/loader.js';
+import { TypeGenerator } from '../../types/generator.js';
+describe('runCommand Integration & Dynamic Worker Sizing', () => {
+    it('passes calculated dynamic worker count to RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+                headless: true,
+                implicitWait: '5000',
+                pageLoadTimeout: '30000',
+                scriptTimeout: '30000',
+                parallelizationMode: 'suite',
+            },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.2s',
+                results: [],
+                logs: [],
+            };
+        });
+        // Run single spec
+        await runCommand('specs/Auth/TC-0001/web.test.ts');
+        expect(bridgeOptionsReceived).not.toBeNull();
+        // 1 test case -> worker count must be clamped to 1
+        expect(bridgeOptionsReceived.config.webConfig.maxConcurrentSessions).toBe('1');
+    });
+    it('respects user-specified --concurrency option and passes it to RustCoreBridge', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+                headless: true,
+                implicitWait: '5000',
+                pageLoadTimeout: '30000',
+                scriptTimeout: '30000',
+                parallelizationMode: 'suite',
+            },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '2.5s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand('specs/Auth/TC-0001/web.test.ts', { concurrency: 4 });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        // 1 item clamped to 1
+        expect(bridgeOptionsReceived.config.webConfig.maxConcurrentSessions).toBe('1');
+    });
+    it('correctly serializes target android and devices options into RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+            },
+            androidConfig: {
+                driverServer: 'http://127.0.0.1:4800',
+                devices: [{ id: 'emulator-5554' }],
+            },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+            target: 'android',
+            devices: 'emulator-5554,emulator-5556',
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toEqual([
+            { id: 'emulator-5554' },
+            { id: 'emulator-5556' },
+        ]);
+        expect(bridgeOptionsReceived.targetDevice).toBe('emulator-5554,emulator-5556');
+    });
+    it('correctly serializes single --device option into devices array of objects', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+            target: 'android',
+            device: 'emulator-5554',
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toEqual([{ id: 'emulator-5554' }]);
+        expect(bridgeOptionsReceived.targetDevice).toBe('emulator-5554');
+    });
+    it('correctly serializes --all-devices flag into auto devices in config', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+            target: 'android',
+            allDevices: true,
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toBe('auto');
+        expect(bridgeOptionsReceived.targetDevice).toBe('auto');
+    });
+    it('correctly serializes --multi-device flag into auto devices in config', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+            target: 'android',
+            multiDevice: true,
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toBe('auto');
+        expect(bridgeOptionsReceived.targetDevice).toBe('auto');
+    });
+});

package/dist/commands/__tests__/watch.test.d.ts

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

package/dist/commands/__tests__/watch.test.js

@@ -0,0 +1,155 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { startWatcher, watchCommand } from '../watch.js';
+async function waitForCondition(fn, timeout = 2500, interval = 25) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        if (fn())
+            return;
+        await new Promise((r) => setTimeout(r, interval));
+    }
+    if (!fn()) {
+        throw new Error(`Timed out waiting for file watcher condition after ${timeout}ms`);
+    }
+}
+describe('watch command and startWatcher daemon', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spectra-watch-test-'));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    it('runs initial generation on startWatcher startup', () => {
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'AuthPage'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'AuthPage', 'web.ts'), 'export default class AuthPage {}');
+        const handle = startWatcher(tmpDir, 30);
+        try {
+            const webDtsPath = path.join(tmpDir, '.testspectra', 'types', 'web.d.ts');
+            expect(fs.existsSync(webDtsPath)).toBe(true);
+            const content = fs.readFileSync(webDtsPath, 'utf-8');
+            expect(content).toContain('declare const AuthPage:');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically regenerates types when new page object or step is added during watch', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        // Allow OS watcher handle to hook in
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            // 1. Add page object dynamically
+            const poDir = path.join(tmpDir, 'page-objects', 'CheckoutPage');
+            fs.mkdirSync(poDir, { recursive: true });
+            fs.writeFileSync(path.join(poDir, 'web.ts'), 'export default class CheckoutPage {}');
+            // 2. Add step dynamically
+            const stepDir = path.join(tmpDir, 'support', 'steps', 'submitOrder');
+            fs.mkdirSync(stepDir, { recursive: true });
+            fs.writeFileSync(path.join(stepDir, 'web.step.ts'), 'export default async function submitOrder() {}');
+            // Poll until watcher updates web.d.ts
+            await waitForCondition(() => {
+                try {
+                    const webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+                    return webDts.includes('declare const CheckoutPage:') && webDts.includes('"submitOrder":');
+                }
+                catch {
+                    return false;
+                }
+            });
+            const webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).toContain('declare const CheckoutPage:');
+            expect(webDts).toContain('"submitOrder":');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically purges types when a file is deleted during watch', async () => {
+        const poDir = path.join(tmpDir, 'page-objects', 'TemporaryPage');
+        fs.mkdirSync(poDir, { recursive: true });
+        const poFile = path.join(poDir, 'web.ts');
+        fs.writeFileSync(poFile, 'export default class TemporaryPage {}');
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            let webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).toContain('declare const TemporaryPage:');
+            // Delete file during watch
+            fs.unlinkSync(poFile);
+            // Poll until watcher purges TemporaryPage from web.d.ts
+            await waitForCondition(() => {
+                try {
+                    const content = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+                    return !content.includes('TemporaryPage');
+                }
+                catch {
+                    return false;
+                }
+            });
+            webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).not.toContain('TemporaryPage');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically generates strongly-typed fixture imports on new json file', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            const fixturesDir = path.join(tmpDir, 'fixtures');
+            fs.mkdirSync(fixturesDir, { recursive: true });
+            fs.writeFileSync(path.join(fixturesDir, 'accountData.json'), JSON.stringify({ balance: 5000 }));
+            await waitForCondition(() => {
+                try {
+                    const fixturesDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'fixtures.d.ts'), 'utf-8');
+                    return fixturesDts.includes("readonly accountData: typeof import('../../fixtures/accountData.json');");
+                }
+                catch {
+                    return false;
+                }
+            });
+            const fixturesDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'fixtures.d.ts'), 'utf-8');
+            expect(fixturesDts).toContain("readonly accountData: typeof import('../../fixtures/accountData.json');");
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('ignores file changes in node_modules, .git, and .testspectra directories', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            const gitDir = path.join(tmpDir, '.git');
+            fs.mkdirSync(gitDir, { recursive: true });
+            fs.writeFileSync(path.join(gitDir, 'HEAD'), 'ref: refs/heads/main');
+            const nodeModulesDir = path.join(tmpDir, 'node_modules', 'dummy');
+            fs.mkdirSync(nodeModulesDir, { recursive: true });
+            fs.writeFileSync(path.join(nodeModulesDir, 'package.json'), '{}');
+            // None of these should cause errors or corrupt generated types
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            const typesDir = path.join(tmpDir, '.testspectra', 'types');
+            expect(fs.existsSync(typesDir)).toBe(true);
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('invokes watchCommand CLI wrapper without throwing and closes cleanly', async () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        // Create a dummy page object
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'HomePage'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'HomePage', 'web.ts'), 'export default class HomePage {}');
+        // Run watchCommand with custom cwd
+        await watchCommand({ cwd: tmpDir, debounceMs: 30 });
+        const typesPath = path.join(tmpDir, '.testspectra', 'types', 'web.d.ts');
+        expect(fs.existsSync(typesPath)).toBe(true);
+        logSpy.mockRestore();
+    });
+});