@testspectra/cli 1.1.7 → 1.1.8-rc.1

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

@@ -5,11 +5,13 @@ import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi }
 import { runCommand } from '../run.js';
 import { initCommand } from '../init.js';
 import { DemoServer } from '../../utils/demo-server.js';
+import { DemoApiServer } from '../../utils/api-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 apiServer;
     let consoleLogs = [];
     const originalLog = console.log;
     beforeAll(async () => {
@@ -21,13 +23,27 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
         catch {
             // Server may already be running on port 5173
         }
+        // The demo API server runs separately (port 5200). Tests that don't pass --demo still need it
+        // reachable: the web app now fetches the API cross-origin, so a JSON POST triggers a CORS
+        // preflight (OPTIONS) that isn't mocked and must reach a live API server.
+        apiServer = new DemoApiServer();
+        try {
+            await apiServer.start();
+        }
+        catch {
+            // API server may already be running on port 5200
+        }
     });
     afterAll(async () => {
-        // 4. AfterAll: Stop demo server
+        // 4. AfterAll: Stop demo servers
         try {
             await demoServer.stop();
         }
         catch { }
+        try {
+            await apiServer.stop();
+        }
+        catch { }
     });
     beforeEach(async () => {
         originalCwd = process.cwd();
@@ -64,7 +80,7 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
         })();
         expect(binaryExists).toBe(true);
         // Execute testspectra run -t web on full template project
-        await runCommand(undefined, { target: 'web' });
+        await runCommand(undefined, { target: 'web', demo: true });
         // Assert reports created
         const resultJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'result.json');
         expect(fs.existsSync(resultJsonPath)).toBe(true);
@@ -82,12 +98,12 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
         // Performance RSS assertion (< 30 MB)
         expect(resultJson.performance.peakMemoryRssMb).toBeLessThan(30);
         expect(resultJson.suites.length).toBeGreaterThanOrEqual(1);
-    }, 15000);
+    }, 30000);
     // 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' });
+        await runCommand([targetSpec], { target: 'web', demo: true });
         const resultJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'result.json');
         expect(fs.existsSync(resultJsonPath)).toBe(true);
         const resultJson = JSON.parse(fs.readFileSync(resultJsonPath, 'utf-8'));
@@ -99,10 +115,10 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
         expect(resultJson.summary.passed).toBe(1);
         expect(resultJson.summary.failed).toBe(0);
         expect(resultJson.summary.passRate).toBe('100%');
-    }, 15000);
+    }, 30000);
     // E2E-03: Network Recording Audit
     it('E2E-03: Network Recording Audit creates network-resources.json with request entries', async () => {
-        await runCommand(undefined, { target: 'web' });
+        await runCommand(undefined, { target: 'web', demo: true });
         const networkJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'network-resources.json');
         expect(fs.existsSync(networkJsonPath)).toBe(true);
         const networkRaw = fs.readFileSync(networkJsonPath, 'utf-8');
@@ -114,17 +130,17 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
         expect(first).toHaveProperty('url');
         expect(first).toHaveProperty('method');
         expect(first).toHaveProperty('status');
-    }, 15000);
+    }, 30000);
     // 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' });
+        await runCommand(undefined, { target: 'web', demo: true });
         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);
+    }, 30000);
     // 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
@@ -137,14 +153,14 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
 `, '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' });
+        await runCommand(['specs/Playground/TC-0099-failing/web.test.ts'], { target: 'web', demo: true });
         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);
+    }, 30000);
     // 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
@@ -158,7 +174,7 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
   await Spectra.getAll(".demo-product-item").shouldHaveLengthGreaterThan(0);
 });
 `, 'utf-8');
-        await runCommand('specs/Playground/TC-0100-spectra-static/web.test.ts', { target: 'web' });
+        await runCommand(['specs/Playground/TC-0100-spectra-static/web.test.ts'], { target: 'web', demo: true });
         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);
@@ -172,10 +188,235 @@ describe('End-to-End (E2E) Test Plan: Native Orchestrator Execution (docs/v2/cor
 });
 `, 'utf-8');
         const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { }));
-        await runCommand('specs/Playground/TC-0101-mismatch/web.test.ts', { target: 'web' });
+        await runCommand(['specs/Playground/TC-0101-mismatch/web.test.ts'], { target: 'web', demo: true });
         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);
+    // E2E-07: Spectra.intercept GET Mocking & Dynamic respondWith on Web in Real Chromium
+    it('E2E-07: Spectra.intercept GET Mocking & Dynamic respondWith on Web in real Chromium', async () => {
+        const targetSpec = 'specs/ApiInterception/TC-0008-fetch-mocking/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%');
+        // Assert network interception log was recorded in network-resources.json
+        const networkJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'network-resources.json');
+        expect(fs.existsSync(networkJsonPath)).toBe(true);
+        const networkEntries = JSON.parse(fs.readFileSync(networkJsonPath, 'utf-8'));
+        const interceptedPostReq = networkEntries.find((entry) => entry.url && entry.url.includes('/api/posts'));
+        expect(interceptedPostReq).toBeDefined();
+        expect(interceptedPostReq.status).toBe(200);
+    }, 20000);
+    // E2E-08: Spectra.intercept POST Mocking with status 201 and payload verification on Web in Real Chromium
+    it('E2E-08: Spectra.intercept POST Mocking with status 201 and payload verification on Web', async () => {
+        const targetSpec = 'specs/ApiInterception/TC-0009-post-mocking/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);
+        const networkJsonPath = path.join(tmpDir, '.testspectra', 'reports', 'network-resources.json');
+        expect(fs.existsSync(networkJsonPath)).toBe(true);
+        const networkEntries = JSON.parse(fs.readFileSync(networkJsonPath, 'utf-8'));
+        const postReq = networkEntries.find((entry) => entry.url && entry.url.includes('/api/posts') && entry.status === 201);
+        expect(postReq).toBeDefined();
+    }, 20000);
+    // E2E-09: Mobile API Interception & Socket Driver on Android target
+    it('E2E-09: Mobile API Interception and verification on Android target', async () => {
+        const net = await import('net');
+        // Start a mock Spectra Native Android Driver TCP Server on port 8200
+        const mockAndroidServer = net.createServer((socket) => {
+            let rxBuf = Buffer.alloc(0);
+            let fetchClickCount = 0;
+            socket.on('data', (chunk) => {
+                rxBuf = Buffer.concat([rxBuf, chunk]);
+                while (rxBuf.length >= 4) {
+                    const payloadLen = rxBuf.readUInt32BE(0);
+                    if (rxBuf.length < 4 + payloadLen)
+                        break;
+                    const payloadStr = rxBuf.slice(4, 4 + payloadLen).toString('utf8');
+                    rxBuf = rxBuf.slice(4 + payloadLen);
+                    try {
+                        const msg = JSON.parse(payloadStr);
+                        const cmd = msg.cmd;
+                        const id = msg.id;
+                        const params = msg.params || {};
+                        let responseData = {};
+                        if (cmd === 'FIND_ALL') {
+                            const sel = (params.selector || '').toLowerCase();
+                            // The driver now reads via a single full-hierarchy dump (`FIND_ALL xpath //*`) and
+                            // resolves selectors in memory, while actions use a targeted lookup for a live
+                            // nodeId. This mock returns the same node set for both, so either path resolves.
+                            //
+                            // TC-0008's mobile.test.ts drives 4 clicks in its single it() block: base mock
+                            // (2 items) -> respondWith dynamic update (1 item) -> respondOnce queued response
+                            // (1 item) -> reverted to base mock (2 items again).
+                            const items = fetchClickCount === 2
+                                ? [{ nodeId: 'item-dyn-1', text: 'Dynamic Updated Mock Title' }]
+                                : fetchClickCount === 3
+                                    ? [{ nodeId: 'item-once-1', text: 'One-Time Queued Response' }]
+                                    : [
+                                        { nodeId: 'item-1', text: 'Mocked Post 1 - TestSpectra Matchers' },
+                                        { nodeId: 'item-2', text: 'Mocked Post 2 - Cross-Platform Automation' },
+                                    ];
+                            const mkNode = (nodeId, text, id) => ({
+                                nodeId,
+                                text,
+                                resourceId: id,
+                                contentDesc: id,
+                                bounds: [0, 0, 10, 10],
+                                displayed: true,
+                                clickable: true,
+                                enabled: true,
+                                checked: false,
+                                selected: false,
+                                focused: false,
+                            });
+                            const tree = [
+                                mkNode('toggle-1', '☰', 'toggle-sidebar-btn'),
+                                mkNode('close-1', '✕', 'close-sidebar-btn'),
+                                mkNode('nav-1', 'API Fetch', 'nav-item-api-fetch'),
+                                mkNode('fetch-api-btn-node', 'Fetch Data', 'fetch-api-btn'),
+                                mkNode('badge-1', '200 OK', 'fetch-status-badge'),
+                                ...items.map((n, i) => mkNode(n.nodeId || `item-${i}`, n.text, 'api-post-item')),
+                                mkNode('badge-2', '201 Created', 'post-status-badge'),
+                                mkNode('banner-1', 'Successfully created post', 'post-success-banner'),
+                                mkNode('resp-json-1', '{"title": "TestSpectra Automated Post"}', 'post-response-json'),
+                            ];
+                            responseData = sel.startsWith('//')
+                                ? tree
+                                : tree.filter((n) => n.resourceId === sel || n.contentDesc === sel);
+                        }
+                        else if (cmd === 'CLICK' || cmd === 'PERFORM_ACTION') {
+                            if (params.node_id === 'fetch-api-btn-node' || params.nodeId === 'fetch-api-btn-node') {
+                                fetchClickCount++;
+                            }
+                            responseData = true;
+                        }
+                        else if (cmd === 'GET_ATTRIBUTE') {
+                            const attr = params.attr;
+                            if (attr === 'text') {
+                                responseData = '200 OK';
+                            }
+                            else {
+                                responseData = 'Mock Attribute';
+                            }
+                        }
+                        const respObj = { id, ok: true, data: responseData };
+                        const respStr = JSON.stringify(respObj);
+                        const respLen = Buffer.byteLength(respStr, 'utf8');
+                        const frame = Buffer.alloc(4 + respLen);
+                        frame.writeUInt32BE(respLen, 0);
+                        frame.write(respStr, 4, 'utf8');
+                        socket.write(frame);
+                    }
+                    catch { }
+                }
+            });
+        });
+        let isMockServerRunning = false;
+        await new Promise((resolve) => {
+            mockAndroidServer.once('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    resolve();
+                }
+            });
+            mockAndroidServer.listen(8200, '127.0.0.1', () => {
+                isMockServerRunning = true;
+                resolve();
+            });
+        });
+        try {
+            const configPath = path.join(tmpDir, 'spectra.config.ts');
+            if (fs.existsSync(configPath)) {
+                let conf = fs.readFileSync(configPath, 'utf-8');
+                conf = conf.replace(/appPackage:\s*["'][^"']*["'],/, 'appPackage: "",');
+                fs.writeFileSync(configPath, conf, 'utf-8');
+            }
+            const targetSpec = 'specs/ApiInterception/TC-0008-fetch-mocking/mobile.test.ts';
+            expect(fs.existsSync(path.join(tmpDir, targetSpec))).toBe(true);
+            await runCommand([targetSpec], { target: 'android', device: 'mock-device' });
+            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('android');
+            expect(resultJson.status).toBe('passed');
+            expect(resultJson.summary.passed).toBe(1);
+            expect(resultJson.summary.failed).toBe(0);
+        }
+        finally {
+            if (isMockServerRunning) {
+                await new Promise((resolve) => {
+                    mockAndroidServer.close(() => resolve());
+                });
+            }
+        }
+    }, 25000);
+    // E2E-10: Spectra.intercept FIFO respondOnce sequential polling and abort simulation
+    it('E2E-10: Spectra.intercept FIFO respondOnce sequential polling and abort simulation in real Chromium', async () => {
+        const fifoAbortDir = path.join(tmpDir, 'specs', 'ApiInterception', 'TC-0010-fifo-abort');
+        fs.mkdirSync(fifoAbortDir, { recursive: true });
+        fs.writeFileSync(path.join(fifoAbortDir, 'web.test.ts'), `it("should handle FIFO respondOnce queue and abort simulation", async () => {
+  await MatchersPage.open("api-fetch");
+
+  // Setup intercept with default fallback and FIFO queue
+  const mock = await Spectra.intercept("api/posts", "GET", [
+    { id: 999, title: "Default Fallback Post" }
+  ]);
+
+  await mock.respondOnce([
+    { id: 101, title: "FIFO Queued Post #1" }
+  ]);
+  await mock.respondOnce([
+    { id: 102, title: "FIFO Queued Post #2" }
+  ]);
+
+  // 1. First fetch triggers FIFO item #1
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchedItems.first().shouldContainText("FIFO Queued Post #1");
+
+  // 2. Second fetch triggers FIFO item #2
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchedItems.first().shouldContainText("FIFO Queued Post #2");
+
+  // 3. Third fetch falls back to default response
+  await MatchersPage.fetchApiButton.click();
+  await MatchersPage.fetchedItems.first().shouldContainText("Default Fallback Post");
+
+  // 4. Test abort simulation
+  await mock.abort("Failed");
+  await MatchersPage.fetchApiButton.click();
+  // On network failure, demo app shows fallback 200 OK from catch block
+  await MatchersPage.fetchStatusBadge.shouldHaveText("200 OK");
+});
+`, 'utf-8');
+        await runCommand(['specs/ApiInterception/TC-0010-fifo-abort/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'));
+        expect(resultJson.version).toBe('2.0.0');
+        expect(resultJson.platform).toBe('web');
+        expect(resultJson.status).toBe('passed');
+        expect(resultJson.summary.passed).toBe(1);
+        expect(resultJson.summary.failed).toBe(0);
+    }, 25000);
 });

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

@@ -6,19 +6,17 @@ 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(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         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;
@@ -32,26 +30,24 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
             };
         });
         // Run single spec
-        await runCommand('specs/Auth/TC-0001/web.test.ts');
+        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(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         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;
@@ -64,13 +60,14 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 logs: [],
             };
         });
-        await runCommand('specs/Auth/TC-0001/web.test.ts', { concurrency: 4 });
+        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(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
             webConfig: {
                 baseUrl: 'http://localhost:3000',
@@ -81,7 +78,6 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 devices: [{ id: 'emulator-5554' }],
             },
             iosConfig: {},
-            browsers: [],
             executionConfig: {},
         });
         let bridgeOptionsReceived = null;
@@ -94,7 +90,7 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 logs: [],
             };
         });
-        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
             target: 'android',
             devices: 'emulator-5554,emulator-5556',
         });
@@ -109,11 +105,11 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
     });
     it('correctly serializes single --device option into devices array of objects', async () => {
         vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
             webConfig: { baseUrl: 'http://localhost:3000' },
             androidConfig: { driverServer: 'http://127.0.0.1:4800' },
             iosConfig: {},
-            browsers: [],
             executionConfig: {},
         });
         let bridgeOptionsReceived = null;
@@ -126,7 +122,7 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 logs: [],
             };
         });
-        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
             target: 'android',
             device: 'emulator-5554',
         });
@@ -138,11 +134,11 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
     });
     it('correctly serializes --all-devices flag into auto devices in config', async () => {
         vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
             webConfig: { baseUrl: 'http://localhost:3000' },
             androidConfig: { driverServer: 'http://127.0.0.1:4800' },
             iosConfig: {},
-            browsers: [],
             executionConfig: {},
         });
         let bridgeOptionsReceived = null;
@@ -155,7 +151,7 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 logs: [],
             };
         });
-        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
             target: 'android',
             allDevices: true,
         });
@@ -167,11 +163,11 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
     });
     it('correctly serializes --multi-device flag into auto devices in config', async () => {
         vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
         vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
             webConfig: { baseUrl: 'http://localhost:3000' },
             androidConfig: { driverServer: 'http://127.0.0.1:4800' },
             iosConfig: {},
-            browsers: [],
             executionConfig: {},
         });
         let bridgeOptionsReceived = null;
@@ -184,7 +180,7 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
                 logs: [],
             };
         });
-        await runCommand('specs/Auth/TC-0001/android.test.ts', {
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
             target: 'android',
             multiDevice: true,
         });
@@ -194,4 +190,84 @@ describe('runCommand Integration & Dynamic Worker Sizing', () => {
         expect(bridgeOptionsReceived.config.androidConfig.devices).toBe('auto');
         expect(bridgeOptionsReceived.targetDevice).toBe('auto');
     });
+    it('sets process.exitCode to 1 when tests fail', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            executionConfig: {},
+        });
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async () => {
+            return {
+                status: 'failed',
+                duration: '1.5s',
+                passedCount: 1,
+                failedCount: 1,
+                results: [],
+                logs: [],
+            };
+        });
+        process.exitCode = undefined;
+        await runCommand(['specs/ApiInterception'], { target: 'web' });
+        expect(process.exitCode).toBe(1);
+        process.exitCode = undefined; // reset
+    });
+    it('incorporates TESTSPECTRA_CARRIED_OVER into summary card calculation', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            executionConfig: {},
+        });
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async () => {
+            return {
+                status: 'passed',
+                duration: '2.0s',
+                passedCount: 1,
+                failedCount: 0,
+                results: [],
+                logs: [],
+            };
+        });
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        process.env.TESTSPECTRA_CARRIED_OVER = JSON.stringify({
+            passed: 3,
+            durationMs: 4000,
+        });
+        await runCommand(['specs/ApiInterception/TC-0008-fetch-mocking/web.test.ts'], { target: 'web' });
+        delete process.env.TESTSPECTRA_CARRIED_OVER;
+        const logged = consoleSpy.mock.calls.map((c) => c[0]).join('\n');
+        expect(logged).toContain('4 passed');
+        expect(logged).toContain('3 carried over');
+        expect(logged).toContain('4 total');
+        expect(logged).toContain('6.0s');
+        consoleSpy.mockRestore();
+    });
+    it('correctly passes multiple specs to RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(TypeGenerator, 'syncEnvDeclaration').mockResolvedValue(undefined);
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            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/web.test.ts', 'specs/Auth/TC-0002/web.test.ts']);
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.specs).toEqual(['specs/Auth/TC-0001/web.test.ts', 'specs/Auth/TC-0002/web.test.ts']);
+    });
 });

package/dist/commands/demo.js

@@ -1,24 +1,34 @@
 import chalk from 'chalk';
 import * as p from '@clack/prompts';
 import { DemoServer } from '../utils/demo-server.js';
+import { DemoApiServer } from '../utils/api-server.js';
 export async function demoCommand(options) {
     const port = options.port ? parseInt(options.port, 10) : 5173;
     p.intro(chalk.bold.cyan('🌐 TestSpectra Demo Web App'));
     const server = new DemoServer(port);
+    const apiServer = new DemoApiServer();
     try {
         const { url } = await server.start();
         p.log.success(chalk.green(`Demo web app is live at: ${chalk.bold.underline(url)}`));
+        // The web app fetches its API sections from the separate self-hosted API server, so start it
+        // too — otherwise the API demo sections show only their offline fallback data.
+        try {
+            const { url: apiUrl } = await apiServer.start();
+            p.log.success(chalk.green(`Demo API server is live at: ${chalk.bold.underline(apiUrl)}`));
+        }
+        catch (err) {
+            p.log.warn(chalk.yellow(`Could not start demo API server: ${err.message}`));
+        }
         p.log.info(chalk.dim("You can now run tests against this server in another terminal (e.g. 'spectra run -t web')."));
-        p.log.info(chalk.dim('Press Ctrl+C to stop the server.'));
+        p.log.info(chalk.dim('Press Ctrl+C to stop the servers.'));
         // Handle termination gracefully
-        process.on('SIGINT', async () => {
+        const shutdown = async () => {
             await server.stop();
+            await apiServer.stop();
             process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            await server.stop();
-            process.exit(0);
-        });
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
         await new Promise(() => { });
     }
     catch (err) {

package/dist/commands/init.d.ts

@@ -1,5 +1,5 @@
 export interface InitCommandOptions {
     force?: boolean;
-    template?: 'default' | 'nx';
+    template?: 'default' | 'nx' | 'react-component';
 }
 export declare function initCommand(options?: InitCommandOptions): Promise<void>;

package/dist/commands/init.js

@@ -215,10 +215,15 @@ export async function initCommand(options = {}) {
                     hint: 'Interactive workspace feature discovery & centralized config',
                 },
                 {
-                    label: 'Standard Project',
+                    label: 'Standard E2E Project',
                     value: 'default',
                     hint: 'Standalone single-suite E2E testing project',
                 },
+                {
+                    label: 'React Component Testing',
+                    value: 'react-component',
+                    hint: 'Real-browser React component testing with Vite & Testing Library',
+                },
             ],
         });
         if (p.isCancel(templateChoice)) {