@testspectra/cli 1.0.70 → 1.1.1

package/dist/commands/devices.js

@@ -1,37 +1,47 @@
-import { execSync } from "child_process";
-export async function devicesCommand(options) {
-    const target = options.target || "all";
-    console.log(`\x1b[36m[TestSpectra Devices]\x1b[0m Listing connected test targets (scope: ${target})...\n`);
-    if (target === "all" || target === "android") {
-        console.log("\x1b[1mAndroid Devices (ADB):\x1b[0m");
-        try {
-            const adbOutput = execSync("adb devices -l", { stdio: "pipe" }).toString();
-            const lines = adbOutput.split("\n").slice(1);
-            let found = false;
-            for (const line of lines) {
-                if (line.trim()) {
-                    found = true;
-                    console.log(`  \x1b[32m•\x1b[0m ${line.trim()}`);
-                }
+import { execFileSync, spawn } from 'child_process';
+import path from 'path';
+import { RustCoreBridge } from '../runner/bridge.js';
+function getRunnerEnv() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalDriversDir = path.join(home, '.testspectra', 'drivers');
+    return {
+        ...process.env,
+        TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
+    };
+}
+export async function getConnectedDevices(cwd = process.cwd()) {
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const stdout = execFileSync(binPath, ['devices', '--json'], {
+        cwd,
+        env: getRunnerEnv(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return JSON.parse(stdout.trim());
+}
+export async function devicesCommand(options = {}) {
+    const cwd = process.cwd();
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    if (options.json) {
+        const devices = await getConnectedDevices(cwd);
+        console.log(JSON.stringify(devices, null, 2));
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, ['devices'], {
+            cwd,
+            env: getRunnerEnv(),
+            stdio: 'inherit',
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
             }
-            if (!found) {
-                console.log("  \x1b[90mNo Android devices/emulators connected via ADB.\x1b[0m");
+            else {
+                process.exitCode = code ?? 1;
+                resolve();
             }
-        }
-        catch {
-            console.log("  \x1b[31mADB command failed or platform-tools not in PATH.\x1b[0m");
-        }
-    }
-    if (target === "all" || target === "web") {
-        console.log("\n\x1b[1mWeb Browsers:\x1b[0m");
-        try {
-            const chromeVer = execSync(process.platform === "darwin"
-                ? '"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --version'
-                : "google-chrome --version", { stdio: "pipe" }).toString().trim();
-            console.log(`  \x1b[32m•\x1b[0m Chrome: ${chromeVer}`);
-        }
-        catch {
-            console.log("  \x1b[90m• Chrome: Not installed\x1b[0m");
-        }
-    }
+        });
+        child.on('error', reject);
+    });
 }

package/dist/commands/doctor.d.ts

@@ -1,11 +1,12 @@
 export interface DependencyStatus {
     name: string;
-    category: "core" | "web" | "mobile";
+    category: 'core' | 'web' | 'mobile' | string;
     installed: boolean;
     version: string | null;
     required: boolean;
     required_version: string | null;
     depends_on: string[];
+    location?: string | null;
 }
 export interface SystemCheckResult {
     all_ready: boolean;
@@ -16,4 +17,5 @@ export declare function runSystemChecks(cwd?: string): Promise<SystemCheckResult
 export declare function doctorCommand(options?: {
     fix?: boolean;
     json?: boolean;
+    verbose?: boolean;
 }): Promise<void>;

package/dist/commands/doctor.js

@@ -1,278 +1,57 @@
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
-function runCommandSafe(cmd) {
-    try {
-        const out = execSync(cmd, { stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).toString().trim();
-        if (out)
-            return out;
-    }
-    catch (e) {
-        const combined = `${e.stdout?.toString() || ""} ${e.stderr?.toString() || ""}`.trim();
-        if (combined) {
-            const lower = combined.toLowerCase();
-            if (!lower.includes("not found") &&
-                !lower.includes("no such file") &&
-                !lower.includes("cannot find") &&
-                !lower.includes("no java runtime present") &&
-                !lower.includes("command not found")) {
-                return combined;
-            }
-        }
-    }
-    return null;
-}
-function checkChrome() {
-    const home = process.env.HOME || process.env.USERPROFILE || "";
-    const driversDir = path.join(home, ".testspectra", "drivers");
-    if (!fs.existsSync(driversDir)) {
-        return { installed: false, version: null };
-    }
-    try {
-        const entries = fs.readdirSync(driversDir, { recursive: true });
-        for (const entry of entries) {
-            const entryStr = String(entry);
-            if (entryStr.endsWith("Google Chrome for Testing") ||
-                entryStr.endsWith("chrome") ||
-                entryStr.endsWith("chrome.exe")) {
-                const fullPath = path.join(driversDir, entryStr);
-                if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
-                    const out = runCommandSafe(`"${fullPath}" --version`);
-                    if (out) {
-                        return { installed: true, version: `${out.split("\n")[0].trim()} (Chrome for Testing)` };
-                    }
-                    // Binary exists but couldn't get version — still count as installed
-                    return { installed: true, version: "Chrome for Testing (cached)" };
-                }
-            }
-        }
-    }
-    catch { }
-    return { installed: false, version: null };
-}
-function checkWorkspacePackage(pkgName, startDir) {
-    let cur = path.resolve(startDir);
-    while (cur && cur !== path.dirname(cur)) {
-        const pkgJsonPath = path.join(cur, "node_modules", pkgName, "package.json");
-        if (fs.existsSync(pkgJsonPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
-                return { installed: true, version: `v${pkg.version || "installed"}` };
-            }
-            catch { }
-        }
-        // Also check root package.json devDependencies/dependencies
-        const rootPkgPath = path.join(cur, "package.json");
-        if (fs.existsSync(rootPkgPath)) {
-            try {
-                const rPkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
-                if (rPkg.name === pkgName) {
-                    return { installed: true, version: `v${rPkg.version || "workspace"}` };
-                }
-                const depVer = rPkg.devDependencies?.[pkgName] || rPkg.dependencies?.[pkgName];
-                if (depVer) {
-                    return { installed: true, version: depVer };
-                }
-            }
-            catch { }
-        }
-        // Check subpackages if monorepo
-        const cand1 = path.join(cur, "tools", pkgName.replace("@testspectra/", ""), "package.json");
-        const cand2 = path.join(cur, "packages", pkgName.replace("@testspectra/", ""), "package.json");
-        const cand3 = path.join(cur, pkgName.replace("@testspectra/", ""), "package.json");
-        for (const cand of [cand1, cand2, cand3]) {
-            if (fs.existsSync(cand)) {
-                try {
-                    const pkg = JSON.parse(fs.readFileSync(cand, "utf-8"));
-                    if (pkg.name === pkgName) {
-                        return { installed: true, version: `v${pkg.version || "workspace"}` };
-                    }
-                }
-                catch { }
-            }
-        }
-        cur = path.dirname(cur);
-    }
-    return { installed: false, version: null };
+import { execFileSync, spawn } from 'child_process';
+import path from 'path';
+import { RustCoreBridge } from '../runner/bridge.js';
+function getRunnerEnv() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const globalDriversDir = path.join(home, '.testspectra', 'drivers');
+    return {
+        ...process.env,
+        TEST_SPECTRA_DRIVER_CACHE: globalDriversDir,
+    };
 }
 export async function runSystemChecks(cwd = process.cwd()) {
-    const dependencies = [];
-    // --- 1. Essential Core ---
-    // Node.js
-    const nodeOut = runCommandSafe("node -v");
-    dependencies.push({
-        name: "Node.js",
-        category: "core",
-        installed: !!nodeOut,
-        version: nodeOut ? nodeOut.split("\n")[0].trim() : null,
-        required: true,
-        required_version: ">=18.0.0",
-        depends_on: [],
-    });
-    // Bun
-    const bunOut = runCommandSafe("bun -v");
-    dependencies.push({
-        name: "Bun",
-        category: "core",
-        installed: !!bunOut,
-        version: bunOut ? `v${bunOut.split("\n")[0].trim()}` : null,
-        required: false,
-        required_version: null,
-        depends_on: [],
-    });
-    // Git
-    const gitOut = runCommandSafe("git --version");
-    dependencies.push({
-        name: "Git",
-        category: "core",
-        installed: !!gitOut,
-        version: gitOut ? gitOut.replace("git version", "").trim() : null,
-        required: false,
-        required_version: null,
-        depends_on: [],
-    });
-    // --- 2. Web Automation & Browsers ---
-    // Google Chrome / Chromium
-    const chromeCheck = checkChrome();
-    dependencies.push({
-        name: "Google Chrome",
-        category: "web",
-        installed: chromeCheck.installed,
-        version: chromeCheck.version,
-        required: true,
-        required_version: "Stable / CfT",
-        depends_on: [],
-    });
-    // WebDriverIO Core packages
-    const webPackages = [
-        { name: "WDIO CLI", pkg: "@wdio/cli", required: true },
-        { name: "WebDriverIO Core", pkg: "webdriverio", required: true },
-        { name: "WDIO Local Runner", pkg: "@wdio/local-runner", required: true },
-        { name: "WDIO Globals", pkg: "@wdio/globals", required: true },
-        { name: "WDIO Spec Reporter", pkg: "@wdio/spec-reporter", required: true },
-        { name: "WDIO Mocha Framework", pkg: "@wdio/mocha-framework", required: true },
-        { name: "WDIO DevTools Service", pkg: "@wdio/devtools-service", required: false },
-        { name: "TestSpectra CLI", pkg: "@testspectra/cli", required: true },
-        { name: "TestSpectra Matchers", pkg: "@testspectra/matchers", required: true },
-    ];
-    for (const wp of webPackages) {
-        const pkgCheck = checkWorkspacePackage(wp.pkg, cwd);
-        dependencies.push({
-            name: wp.name,
-            category: "web",
-            installed: pkgCheck.installed,
-            version: pkgCheck.version,
-            required: wp.required,
-            required_version: null,
-            depends_on: ["Node.js"],
-        });
-    }
-    // --- 3. Mobile Testing (Android) ---
-    const adbOut = runCommandSafe("adb version");
-    let adbVer = null;
-    if (adbOut) {
-        const m = adbOut.match(/Version\s+([\d.]+)/i) || adbOut.match(/Android Debug Bridge version\s+([\d.]+)/i);
-        adbVer = m ? `v${m[1]}` : "Installed";
-    }
-    dependencies.push({
-        name: "ADB (Android Debug Bridge)",
-        category: "mobile",
-        installed: !!adbOut,
-        version: adbVer,
-        required: false,
-        required_version: null,
-        depends_on: [],
-    });
-    const javaOut = runCommandSafe("java -version 2>&1");
-    let javaVer = null;
-    if (javaOut && !javaOut.toLowerCase().includes("no java runtime present") && !javaOut.toLowerCase().includes("not found")) {
-        const m = javaOut.match(/(?:java|openjdk)\s+version\s+"([^"]+)"/i) || javaOut.match(/(?:java|openjdk)\s+([\d.]+)/i);
-        javaVer = m ? `v${m[1]}` : "Installed";
-    }
-    dependencies.push({
-        name: "Java JDK",
-        category: "mobile",
-        installed: !!javaVer,
-        version: javaVer,
-        required: false,
-        required_version: ">=21.0.0",
-        depends_on: [],
-    });
-    const appiumOut = runCommandSafe("appium -v");
-    dependencies.push({
-        name: "Appium",
-        category: "mobile",
-        installed: !!appiumOut,
-        version: appiumOut ? `v${appiumOut.split("\n")[0].trim()}` : null,
-        required: false,
-        required_version: ">=2.0.0",
-        depends_on: ["Node.js"],
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const stdout = execFileSync(binPath, ['doctor', '--json'], {
+        cwd,
+        env: getRunnerEnv(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
     });
-    const missingRequired = dependencies.filter((d) => d.required && !d.installed);
-    const missingCount = missingRequired.length;
-    return {
-        all_ready: missingCount === 0,
-        missing_count: missingCount,
-        dependencies,
-    };
+    return JSON.parse(stdout.trim());
 }
 export async function doctorCommand(options = {}) {
     const cwd = process.cwd();
-    const result = await runSystemChecks(cwd);
+    const binPath = RustCoreBridge.resolveBinaryPath();
+    const args = ['doctor'];
     if (options.json) {
+        args.push('--json');
+    }
+    if (options.verbose) {
+        args.push('--verbose');
+    }
+    if (options.fix) {
+        args.push('--fix');
+    }
+    if (options.json) {
+        const result = await runSystemChecks(cwd);
         console.log(JSON.stringify(result, null, 2));
         return;
     }
-    console.log("\x1b[36m┌  🩺 TestSpectra Doctor: System & Dependency Diagnostics\x1b[0m");
-    console.log("\x1b[36m│\x1b[0m");
-    const categories = [
-        { key: "core", title: "Essential Core Runtimes" },
-        { key: "web", title: "Web Automation (WebDriverIO & Browsers)" },
-        { key: "mobile", title: "Mobile Testing (Android & Appium)" },
-    ];
-    for (const cat of categories) {
-        const items = result.dependencies.filter((d) => d.category === cat.key);
-        if (items.length === 0)
-            continue;
-        console.log(`\x1b[36m│\x1b[0m  \x1b[1m\x1b[34m${cat.title}\x1b[0m`);
-        for (const item of items) {
-            if (item.installed) {
-                const verStr = item.version ? `\x1b[90m(${item.version})\x1b[0m` : "";
-                console.log(`\x1b[36m│\x1b[0m   \x1b[32m✓\x1b[0m ${item.name.padEnd(28)} ${verStr}`);
-            }
-            else if (item.required) {
-                console.log(`\x1b[36m│\x1b[0m   \x1b[31m✗\x1b[0m ${item.name.padEnd(28)} \x1b[31m[Missing - Required]\x1b[0m`);
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            cwd,
+            env: getRunnerEnv(),
+            stdio: 'inherit',
+        });
+        child.on('close', (code) => {
+            if (code === 0 || options.fix) {
+                resolve();
             }
             else {
-                console.log(`\x1b[36m│\x1b[0m   \x1b[33m!\x1b[0m ${item.name.padEnd(28)} \x1b[90m(Not found - Optional)\x1b[0m`);
+                process.exitCode = code ?? 1;
+                resolve();
             }
-        }
-        console.log("\x1b[36m│\x1b[0m");
-    }
-    console.log("\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m");
-    if (result.all_ready) {
-        console.log("\x1b[32m🎉 [TestSpectra] System is 100% ready for Web & Local Test Execution!\x1b[0m\n");
-    }
-    else {
-        console.log(`\x1b[33m⚠️  [TestSpectra] Found ${result.missing_count} missing required dependencies.\x1b[0m`);
-        console.log("   Run \x1b[36mspectra doctor --fix\x1b[0m or install missing tools above.\n");
-        if (options.fix) {
-            console.log("\x1b[36m[Doctor Fix] Attempting automated resolution...\x1b[0m");
-            const missingPkgs = result.dependencies
-                .filter((d) => !d.installed && d.category === "web" && d.name.startsWith("WDIO"))
-                .map((d) => d.name);
-            if (missingPkgs.length > 0) {
-                console.log(`Installing workspace packages: ${missingPkgs.join(", ")}`);
-                try {
-                    execSync("pnpm add -D @wdio/cli webdriverio @wdio/local-runner @wdio/globals @wdio/spec-reporter @wdio/mocha-framework @wdio/devtools-service", {
-                        stdio: "inherit",
-                    });
-                    console.log("\x1b[32m✓ Installed WebDriverIO packages successfully.\x1b[0m");
-                }
-                catch (err) {
-                    console.error("\x1b[31m✗ Failed to install packages:\x1b[0m", err.message);
-                }
-            }
-        }
-    }
+        });
+        child.on('error', reject);
+    });
 }

package/dist/commands/init.d.ts

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