@testspectra/cli 1.0.70 → 1.1.0-rc.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/demo.js

@@ -1,24 +1,34 @@
-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';
+import { DemoApiServer } from '../utils/api-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);
+    const apiServer = new DemoApiServer();
     try {
         const { url } = await server.start();
         p.log.success(chalk.green(`Demo web app is live at: ${chalk.bold.underline(url)}`));
+        // The web app fetches its API sections from the separate self-hosted API server, so start it
+        // too — otherwise the API demo sections show only their offline fallback data.
+        try {
+            const { url: apiUrl } = await apiServer.start();
+            p.log.success(chalk.green(`Demo API server is live at: ${chalk.bold.underline(apiUrl)}`));
+        }
+        catch (err) {
+            p.log.warn(chalk.yellow(`Could not start demo API server: ${err.message}`));
+        }
         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 servers.'));
         // Handle termination gracefully
-        process.on("SIGINT", async () => {
+        const shutdown = async () => {
             await server.stop();
+            await apiServer.stop();
             process.exit(0);
-        });
-        process.on("SIGTERM", async () => {
-            await server.stop();
-            process.exit(0);
-        });
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
         await new Promise(() => { });
     }
     catch (err) {

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>;

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>;