@testspectra/cli 1.0.65 → 1.0.67

package/dist/commands/doctor.d.ts

@@ -1,3 +1,19 @@
-export declare function doctorCommand(options: {
+export interface DependencyStatus {
+    name: string;
+    category: "core" | "web" | "mobile";
+    installed: boolean;
+    version: string | null;
+    required: boolean;
+    required_version: string | null;
+    depends_on: string[];
+}
+export interface SystemCheckResult {
+    all_ready: boolean;
+    missing_count: number;
+    dependencies: DependencyStatus[];
+}
+export declare function runSystemChecks(cwd?: string): Promise<SystemCheckResult>;
+export declare function doctorCommand(options?: {
     fix?: boolean;
+    json?: boolean;
 }): Promise<void>;

package/dist/commands/doctor.js

@@ -1,54 +1,278 @@
+import fs from "fs";
+import path from "path";
 import { execSync } from "child_process";
-export async function doctorCommand(options) {
-    console.log("\x1b[36m[TestSpectra Doctor]\x1b[0m Checking development and runtime dependencies...\n");
-    const checks = [
-        {
-            name: "Node.js",
-            command: "node -v",
-            required: true,
-        },
-        {
-            name: "Bun",
-            command: "bun -v",
-            required: false,
-        },
-        {
-            name: "ADB (Android Debug Bridge)",
-            command: "adb version",
-            required: false,
-        },
-        {
-            name: "Java JDK",
-            command: "java -version",
-            required: false,
-        },
-        {
-            name: "Google Chrome",
-            command: process.platform === "darwin"
-                ? '"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --version'
-                : "google-chrome --version",
-            required: false,
-        },
-    ];
-    let missingCount = 0;
-    for (const check of checks) {
-        try {
-            const out = execSync(check.command, { stdio: "pipe" }).toString().trim();
-            const firstLine = out.split("\n")[0];
-            console.log(` \x1b[32m✓\x1b[0m ${check.name.padEnd(30)} \x1b[90m(${firstLine})\x1b[0m`);
+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;
+            }
         }
-        catch {
-            console.log(` \x1b[31m✗\x1b[0m ${check.name.padEnd(30)} \x1b[31m(Not found)\x1b[0m`);
-            if (check.required) {
-                missingCount++;
+    }
+    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)" };
+                }
             }
         }
     }
-    console.log("\n------------------------------------------------------------");
-    if (missingCount === 0) {
-        console.log("\x1b[32m[Doctor]\x1b[0m System ready for local test execution!");
+    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 };
+}
+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 missingRequired = dependencies.filter((d) => d.required && !d.installed);
+    const missingCount = missingRequired.length;
+    return {
+        all_ready: missingCount === 0,
+        missing_count: missingCount,
+        dependencies,
+    };
+}
+export async function doctorCommand(options = {}) {
+    const cwd = process.cwd();
+    const result = await runSystemChecks(cwd);
+    if (options.json) {
+        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`);
+            }
+            else {
+                console.log(`\x1b[36m│\x1b[0m   \x1b[33m!\x1b[0m ${item.name.padEnd(28)} \x1b[90m(Not found - Optional)\x1b[0m`);
+            }
+        }
+        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[Doctor]\x1b[0m Found ${missingCount} missing required dependencies.`);
+        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);
+                }
+            }
+        }
     }
 }

package/dist/index.js

@@ -42,6 +42,7 @@ export function createCliProgram() {
         .command("doctor")
         .description("Verify local environment prerequisites (ADB, Java, Chrome, Bun, Node)")
         .option("--fix", "Attempt automatic fix / download of missing tools")
+        .option("--json", "Output diagnostic results as JSON")
         .action(doctorCommand);
     program
         .command("devices")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testspectra/cli",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "description": "TestSpectra Zero-Config Cross-Platform Test Runner CLI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@testspectra/matchers": "^1.0.65",
+    "@testspectra/matchers": "^1.0.67",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",

package/templates/default/package.json

@@ -8,8 +8,8 @@
     "type-check": "tsc -b"
   },
   "devDependencies": {
-    "@testspectra/cli": "^1.0.65",
-    "@testspectra/matchers": "^1.0.65",
+    "@testspectra/cli": "^1.0.67",
+    "@testspectra/matchers": "^1.0.67",
     "@types/node": "^20.14.0",
     "@wdio/cli": "^9.2.8",
     "@wdio/local-runner": "^9.2.8",

package/templates/nx/package.json

@@ -10,8 +10,8 @@
     "build": "nx run-many -t build"
   },
   "devDependencies": {
-    "@testspectra/cli": "^1.0.65",
-    "@testspectra/matchers": "^1.0.65",
+    "@testspectra/cli": "^1.0.67",
+    "@testspectra/matchers": "^1.0.67",
     "@types/node": "^20.14.0",
     "@wdio/cli": "^9.2.8",
     "@wdio/local-runner": "^9.2.8",