@testspectra/cli 1.1.8-rc.13 → 1.1.8-rc.16

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

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cloudRunCommand, parseTimeoutMs } from '../cloud-run.js';
+const ORIGINAL_ENV = { ...process.env };
+function mockFetchSequence(responses) {
+    let call = 0;
+    return vi.fn(async (_url, _init) => {
+        const res = responses[Math.min(call, responses.length - 1)];
+        call += 1;
+        return {
+            ok: res.ok,
+            status: res.status ?? (res.ok ? 200 : 500),
+            statusText: 'error',
+            json: async () => res.json,
+        };
+    });
+}
+describe('cloudRunCommand (docs/v2/cloud/git-spec-standards-and-workflow.md)', () => {
+    beforeEach(() => {
+        process.env = { ...ORIGINAL_ENV, SPECTRA_URL: 'https://cloud.test', SPECTRA_TOKEN: 'gitea-pat-123' };
+        process.exitCode = undefined;
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        process.env = { ...ORIGINAL_ENV };
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+    it('fails fast without SPECTRA_URL/SPECTRA_TOKEN', async () => {
+        delete process.env.SPECTRA_URL;
+        delete process.env.SPECTRA_TOKEN;
+        const fetchSpy = vi.fn();
+        vi.stubGlobal('fetch', fetchSpy);
+        await cloudRunCommand({ project: 'org/repo', branch: 'main' });
+        expect(process.exitCode).toBe(1);
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+    it('triggers and returns immediately with --no-wait', async () => {
+        const fetchSpy = mockFetchSequence([{ ok: true, json: { job_id: 'job-1', status: 'queued' } }]);
+        vi.stubGlobal('fetch', fetchSpy);
+        await cloudRunCommand({ project: 'org/repo', branch: 'main', wait: false });
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        const [url, init] = fetchSpy.mock.calls[0];
+        expect(url).toBe('https://cloud.test/api/v1/runs/trigger');
+        const headers = init.headers;
+        expect(headers.Authorization).toBe('Bearer gitea-pat-123');
+        expect(JSON.parse(init.body)).toMatchObject({ project_id: 'org/repo', branch: 'main', platform: 'web' });
+        expect(process.exitCode).toBeUndefined();
+    });
+    it('exits 0 when the job reaches done', async () => {
+        const fetchSpy = mockFetchSequence([
+            { ok: true, json: { job_id: 'job-2', status: 'queued' } },
+            { ok: true, json: { status: 'done', run_id: 'run-2', started_at: null, completed_at: null, error_log: null } },
+        ]);
+        vi.stubGlobal('fetch', fetchSpy);
+        const promise = cloudRunCommand({ project: 'org/repo', branch: 'main' });
+        await vi.advanceTimersByTimeAsync(5000);
+        await promise;
+        expect(process.exitCode).toBe(0);
+    });
+    it('exits 1 when the job reaches failed', async () => {
+        const fetchSpy = mockFetchSequence([
+            { ok: true, json: { job_id: 'job-3', status: 'queued' } },
+            {
+                ok: true,
+                json: { status: 'failed', run_id: 'run-3', started_at: null, completed_at: null, error_log: 'boom' },
+            },
+        ]);
+        vi.stubGlobal('fetch', fetchSpy);
+        const promise = cloudRunCommand({ project: 'org/repo', branch: 'main' });
+        await vi.advanceTimersByTimeAsync(5000);
+        await promise;
+        expect(process.exitCode).toBe(1);
+    });
+    it('exits 1 when the trigger request itself fails', async () => {
+        const fetchSpy = mockFetchSequence([{ ok: false, status: 401, json: { error: 'Invalid PAT' } }]);
+        vi.stubGlobal('fetch', fetchSpy);
+        await cloudRunCommand({ project: 'org/repo', branch: 'main' });
+        expect(process.exitCode).toBe(1);
+    });
+});
+describe('parseTimeoutMs', () => {
+    it('parses seconds, minutes, and hours', () => {
+        expect(parseTimeoutMs('30s')).toBe(30_000);
+        expect(parseTimeoutMs('30m')).toBe(30 * 60_000);
+        expect(parseTimeoutMs('2h')).toBe(2 * 3_600_000);
+    });
+    it('defaults to minutes when no unit is given', () => {
+        expect(parseTimeoutMs('10')).toBe(10 * 60_000);
+    });
+    it('falls back to 30m for unparseable input', () => {
+        expect(parseTimeoutMs('nonsense')).toBe(30 * 60_000);
+    });
+});

package/dist/commands/cloud-run.d.ts

@@ -0,0 +1,13 @@
+export interface CloudRunOptions {
+    project: string;
+    projectName?: string;
+    branch?: string;
+    commit?: string;
+    platform?: string;
+    wait?: boolean;
+    timeout?: string;
+    demo?: boolean;
+    baseUrl?: string;
+}
+export declare function parseTimeoutMs(timeout: string): number;
+export declare function cloudRunCommand(options: CloudRunOptions): Promise<void>;

package/dist/commands/cloud-run.js

@@ -0,0 +1,120 @@
+import { execFileSync } from 'child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+const POLL_INTERVAL_MS = 5000;
+const DEFAULT_TIMEOUT = '30m';
+function detectGitRef(...args) {
+    try {
+        return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseTimeoutMs(timeout) {
+    const match = /^(\d+)(s|m|h)?$/.exec(timeout.trim());
+    if (!match)
+        return 30 * 60 * 1000;
+    const value = Number(match[1]);
+    const unit = match[2] ?? 'm';
+    const multiplier = unit === 's' ? 1000 : unit === 'h' ? 3_600_000 : 60_000;
+    return value * multiplier;
+}
+// Same credential path as the trigger endpoint expects: a Gitea PAT, not the
+// dashboard's OAuth2 session — a CI runner can't complete a browser redirect.
+// See docs/v2/cloud/git-spec-standards-and-workflow.md.
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(chalk.red(`Missing required environment variable: ${name}`));
+        console.error(chalk.gray('Set it as a CI secret — see docs/v2/cloud/git-spec-standards-and-workflow.md'));
+    }
+    return value;
+}
+export async function cloudRunCommand(options) {
+    const spectraUrl = requireEnv('SPECTRA_URL')?.replace(/\/$/, '');
+    const spectraToken = requireEnv('SPECTRA_TOKEN');
+    if (!spectraUrl || !spectraToken) {
+        process.exitCode = 1;
+        return;
+    }
+    const branch = options.branch ?? detectGitRef('rev-parse', '--abbrev-ref', 'HEAD');
+    if (!branch) {
+        console.error(chalk.red('Could not determine branch: pass --branch or run inside a git repository.'));
+        process.exitCode = 1;
+        return;
+    }
+    const commit = options.commit ?? detectGitRef('rev-parse', 'HEAD');
+    const platform = options.platform ?? 'web';
+    const wait = options.wait !== false;
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    const spinner = ora(`Triggering cloud run for ${chalk.bold(options.project)}@${branch}...`).start();
+    let trigger;
+    try {
+        const res = await fetch(`${spectraUrl}/api/v1/runs/trigger`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${spectraToken}`,
+            },
+            body: JSON.stringify({
+                project_id: options.project,
+                project_name: options.projectName ?? options.project,
+                branch,
+                commit_hash: commit,
+                platform,
+                demo: options.demo ?? false,
+                base_url: options.baseUrl,
+            }),
+        });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: res.statusText }));
+            throw new Error(body.error ?? `HTTP ${res.status}`);
+        }
+        trigger = (await res.json());
+    }
+    catch (err) {
+        spinner.fail(chalk.red(`Failed to trigger cloud run: ${err.message}`));
+        process.exitCode = 1;
+        return;
+    }
+    spinner.succeed(`Cloud run queued: ${chalk.cyan(trigger.job_id)}`);
+    if (!wait) {
+        console.log(chalk.gray(`Not waiting for result. Poll ${spectraUrl}/api/v1/jobs/${trigger.job_id}/status yourself.`));
+        return;
+    }
+    await waitForJob(spectraUrl, spectraToken, trigger.job_id, timeout);
+}
+async function waitForJob(spectraUrl, spectraToken, jobId, timeout) {
+    const spinner = ora('Waiting for run to finish...').start();
+    const deadline = Date.now() + parseTimeoutMs(timeout);
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        let job;
+        try {
+            const res = await fetch(`${spectraUrl}/api/v1/jobs/${jobId}/status`, {
+                headers: { Authorization: `Bearer ${spectraToken}` },
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            job = (await res.json());
+        }
+        catch (err) {
+            spinner.text = chalk.yellow(`Poll failed, retrying: ${err.message}`);
+            continue;
+        }
+        if (job.status === 'done') {
+            spinner.succeed(chalk.green(`Run passed (run_id: ${job.run_id})`));
+            process.exitCode = 0;
+            return;
+        }
+        if (job.status === 'failed') {
+            spinner.fail(chalk.red(`Run failed (run_id: ${job.run_id})${job.error_log ? `: ${job.error_log}` : ''}`));
+            process.exitCode = 1;
+            return;
+        }
+        spinner.text = `Run status: ${job.status}`;
+    }
+    spinner.fail(chalk.red(`Timed out after ${timeout} waiting for the run to finish.`));
+    process.exitCode = 1;
+}

package/dist/commands/test.js

@@ -15,7 +15,7 @@ import { runSystemChecks } from './doctor.js';
 async function resolveBrowserExecutable(cwd) {
     try {
         const { dependencies } = await runSystemChecks(cwd);
-        const chrome = dependencies.find((d) => d.category === 'web' && (d.name.includes('Chrome') || d.name.includes('Chromium')));
+        const chrome = dependencies.find((d) => d.category === 'web' && d.name.includes('Chrome'));
         return chrome?.installed && chrome.location ? chrome.location : null;
     }
     catch {
@@ -81,9 +81,11 @@ export async function testCommand(options = {}) {
         concurrency: concurrency !== undefined && !isNaN(concurrency) ? concurrency : undefined,
         browserExecutablePath,
         onLine: (line) => {
-            if (!line.startsWith('[TESTSPECTRA_'))
+            // Strip ANSI and whitespace since Vitest might prefix or colorize console logs
+            const cleanLine = line.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '').trim();
+            if (!cleanLine.startsWith('[TESTSPECTRA_'))
                 return;
-            reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'INFO', message: line });
+            reporter.addLog({ timestamp: new Date().toLocaleTimeString(), level: 'INFO', message: cleanLine });
             if (!reporter.isInteractiveMode()) {
                 console.log(line);
             }

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

@@ -41,7 +41,8 @@ describe('Platform TSConfigs & Type Isolation (docs/v2/cli/tsconfig-platform-iso
         expect(rootConfig.references).toEqual([{ path: './.testspectra/tsconfig.json' }]);
         // Verify dynamic master solution references all 5 platform solution tsconfigs in .testspectra/tsconfig/
         const solutionConfig = JSON.parse(fs.readFileSync(path.join(tmpDir, '.testspectra', 'tsconfig.json'), 'utf-8'));
-        expect(solutionConfig.compilerOptions.noEmit).toBe(true);
+        expect(solutionConfig.compilerOptions.composite).toBe(true);
+        expect(solutionConfig.compilerOptions.noEmit).toBeUndefined();
         expect(solutionConfig.references).toEqual([
             { path: './tsconfig/web.json' },
             { path: './tsconfig/mobile.json' },

package/dist/generator/tsconfig-generator.js

@@ -16,7 +16,7 @@ export class TsConfigGenerator {
                 moduleResolution: 'NodeNext',
                 skipLibCheck: true,
                 strict: true,
-                noEmit: true,
+                composite: true,
             },
             files: [],
             references: references || [

package/package.json

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

package/templates/default/package.json

@@ -17,8 +17,8 @@
     "postinstall": "spectra sync-types"
   },
   "devDependencies": {
-    "@testspectra/cli": "^1.1.8-rc.13",
-    "@testspectra/matchers": "^1.1.8-rc.13",
+    "@testspectra/cli": "^1.1.8-rc.16",
+    "@testspectra/matchers": "^1.1.8-rc.16",
     "@types/node": "^20.14.0",
     "@wdio/cli": "^9.2.8",
     "@wdio/local-runner": "^9.2.8",