@testspectra/cli 1.0.70 → 1.1.0-rc.1

package/dist/commands/update.js

@@ -1,19 +1,19 @@
-import { execSync, execFileSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { execSync, execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const PACKAGES = ["@testspectra/cli", "@testspectra/matchers"];
+const PACKAGES = ['@testspectra/cli', '@testspectra/matchers'];
 function getLatestVersion(pkg) {
     try {
-        const out = execFileSync("npm", ["view", pkg, "version", "--json"], {
-            stdio: ["ignore", "pipe", "ignore"],
+        const out = execFileSync('npm', ['view', pkg, 'version', '--json'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 10000,
         })
             .toString()
             .trim()
-            .replace(/"/g, "");
+            .replace(/"/g, '');
         return out || null;
     }
     catch {
@@ -24,10 +24,10 @@ function getCurrentVersion(pkg, cwd) {
     // Walk up to find the installed version
     let cur = path.resolve(cwd);
     while (cur && cur !== path.dirname(cur)) {
-        const pkgJson = path.join(cur, "node_modules", pkg, "package.json");
+        const pkgJson = path.join(cur, 'node_modules', pkg, 'package.json');
         if (fs.existsSync(pkgJson)) {
             try {
-                const p = JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
+                const p = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
                 return p.version ?? null;
             }
             catch { }
@@ -37,20 +37,20 @@ function getCurrentVersion(pkg, cwd) {
     return null;
 }
 function detectPackageManager(cwd) {
-    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml")))
-        return "pnpm";
-    if (fs.existsSync(path.join(cwd, "bun.lockb")) || fs.existsSync(path.join(cwd, "bun.lock")))
-        return "bun";
-    return "npm";
+    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock')))
+        return 'bun';
+    return 'npm';
 }
 function buildInstallCmd(pm, pkgSpecs) {
-    const list = pkgSpecs.join(" ");
+    const list = pkgSpecs.join(' ');
     switch (pm) {
-        case "pnpm":
+        case 'pnpm':
             return `pnpm add -D ${list}`;
-        case "bun":
+        case 'bun':
             return `bun add -d ${list}`;
-        case "npm":
+        case 'npm':
         default:
             return `npm install -D ${list}`;
     }
@@ -58,55 +58,51 @@ function buildInstallCmd(pm, pkgSpecs) {
 export async function updateCommand(options = {}) {
     const cwd = process.cwd();
     const pm = detectPackageManager(cwd);
-    console.log("\x1b[36m┌  🔄 TestSpectra Self-Update\x1b[0m");
-    console.log("\x1b[36m│\x1b[0m");
+    console.log('\x1b[36m┌  🔄 TestSpectra Self-Update\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m');
     console.log(`\x1b[36m│\x1b[0m  Package Manager: \x1b[33m${pm}\x1b[0m`);
-    console.log("\x1b[36m│\x1b[0m");
-    console.log("\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...");
+    console.log('\x1b[36m│\x1b[0m');
+    console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
     const updates = [];
     for (const pkg of PACKAGES) {
         const current = getCurrentVersion(pkg, cwd);
         const latest = getLatestVersion(pkg);
         const needsUpdate = !!latest && latest !== current;
         updates.push({ pkg, current, latest, needsUpdate });
-        const currentStr = current ? `\x1b[33mv${current}\x1b[0m` : "\x1b[90m(not installed)\x1b[0m";
-        const latestStr = latest ? `\x1b[32mv${latest}\x1b[0m` : "\x1b[31m(unavailable)\x1b[0m";
-        const arrow = needsUpdate ? ` → ${latestStr}` : "";
-        const status = !latest
-            ? "\x1b[31m✗\x1b[0m"
-            : needsUpdate
-                ? "\x1b[33m↑\x1b[0m"
-                : "\x1b[32m✓\x1b[0m";
+        const currentStr = current ? `\x1b[33mv${current}\x1b[0m` : '\x1b[90m(not installed)\x1b[0m';
+        const latestStr = latest ? `\x1b[32mv${latest}\x1b[0m` : '\x1b[31m(unavailable)\x1b[0m';
+        const arrow = needsUpdate ? ` → ${latestStr}` : '';
+        const status = !latest ? '\x1b[31m✗\x1b[0m' : needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
         console.log(`\x1b[36m│\x1b[0m   ${status} ${pkg.padEnd(28)} ${currentStr}${arrow}`);
     }
     const toUpdate = updates.filter((u) => u.needsUpdate && u.latest);
-    console.log("\x1b[36m│\x1b[0m");
+    console.log('\x1b[36m│\x1b[0m');
     if (toUpdate.length === 0) {
-        console.log("\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m");
-        console.log("\x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m\n");
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m\n');
         return;
     }
     if (options.check) {
         console.log(`\x1b[36m│\x1b[0m  \x1b[33m${toUpdate.length} update(s) available. Run \x1b[36mspectra update\x1b[33m to install.\x1b[0m`);
-        console.log("\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n");
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
         return;
     }
     const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
     const installCmd = buildInstallCmd(pm, pkgSpecs);
     console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
-    console.log("\x1b[36m│\x1b[0m");
+    console.log('\x1b[36m│\x1b[0m');
     try {
-        execSync(installCmd, { cwd, stdio: "inherit" });
-        console.log("\x1b[36m│\x1b[0m");
-        console.log("\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m");
-        console.log("\x1b[32m🎉 TestSpectra updated successfully!\x1b[0m");
+        execSync(installCmd, { cwd, stdio: 'inherit' });
+        console.log('\x1b[36m│\x1b[0m');
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
+        console.log('\x1b[32m🎉 TestSpectra updated successfully!\x1b[0m');
         for (const u of toUpdate) {
-            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? "?"} → v${u.latest}`);
+            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? '?'} → v${u.latest}`);
         }
-        console.log("");
+        console.log('');
     }
     catch (err) {
-        console.log("\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m");
+        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
         console.error(`\x1b[31m✗ Update failed: ${err.message}\x1b[0m\n`);
         process.exit(1);
     }

package/dist/commands/watch.d.ts

@@ -1,4 +1,10 @@
+import fs from 'fs';
 export interface WatchCommandOptions {
     cwd?: string;
+    debounceMs?: number;
 }
+export declare function startWatcher(cwd: string, debounceMs?: number): {
+    watcher: fs.FSWatcher;
+    close: () => void;
+};
 export declare function watchCommand(options?: WatchCommandOptions): Promise<void>;

package/dist/commands/watch.js

@@ -1,63 +1,73 @@
-import fs from "fs";
-import path from "path";
-import chalk from "chalk";
-import { TypeGenerator } from "../types/generator.js";
-export async function watchCommand(options = {}) {
-    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
-    console.log(chalk.bold.cyan("\n🔭 TestSpectra Ambient Types Watcher"));
-    console.log(chalk.gray(`Watching workspace: ${cwd}\n`));
-    // Initial generation
-    try {
-        TypeGenerator.writeDeclarationFiles(cwd);
-        console.log(chalk.green("✔ Initialized ambient declarations in .testspectra/types/"));
-    }
-    catch (err) {
-        console.error(chalk.red(`✖ Failed initial type generation: ${err?.message}`));
-    }
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { TypeGenerator } from '../types/generator.js';
+export function startWatcher(cwd, debounceMs = 60) {
+    // Initial generation. TypeGenerator.generateAll itself stays synchronous (reading
+    // spectra.config.ts is unavoidably async, so that part is handled by the separate
+    // syncEnvDeclaration call below); startWatcher stays sync so it can return the watcher handle
+    // immediately, with the async env sync fired-and-forgotten.
+    TypeGenerator.generateAll(cwd);
+    TypeGenerator.syncEnvDeclaration(cwd).catch((err) => {
+        console.error(chalk.red(`✖ Error generating initial env.d.ts: ${err?.message}`));
+    });
     let debounceTimer = null;
     const triggerRegen = (filePath, eventType) => {
         if (debounceTimer)
             clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
+        debounceTimer = setTimeout(async () => {
             try {
-                TypeGenerator.writeDeclarationFiles(cwd);
+                TypeGenerator.generateAll(cwd);
+                await TypeGenerator.syncEnvDeclaration(cwd);
                 const time = new Date().toLocaleTimeString();
                 const rel = path.relative(cwd, filePath) || filePath;
-                console.log(chalk.gray(`[${time}] `) +
-                    chalk.cyan(`✨ Updated ambient types `) +
-                    chalk.gray(`(${eventType}: ${rel})`));
+                console.log(chalk.gray(`[${time}] `) + chalk.cyan(`✨ Updated ambient types `) + chalk.gray(`(${eventType}: ${rel})`));
             }
             catch (err) {
                 console.error(chalk.red(`✖ Error regenerating declarations: ${err?.message}`));
             }
-        }, 100);
+        }, debounceMs);
+    };
+    const watcher = fs.watch(cwd, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+            return;
+        const fn = filename.toString();
+        if (fn.includes('.testspectra') ||
+            fn.includes('node_modules') ||
+            fn.includes('.git') ||
+            fn.includes('dist') ||
+            fn.includes('.nx')) {
+            return;
+        }
+        if (fn.includes('fixtures') ||
+            fn.includes('page-objects') ||
+            fn.includes('actions') ||
+            fn.includes('steps') ||
+            fn.includes('hooks') ||
+            fn.includes('spectra.config')) {
+            triggerRegen(path.join(cwd, fn), eventType);
+        }
+    });
+    return {
+        watcher,
+        close: () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            watcher.close();
+        },
     };
+}
+export async function watchCommand(options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    console.log(chalk.bold.cyan('\n🔭 TestSpectra Ambient Types Watcher'));
+    console.log(chalk.gray(`Watching workspace: ${cwd}\n`));
     try {
-        const watcher = fs.watch(cwd, { recursive: true }, (eventType, filename) => {
-            if (!filename)
-                return;
-            const fn = filename.toString();
-            if (fn.includes(".testspectra") ||
-                fn.includes("node_modules") ||
-                fn.includes(".git") ||
-                fn.includes("dist") ||
-                fn.includes(".nx")) {
-                return;
-            }
-            if (fn.includes("fixtures") ||
-                fn.includes("page-objects") ||
-                fn.includes("pageobjects") ||
-                fn.includes("actions") ||
-                fn.includes("steps") ||
-                fn.includes("hooks") ||
-                fn.includes("spectra.config")) {
-                triggerRegen(path.join(cwd, fn), eventType);
-            }
-        });
-        watcher.on("error", (err) => {
+        const handle = startWatcher(cwd, options.debounceMs ?? 60);
+        console.log(chalk.green('✔ Initialized ambient declarations in .testspectra/types/'));
+        console.log(chalk.gray('Press Ctrl+C to stop watching.\n'));
+        handle.watcher.on('error', (err) => {
             console.error(chalk.red(`Watcher error: ${err?.message}`));
         });
-        console.log(chalk.gray("Press Ctrl+C to stop watching.\n"));
     }
     catch (err) {
         console.error(chalk.red(`Failed to start workspace watcher: ${err?.message}`));

package/dist/config/loader.d.ts

@@ -1,4 +1,4 @@
-import { ConfigData } from "./schema.js";
+import { ConfigData } from './schema.js';
 export declare class ConfigLoader {
     static readonly CONFIG_FILE_NAMES: string[];
     static findConfigFile(cwd?: string): string | null;

package/dist/config/loader.js

@@ -1,14 +1,14 @@
-import fs from "fs";
-import path from "path";
-import { DEFAULT_CONFIG_DATA } from "./schema.js";
+import fs from 'fs';
+import path from 'path';
+import { DEFAULT_CONFIG_DATA } from './schema.js';
 export class ConfigLoader {
     static CONFIG_FILE_NAMES = [
-        "testspectra.config.ts",
-        "spectra.config.ts",
-        "testspectra.config.js",
-        "spectra.config.js",
-        "testspectra.config.json",
-        ".testspectrarc.json",
+        'testspectra.config.ts',
+        'spectra.config.ts',
+        'testspectra.config.js',
+        'spectra.config.js',
+        'testspectra.config.json',
+        '.testspectrarc.json',
     ];
     static findConfigFile(cwd = process.cwd()) {
         let cur = path.resolve(cwd);
@@ -30,16 +30,16 @@ export class ConfigLoader {
         const configPath = this.findConfigFile(cwd);
         let loaded = {};
         if (configPath) {
-            if (configPath.endsWith(".json")) {
+            if (configPath.endsWith('.json')) {
                 try {
-                    const raw = fs.readFileSync(configPath, "utf-8");
+                    const raw = fs.readFileSync(configPath, 'utf-8');
                     loaded = JSON.parse(raw);
                 }
                 catch (e) {
                     console.warn(`[TestSpectra] Warning: Failed to parse ${configPath}:`, e);
                 }
             }
-            else if (configPath.endsWith(".ts") || configPath.endsWith(".js")) {
+            else if (configPath.endsWith('.ts') || configPath.endsWith('.js')) {
                 try {
                     const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
                     const mod = await import(fileUrl);
@@ -56,31 +56,46 @@ export class ConfigLoader {
             ...overrides,
             webConfig: {
                 ...DEFAULT_CONFIG_DATA.webConfig,
-                ...(loaded.webConfig || {}),
-                ...(overrides?.webConfig || {}),
+                ...loaded.webConfig,
+                ...overrides?.webConfig,
             },
             androidConfig: {
                 ...DEFAULT_CONFIG_DATA.androidConfig,
-                ...(loaded.androidConfig || {}),
-                ...(overrides?.androidConfig || {}),
+                ...loaded.androidConfig,
+                ...overrides?.androidConfig,
             },
             iosConfig: {
                 ...DEFAULT_CONFIG_DATA.iosConfig,
-                ...(loaded.iosConfig || {}),
-                ...(overrides?.iosConfig || {}),
+                ...loaded.iosConfig,
+                ...overrides?.iosConfig,
             },
             executionConfig: {
-                networkMonitoringEnabled: overrides?.executionConfig?.networkMonitoringEnabled ?? loaded.executionConfig?.networkMonitoringEnabled ?? DEFAULT_CONFIG_DATA.executionConfig?.networkMonitoringEnabled ?? true,
-                fastResponseTime: overrides?.executionConfig?.fastResponseTime ?? loaded.executionConfig?.fastResponseTime ?? DEFAULT_CONFIG_DATA.executionConfig?.fastResponseTime ?? "200",
-                normalResponseTime: overrides?.executionConfig?.normalResponseTime ?? loaded.executionConfig?.normalResponseTime ?? DEFAULT_CONFIG_DATA.executionConfig?.normalResponseTime ?? "1000",
-                monitoredDomains: overrides?.executionConfig?.monitoredDomains ?? loaded.executionConfig?.monitoredDomains ?? DEFAULT_CONFIG_DATA.executionConfig?.monitoredDomains ?? [],
-                environmentVariables: overrides?.executionConfig?.environmentVariables ?? loaded.executionConfig?.environmentVariables ?? DEFAULT_CONFIG_DATA.executionConfig?.environmentVariables ?? [],
+                networkMonitoringEnabled: overrides?.executionConfig?.networkMonitoringEnabled ??
+                    loaded.executionConfig?.networkMonitoringEnabled ??
+                    DEFAULT_CONFIG_DATA.executionConfig?.networkMonitoringEnabled ??
+                    true,
+                fastResponseTime: overrides?.executionConfig?.fastResponseTime ??
+                    loaded.executionConfig?.fastResponseTime ??
+                    DEFAULT_CONFIG_DATA.executionConfig?.fastResponseTime ??
+                    '200',
+                normalResponseTime: overrides?.executionConfig?.normalResponseTime ??
+                    loaded.executionConfig?.normalResponseTime ??
+                    DEFAULT_CONFIG_DATA.executionConfig?.normalResponseTime ??
+                    '1000',
+                monitoredDomains: overrides?.executionConfig?.monitoredDomains ??
+                    loaded.executionConfig?.monitoredDomains ??
+                    DEFAULT_CONFIG_DATA.executionConfig?.monitoredDomains ??
+                    [],
+                environmentVariables: overrides?.executionConfig?.environmentVariables ??
+                    loaded.executionConfig?.environmentVariables ??
+                    DEFAULT_CONFIG_DATA.executionConfig?.environmentVariables ??
+                    {},
             },
         };
     }
-    static saveConfig(cwd, config, filename = "testspectra.config.json") {
+    static saveConfig(cwd, config, filename = 'testspectra.config.json') {
         const target = path.join(cwd, filename);
-        fs.writeFileSync(target, JSON.stringify(config, null, 2), "utf-8");
+        fs.writeFileSync(target, JSON.stringify(config, null, 2), 'utf-8');
         return target;
     }
 }