@testspectra/cli 1.0.69 → 1.1.0

package/dist/commands/add.js

@@ -1,26 +1,26 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-import { TypeGenerator } from "../types/generator.js";
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { TypeGenerator } from '../types/generator.js';
 function parsePnpmWorkspaceGlobs(content) {
-    const lines = content.split("\n");
+    const lines = content.split('\n');
     const globs = [];
     let inPackages = false;
     for (const line of lines) {
         const trimmed = line.trim();
-        if (trimmed.startsWith("packages:")) {
+        if (trimmed.startsWith('packages:')) {
             inPackages = true;
             continue;
         }
         if (inPackages) {
-            if (trimmed.startsWith("-")) {
-                const item = trimmed.replace(/^-\s*['"]?/, "").replace(/['"]?\s*$/, "");
+            if (trimmed.startsWith('-')) {
+                const item = trimmed.replace(/^-\s*['"]?/, '').replace(/['"]?\s*$/, '');
                 if (item)
                     globs.push(item);
             }
-            else if (trimmed && !trimmed.startsWith("#")) {
+            else if (trimmed && !trimmed.startsWith('#')) {
                 break;
             }
         }
@@ -34,11 +34,11 @@ function scanDirectoriesForProjects(cwd, patterns) {
         if (currentDepth > maxDepth || !fs.existsSync(dir))
             return;
         const base = path.basename(dir);
-        if (base === "node_modules" || base === "dist" || base === ".testspectra" || base === ".git" || base === "shared") {
+        if (base === 'node_modules' || base === 'dist' || base === '.testspectra' || base === '.git' || base === 'shared') {
             return;
         }
-        const hasPkg = fs.existsSync(path.join(dir, "package.json"));
-        const hasNx = fs.existsSync(path.join(dir, "project.json"));
+        const hasPkg = fs.existsSync(path.join(dir, 'package.json'));
+        const hasNx = fs.existsSync(path.join(dir, 'project.json'));
         if ((hasPkg || hasNx) && dir !== cwd) {
             const rel = path.relative(cwd, dir);
             if (!visited.has(rel)) {
@@ -46,7 +46,7 @@ function scanDirectoriesForProjects(cwd, patterns) {
                 let name = path.basename(dir);
                 if (hasPkg) {
                     try {
-                        const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8"));
+                        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
                         if (pkg.name)
                             name = pkg.name;
                     }
@@ -54,7 +54,7 @@ function scanDirectoriesForProjects(cwd, patterns) {
                 }
                 else if (hasNx) {
                     try {
-                        const nxJson = JSON.parse(fs.readFileSync(path.join(dir, "project.json"), "utf-8"));
+                        const nxJson = JSON.parse(fs.readFileSync(path.join(dir, 'project.json'), 'utf-8'));
                         if (nxJson.name)
                             name = nxJson.name;
                     }
@@ -81,7 +81,7 @@ function scanDirectoriesForProjects(cwd, patterns) {
     }
     if (patterns.length > 0) {
         for (const pat of patterns) {
-            const cleanPat = pat.replace(/\/\*\*?$/, "").replace(/\/\*$/, "");
+            const cleanPat = pat.replace(/\/\*\*?$/, '').replace(/\/\*$/, '');
             const searchRoot = path.join(cwd, cleanPat);
             if (fs.existsSync(searchRoot)) {
                 const stat = fs.statSync(searchRoot);
@@ -92,7 +92,7 @@ function scanDirectoriesForProjects(cwd, patterns) {
         }
     }
     else {
-        for (const fallback of ["packages", "modules", "apps", "libs", "src"]) {
+        for (const fallback of ['packages', 'modules', 'apps', 'libs', 'src']) {
             const fbPath = path.join(cwd, fallback);
             if (fs.existsSync(fbPath)) {
                 search(fbPath, 1, 3);
@@ -107,43 +107,43 @@ export async function addCommand(moduleNameArg, options = {}) {
     let rootDir = cwd;
     let cur = cwd;
     while (cur !== path.dirname(cur)) {
-        if (fs.existsSync(path.join(cur, "spectra.config.ts")) ||
-            fs.existsSync(path.join(cur, "pnpm-workspace.yaml")) ||
-            fs.existsSync(path.join(cur, "nx.json"))) {
+        if (fs.existsSync(path.join(cur, 'spectra.config.ts')) ||
+            fs.existsSync(path.join(cur, 'pnpm-workspace.yaml')) ||
+            fs.existsSync(path.join(cur, 'nx.json'))) {
             rootDir = cur;
             break;
         }
         cur = path.dirname(cur);
     }
-    p.intro(chalk.bold.cyan("✨ TestSpectra Module Generator"));
+    p.intro(chalk.bold.cyan('✨ TestSpectra Module Generator'));
     // Check if we are in a monorepo
-    const pnpmWorkspacePath = path.join(rootDir, "pnpm-workspace.yaml");
-    const nxJsonPath = path.join(rootDir, "nx.json");
+    const pnpmWorkspacePath = path.join(rootDir, 'pnpm-workspace.yaml');
+    const nxJsonPath = path.join(rootDir, 'nx.json');
     const isMonorepo = fs.existsSync(pnpmWorkspacePath) || fs.existsSync(nxJsonPath);
     // 2. Resolve template directory
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    let templateDir = path.resolve(__dirname, "../templates/nx");
+    let templateDir = path.resolve(__dirname, '../templates/nx');
     if (!fs.existsSync(templateDir)) {
-        templateDir = path.resolve(__dirname, "../../templates/nx");
+        templateDir = path.resolve(__dirname, '../../templates/nx');
     }
     if (!fs.existsSync(templateDir)) {
-        templateDir = path.resolve(__dirname, "../../../templates/nx");
+        templateDir = path.resolve(__dirname, '../../../templates/nx');
     }
-    const sampleE2eSrc = path.join(templateDir, "packages/playground/e2e");
+    const sampleE2eSrc = path.join(templateDir, 'packages/playground/e2e');
     if (!fs.existsSync(sampleE2eSrc)) {
         p.cancel(chalk.red(`Template directory not found at: ${sampleE2eSrc}`));
         return;
     }
     // 3. Resolve CLI dependency version
-    let cliVersion = "^1.0.65";
+    let cliVersion = '^1.0.65';
     try {
         let pDir = __dirname;
         while (pDir !== path.dirname(pDir)) {
-            const cand = path.join(pDir, "package.json");
+            const cand = path.join(pDir, 'package.json');
             if (fs.existsSync(cand)) {
-                const cliPkg = JSON.parse(fs.readFileSync(cand, "utf-8"));
-                if (cliPkg.name === "@testspectra/cli" && cliPkg.version) {
+                const cliPkg = JSON.parse(fs.readFileSync(cand, 'utf-8'));
+                if (cliPkg.name === '@testspectra/cli' && cliPkg.version) {
                     cliVersion = `^${cliPkg.version}`;
                     break;
                 }
@@ -152,10 +152,10 @@ export async function addCommand(moduleNameArg, options = {}) {
         }
     }
     catch { }
-    const cliDepVersion = cliVersion.startsWith("^") ? cliVersion : `^${cliVersion}`;
+    const cliDepVersion = cliVersion.startsWith('^') ? cliVersion : `^${cliVersion}`;
     function copyRecursive(src, dest, replacements = {}) {
         const base = path.basename(src);
-        if (base === "node_modules" || base === "dist" || base === ".testspectra" || base === ".git") {
+        if (base === 'node_modules' || base === 'dist' || base === '.testspectra' || base === '.git') {
             return;
         }
         const stat = fs.statSync(src);
@@ -172,23 +172,23 @@ export async function addCommand(moduleNameArg, options = {}) {
             if (fs.existsSync(dest) && !options.force) {
                 return;
             }
-            let content = fs.readFileSync(src, "utf-8");
+            let content = fs.readFileSync(src, 'utf-8');
             for (const [k, v] of Object.entries(replacements)) {
                 content = content.replaceAll(k, v);
             }
-            if (dest.endsWith("package.json")) {
+            if (dest.endsWith('package.json')) {
                 try {
                     const pkg = JSON.parse(content);
                     if (pkg.devDependencies) {
                         for (const key of Object.keys(pkg.devDependencies)) {
-                            if (key.startsWith("@testspectra/") || pkg.devDependencies[key] === "workspace:*") {
+                            if (key.startsWith('@testspectra/') || pkg.devDependencies[key] === 'workspace:*') {
                                 pkg.devDependencies[key] = cliDepVersion;
                             }
                         }
                     }
                     if (pkg.dependencies) {
                         for (const key of Object.keys(pkg.dependencies)) {
-                            if (key.startsWith("@testspectra/") || pkg.dependencies[key] === "workspace:*") {
+                            if (key.startsWith('@testspectra/') || pkg.dependencies[key] === 'workspace:*') {
                                 pkg.dependencies[key] = cliDepVersion;
                             }
                         }
@@ -197,7 +197,7 @@ export async function addCommand(moduleNameArg, options = {}) {
                 }
                 catch { }
             }
-            fs.writeFileSync(dest, content, "utf-8");
+            fs.writeFileSync(dest, content, 'utf-8');
         }
     }
     // If in a Monorepo
@@ -205,13 +205,13 @@ export async function addCommand(moduleNameArg, options = {}) {
         let pnpmPatterns = [];
         if (fs.existsSync(pnpmWorkspacePath)) {
             try {
-                pnpmPatterns = parsePnpmWorkspaceGlobs(fs.readFileSync(pnpmWorkspacePath, "utf-8"));
+                pnpmPatterns = parsePnpmWorkspaceGlobs(fs.readFileSync(pnpmWorkspacePath, 'utf-8'));
             }
             catch { }
         }
         const detectedProjects = scanDirectoriesForProjects(rootDir, pnpmPatterns);
-        let targetProjectPath = "";
-        let featureName = "";
+        let targetProjectPath = '';
+        let featureName = '';
         if (moduleNameArg) {
             // Find if moduleNameArg matches an existing detected package
             const match = detectedProjects.find((p) => p.name === moduleNameArg || p.relPath === moduleNameArg || path.basename(p.relPath) === moduleNameArg);
@@ -226,35 +226,35 @@ export async function addCommand(moduleNameArg, options = {}) {
         }
         else {
             const mode = await p.select({
-                message: "How would you like to add the TestSpectra module?",
+                message: 'How would you like to add the TestSpectra module?',
                 options: [
                     {
-                        label: "Add E2E to an existing workspace project / feature",
-                        value: "existing",
-                        hint: "Attach E2E test suite to a detected workspace package",
+                        label: 'Add E2E to an existing workspace project / feature',
+                        value: 'existing',
+                        hint: 'Attach E2E test suite to a detected workspace package',
                     },
                     {
-                        label: "Create a new custom feature / module path",
-                        value: "custom",
-                        hint: "Specify a custom path e.g. packages/features/billing",
+                        label: 'Create a new custom feature / module path',
+                        value: 'custom',
+                        hint: 'Specify a custom path e.g. packages/features/billing',
                     },
                 ],
             });
             if (p.isCancel(mode)) {
-                p.cancel("Operation cancelled.");
+                p.cancel('Operation cancelled.');
                 return;
             }
-            if (mode === "existing" && detectedProjects.length > 0) {
+            if (mode === 'existing' && detectedProjects.length > 0) {
                 const choice = await p.select({
-                    message: "Select workspace project to add TestSpectra E2E testing to:",
+                    message: 'Select workspace project to add TestSpectra E2E testing to:',
                     options: detectedProjects.map((proj) => ({
                         value: proj.relPath,
                         label: `${proj.relPath} (${proj.name})`,
-                        hint: proj.hasNxProject ? "Nx project.json" : "package.json",
+                        hint: proj.hasNxProject ? 'Nx project.json' : 'package.json',
                     })),
                 });
                 if (p.isCancel(choice)) {
-                    p.cancel("Operation cancelled.");
+                    p.cancel('Operation cancelled.');
                     return;
                 }
                 targetProjectPath = choice;
@@ -262,22 +262,22 @@ export async function addCommand(moduleNameArg, options = {}) {
             }
             else {
                 const customPath = await p.text({
-                    message: "Enter path for the new feature module (e.g. packages/features/payment):",
-                    placeholder: "packages/features/new-feature",
+                    message: 'Enter path for the new feature module (e.g. packages/features/payment):',
+                    placeholder: 'packages/features/new-feature',
                     validate: (val) => {
                         if (!val || !val.trim())
-                            return "Path cannot be empty";
+                            return 'Path cannot be empty';
                     },
                 });
                 if (p.isCancel(customPath)) {
-                    p.cancel("Operation cancelled.");
+                    p.cancel('Operation cancelled.');
                     return;
                 }
                 targetProjectPath = customPath.trim();
                 featureName = path.basename(targetProjectPath);
             }
         }
-        const e2eFolderName = options.e2eFolder || "e2e";
+        const e2eFolderName = options.e2eFolder || 'e2e';
         const targetE2eDir = path.join(rootDir, targetProjectPath, e2eFolderName);
         const e2eProjectName = `${featureName}-${e2eFolderName}`;
         if (fs.existsSync(targetE2eDir) && !options.force) {
@@ -287,38 +287,39 @@ export async function addCommand(moduleNameArg, options = {}) {
         const s = p.spinner();
         s.start(`Scaffolding ${e2eProjectName} in ./${path.relative(rootDir, targetE2eDir)}...`);
         copyRecursive(sampleE2eSrc, targetE2eDir, {
-            "playground-e2e": e2eProjectName,
-            "packages/playground/e2e": path.relative(rootDir, targetE2eDir).replace(/\\/g, "/"),
-            "scope:playground": `scope:${featureName}`,
+            'playground-e2e': e2eProjectName,
+            'packages/playground/e2e': path.relative(rootDir, targetE2eDir).replace(/\\/g, '/'),
+            'scope:playground': `scope:${featureName}`,
         });
         // Adjust project.json
-        const projJsonPath = path.join(targetE2eDir, "project.json");
+        const projJsonPath = path.join(targetE2eDir, 'project.json');
         if (fs.existsSync(projJsonPath)) {
             try {
-                const pObj = JSON.parse(fs.readFileSync(projJsonPath, "utf-8"));
+                const pObj = JSON.parse(fs.readFileSync(projJsonPath, 'utf-8'));
                 pObj.name = e2eProjectName;
-                pObj.sourceRoot = path.relative(rootDir, targetE2eDir).replace(/\\/g, "/");
-                pObj.targets.e2e.options.cwd = path.relative(rootDir, targetE2eDir).replace(/\\/g, "/");
-                pObj.targets["type-check"].options.cwd = ".";
-                pObj.tags = [`scope:${featureName}`, "type:e2e"];
-                fs.writeFileSync(projJsonPath, JSON.stringify(pObj, null, 2), "utf-8");
+                pObj.sourceRoot = path.relative(rootDir, targetE2eDir).replace(/\\/g, '/');
+                pObj.targets.e2e.options.cwd = path.relative(rootDir, targetE2eDir).replace(/\\/g, '/');
+                pObj.targets['type-check'].options.cwd = '.';
+                pObj.tags = [`scope:${featureName}`, 'type:e2e'];
+                fs.writeFileSync(projJsonPath, JSON.stringify(pObj, null, 2), 'utf-8');
             }
             catch { }
         }
         // Ensure no local spectra.config.ts (centralized in root)
-        const localConfig = path.join(targetE2eDir, "spectra.config.ts");
+        const localConfig = path.join(targetE2eDir, 'spectra.config.ts');
         if (fs.existsSync(localConfig))
             fs.unlinkSync(localConfig);
-        // Ensure Root Solution tsconfig.json references tsconfig.spectra.json
-        const rootTsConfigPath = path.join(rootDir, "tsconfig.json");
+        // Ensure Root Solution tsconfig.json references .testspectra/tsconfig.json
+        const rootTsConfigPath = path.join(rootDir, 'tsconfig.json');
         if (fs.existsSync(rootTsConfigPath)) {
             try {
-                const rootTsConfig = JSON.parse(fs.readFileSync(rootTsConfigPath, "utf-8"));
+                const rootTsConfig = JSON.parse(fs.readFileSync(rootTsConfigPath, 'utf-8'));
                 if (!rootTsConfig.references)
                     rootTsConfig.references = [];
-                if (!rootTsConfig.references.some((r) => r.path === "./tsconfig.spectra.json")) {
-                    rootTsConfig.references.push({ path: "./tsconfig.spectra.json" });
-                    fs.writeFileSync(rootTsConfigPath, JSON.stringify(rootTsConfig, null, 2), "utf-8");
+                rootTsConfig.references = rootTsConfig.references.filter((r) => r.path !== './tsconfig.spectra.json');
+                if (!rootTsConfig.references.some((r) => r.path === './.testspectra/tsconfig.json')) {
+                    rootTsConfig.references.push({ path: './.testspectra/tsconfig.json' });
+                    fs.writeFileSync(rootTsConfigPath, JSON.stringify(rootTsConfig, null, 2), 'utf-8');
                 }
             }
             catch { }
@@ -329,38 +330,38 @@ export async function addCommand(moduleNameArg, options = {}) {
         p.log.success(chalk.green(`Directory: ./${path.relative(rootDir, targetE2eDir)}`));
         p.log.success(chalk.green(`Nx Target: ${e2eProjectName}:e2e`));
         p.log.message(chalk.cyan(`Run tests: pnpm nx run ${e2eProjectName}:e2e`));
-        p.outro(chalk.bold.green("🎉 New TestSpectra module ready!"));
+        p.outro(chalk.bold.green('🎉 New TestSpectra module ready!'));
         return;
     }
     // Standalone mode: adding a new spec suite in specs/<ModuleName>
     let targetModule = moduleNameArg;
     if (!targetModule) {
         const input = await p.text({
-            message: "Enter name of the new test suite/module (e.g. Payment, Profile):",
-            placeholder: "Checkout",
+            message: 'Enter name of the new test suite/module (e.g. Payment, Profile):',
+            placeholder: 'Checkout',
             validate: (val) => {
                 if (!val || !val.trim())
-                    return "Module name cannot be empty";
+                    return 'Module name cannot be empty';
             },
         });
         if (p.isCancel(input)) {
-            p.cancel("Operation cancelled.");
+            p.cancel('Operation cancelled.');
             return;
         }
         targetModule = input.trim();
     }
-    const specDir = path.join(cwd, "specs", targetModule, "TC-01");
-    const poDir = path.join(cwd, "page-objects", `${targetModule}Page`);
+    const specDir = path.join(cwd, 'specs', targetModule, 'TC-01');
+    const poDir = path.join(cwd, 'page-objects', `${targetModule}Page`);
     if (!fs.existsSync(specDir))
         fs.mkdirSync(specDir, { recursive: true });
     if (!fs.existsSync(poDir))
         fs.mkdirSync(poDir, { recursive: true });
     // Create starter page object
     const poContent = `class ${targetModule}Page {\n  get mainTitle() {\n    return $("h1");\n  }\n\n  async open() {\n    await Spectra.navigate("/${targetModule.toLowerCase()}");\n  }\n}\n\nexport default new ${targetModule}Page();\n`;
-    fs.writeFileSync(path.join(poDir, "common.ts"), poContent, "utf-8");
+    fs.writeFileSync(path.join(poDir, 'common.ts'), poContent, 'utf-8');
     // Create starter test spec (Zero-import, flat it() block)
     const specContent = `it("should verify ${targetModule} page components", async () => {\n  await ${targetModule}Page.open();\n  await ${targetModule}Page.mainTitle.shouldBeVisible();\n});\n`;
-    fs.writeFileSync(path.join(specDir, "web.test.ts"), specContent, "utf-8");
+    fs.writeFileSync(path.join(specDir, 'web.test.ts'), specContent, 'utf-8');
     TypeGenerator.writeDeclarationFiles(cwd);
     p.log.success(chalk.green(`Created Page Object: ./page-objects/${targetModule}Page/common.ts`));
     p.log.success(chalk.green(`Created Test Spec: ./specs/${targetModule}/TC-01/web.test.ts`));

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

@@ -0,0 +1,11 @@
+export interface CloudRunOptions {
+    project: string;
+    projectName?: string;
+    branch?: string;
+    commit?: string;
+    platform?: string;
+    wait?: boolean;
+    timeout?: 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,118 @@
+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,
+            }),
+        });
+        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/demo.js

@@ -1,21 +1,21 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { DemoServer } from "../utils/demo-server.js";
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { DemoServer } from '../utils/demo-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"));
+    p.intro(chalk.bold.cyan('🌐 TestSpectra Demo Web App'));
     const server = new DemoServer(port);
     try {
         const { url } = await server.start();
         p.log.success(chalk.green(`Demo web app is live at: ${chalk.bold.underline(url)}`));
         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 server.'));
         // Handle termination gracefully
-        process.on("SIGINT", async () => {
+        process.on('SIGINT', async () => {
             await server.stop();
             process.exit(0);
         });
-        process.on("SIGTERM", async () => {
+        process.on('SIGTERM', async () => {
             await server.stop();
             process.exit(0);
         });

package/dist/commands/devices.d.ts

@@ -1,3 +1,15 @@
-export declare function devicesCommand(options: {
-    target?: "android" | "ios" | "web" | "all";
+export interface AdbDevice {
+    udid: string;
+    id: string;
+    model: string;
+    name: string;
+    status: string;
+    connectionType: 'usb' | 'wifi' | string;
+    version?: string | null;
+    androidId?: string | null;
+}
+export declare function getConnectedDevices(cwd?: string): Promise<AdbDevice[]>;
+export declare function devicesCommand(options?: {
+    target?: 'android' | 'ios' | 'web' | 'all';
+    json?: boolean;
 }): Promise<void>;