@houwert/conductor 0.4.0 → 0.6.0

package/README.md

@@ -24,10 +24,10 @@ Conductor gives Claude Code the ability to interact with iOS simulators and Andr
 
 ```bash
 conductor launch-app com.example.myapp
-conductor tap "Sign In"
-conductor type "user@example.com"
+conductor tap-on "Sign In"
+conductor input-text "user@example.com"
 conductor assert-visible "Dashboard"
-conductor screenshot --output /tmp/screen.png
+conductor take-screenshot --output /tmp/screen.png
 ```
 
 One agent writes the feature. Another taps through the app. They talk. It works. 🤝
@@ -57,18 +57,21 @@ Claude learns every available command, how to coordinate across devices, and how
 
 | Command | What it does |
 |---|---|
-| `npm install -g @houwert/conductor` | Registers global plugin automatically (via postinstall) |
-| `conductor install` | Re-register or update the global plugin |
-| `conductor install --skills` | Copy skills into `.claude/skills/conductor/` in the current project |
-| `conductor install --check` | Print current install status without modifying anything |
+| `npm install -g @houwert/conductor` | Registers or updates the global Claude Code plugin (via package postinstall) |
+| `conductor install-plugin` | Re-register or update the global Claude Code plugin (same as postinstall) |
+| `conductor install-plugin --check` | Print whether the global plugin is registered (no changes) |
+| `conductor install-skills` | Copy skills into `.claude/skills/conductor/` in the current project |
+| `conductor install-skills --check` | Print whether local skills are installed (no changes) |
+| `conductor install-web` | Install a Playwright browser for web automation (default: chromium) |
+| `conductor install-web --check` | Print which Playwright browsers are installed (no changes) |
 
 ### 📱 What Claude can do
 
 | Capability | Commands |
 |---|---|
-| App lifecycle | `launch-app`, `stop-app`, `foreground-app`, `copy-app` |
-| Interaction | `tap`, `type`, `scroll`, `scroll-until-visible`, `swipe`, `press-key`, `erase-text`, `hide-keyboard` |
-| Inspection | `inspect`, `focused`, `screenshot`, `list-apps` |
+| App lifecycle | `launch-app`, `stop-app`, `clear-state`, `uninstall-app`, `install-app`, `foreground-app`, `copy-app` |
+| Interaction | `tap-on`, `input-text`, `scroll`, `scroll-until-visible`, `swipe`, `press-key`, `erase-text`, `hide-keyboard` |
+| Inspection | `inspect`, `focused`, `take-screenshot`, `list-apps` |
 | Assertions | `assert-visible`, `assert-not-visible` |
 | Navigation | `open-link`, `back` |
 | Flows | `run-flow`, `run-flow-inline`, `run-parallel` |

package/dist/commands/assert-not-visible.js

@@ -10,6 +10,7 @@ const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
 const wait_js_1 = require("../drivers/wait.js");
 async function assertNotVisible(element, opts = {}, sessionName = 'default', flags = {}) {
     if (!element && !flags.id && !flags.text) {
@@ -38,6 +39,9 @@ async function assertNotVisible(element, opts = {}, sessionName = 'default', fla
         if (driver instanceof ios_js_1.IOSDriver) {
             await (0, wait_js_1.waitUntilIOSElementGone)(() => driver.viewHierarchy().then((h) => h.axElement), sel, flags.timeout);
         }
+        else if (driver instanceof web_js_1.WebDriver) {
+            await (0, wait_js_1.waitUntilWebElementGone)(() => driver.viewHierarchy(), sel, flags.timeout);
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             await (0, wait_js_1.waitUntilAndroidElementGone)(() => driver.viewHierarchy(), sel, flags.timeout);
         }

package/dist/commands/assert-visible.js

@@ -20,6 +20,7 @@ const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
 const wait_js_1 = require("../drivers/wait.js");
 async function assertVisible(element, opts = {}, sessionName = 'default', flags = {}) {
     if (!element && !flags.id && !flags.text) {
@@ -50,6 +51,9 @@ async function assertVisible(element, opts = {}, sessionName = 'default', flags
             if (driver instanceof ios_js_1.IOSDriver) {
                 return (0, wait_js_1.waitForIOSElement)(() => driver.viewHierarchy().then((h) => h.axElement), sel, timeoutMs);
             }
+            else if (driver instanceof web_js_1.WebDriver) {
+                return (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel, timeoutMs);
+            }
             else if (driver instanceof android_js_1.AndroidDriver) {
                 return (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel, timeoutMs);
             }

package/dist/commands/back.js

@@ -7,6 +7,7 @@ const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
 async function back(opts = {}, sessionName = 'default') {
     const result = await (0, runner_js_1.runDirect)(async (driver) => {
         if (driver instanceof ios_js_1.IOSDriver) {
@@ -15,6 +16,9 @@ async function back(opts = {}, sessionName = 'default') {
             }
             // Plain iOS has no universal "back" concept — this is a no-op (same as maestro IOSDriver.backPress)
         }
+        else if (driver instanceof web_js_1.WebDriver) {
+            await driver.goBack();
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             await driver.back(); // adb shell input keyevent 4
         }

package/dist/commands/cheat-sheet.js

@@ -34,6 +34,8 @@ DEVICE MANAGEMENT
   session --list                            List all device sessions
 
 APP CONTROL
+  download-app <appId> [--output <path>]     Download installed app binary from device
+  install-app <path>                        Install .app / .ipa / .apk onto device
   launch-app <appId> [--device <id>]        Launch app and save to session
     --clear-state                           Wipe app data/state before launching
     --clear-keychain                        Wipe keychain before launching
@@ -43,12 +45,12 @@ APP CONTROL
   uninstall-app <appId>                     Uninstall app from device
 
 INTERACTIONS
-  tap <element>                             Tap element by text
+  tap-on <element>                           Tap element by text
     --id <id>                               Match by accessibility ID instead of text
     --index <n>                             Pick the nth match (0-based)
     --long-press                            Hold instead of tap
     --double-tap                            Double-tap the element
-  type <text>                               Type text into focused field
+  input-text <text>                          Type text into focused field
   back                                      Press back button (Android only)
   press-key <key>                           Press a key (Enter, Backspace, Home, ...)
   scroll [--direction down|up|left|right]   Scroll (default: down)
@@ -64,7 +66,7 @@ ASSERTIONS
     --optional                              Succeed even if element is not found
 
 SCREENSHOTS & INSPECTION
-  screenshot [--output <path>]              Take screenshot (default: ./screenshot-<ts>.png)
+  take-screenshot [--output <path>]          Take screenshot (default: ./screenshot-<ts>.png)
   inspect                                   Print UI hierarchy
 
 FLOW EXECUTION
@@ -83,7 +85,9 @@ MULTI-AGENT / PARALLEL
   run-parallel --flows-dir <path>           Run flows in parallel across all devices
 
 MISC
-  install --skills                          Install skill files into .claude/skills/
+  install-plugin                            Register/update the global Claude Code plugin
+  install-skills                            Install skill files into .claude/skills/
+  install-web [browser]                     Install Playwright browser for web automation
   cheat-sheet                               Print this reference
 
 GLOBAL FLAGS
@@ -94,11 +98,11 @@ GLOBAL FLAGS
 
 EXAMPLES
   conductor launch-app com.example.app
-  conductor tap "Sign In"
-  conductor tap --id "btn_login"
-  conductor type "hello@example.com"
+  conductor tap-on "Sign In"
+  conductor tap-on --id "btn_login"
+  conductor input-text "hello@example.com"
   conductor swipe --start 0.5,0.8 --end 0.5,0.2
   conductor assert-visible "Dashboard" --timeout 30000
-  conductor screenshot --output /tmp/screen.png
+  conductor take-screenshot --output /tmp/screen.png
   conductor run-flow ./flows/login.yaml
 `.trim();

package/dist/commands/delete-device.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.deleteDevice = deleteDevice;
+exports.HELP = `  delete-device <name-or-id>
+    --platform <ios|tvos|android>  Scope to a single platform
+    --all                          Delete all shutdown simulators / non-running AVDs`;
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+async function listSimulators() {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', '--json']);
+    if (!result.success)
+        throw new Error(`xcrun simctl list failed: ${result.stderr}`);
+    const parsed = JSON.parse(result.stdout);
+    const flat = [];
+    for (const [runtime, sims] of Object.entries(parsed.devices)) {
+        for (const sim of sims) {
+            if (sim.isAvailable)
+                flat.push({ runtime, device: sim });
+        }
+    }
+    return flat;
+}
+function simPlatform(runtime) {
+    return runtime.includes('tvOS') ? 'tvos' : 'ios';
+}
+async function shutdownSimulator(udid) {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'shutdown', udid]);
+    if (!result.success && !result.stderr.includes('current state: Shutdown')) {
+        throw new Error(`Failed to shutdown simulator: ${result.stderr.trim()}`);
+    }
+}
+async function deleteSimulator(udid) {
+    const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'delete', udid]);
+    if (!result.success) {
+        throw new Error(`Failed to delete simulator: ${result.stderr.trim()}`);
+    }
+}
+// ── Android ──────────────────────────────────────────────────────────────────
+async function listAVDs() {
+    const result = await (0, runner_js_1.spawnCommand)('emulator', ['-list-avds']);
+    if (!result.success)
+        return [];
+    return result.stdout
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+/** Map running emulator serial → AVD name */
+async function runningAVDs() {
+    const map = new Map();
+    const result = await (0, runner_js_1.spawnCommand)('adb', ['devices']);
+    if (!result.success)
+        return map;
+    const serials = result.stdout
+        .split('\n')
+        .slice(1)
+        .map((l) => l.trim().split(/\s+/)[0])
+        .filter((s) => s && s.startsWith('emulator-'));
+    for (const serial of serials) {
+        const name = await (0, runner_js_1.spawnCommand)('adb', ['-s', serial, 'emu', 'avd', 'name']);
+        if (name.success) {
+            const avdName = name.stdout.trim().split('\n')[0];
+            if (avdName)
+                map.set(avdName, serial);
+        }
+    }
+    return map;
+}
+async function killEmulator(serial) {
+    const result = await (0, runner_js_1.spawnCommand)('adb', ['-s', serial, 'emu', 'kill']);
+    if (!result.success) {
+        throw new Error(`Failed to kill emulator ${serial}: ${result.stderr.trim()}`);
+    }
+}
+async function deleteAVD(name) {
+    const result = await (0, runner_js_1.spawnCommand)('avdmanager', ['delete', 'avd', '-n', name]);
+    if (!result.success) {
+        throw new Error(`Failed to delete AVD "${name}": ${result.stderr.trim()}`);
+    }
+}
+// ── Entry point ──────────────────────────────────────────────────────────────
+async function deleteDevice(nameOrId, opts, flags) {
+    if (!nameOrId && !flags.all) {
+        (0, output_js_1.printError)('delete-device requires a device name/ID, or --all', opts);
+        return 1;
+    }
+    const platform = flags.platform?.toLowerCase();
+    const includeIOS = !platform || platform === 'ios';
+    const includeTvOS = !platform || platform === 'tvos';
+    const includeAndroid = !platform || platform === 'android';
+    const deleted = [];
+    // ── --all mode ───────────────────────────────────────────────────────────
+    if (flags.all) {
+        // iOS / tvOS: delete all non-booted simulators
+        if (includeIOS || includeTvOS) {
+            let sims;
+            try {
+                sims = await listSimulators();
+            }
+            catch (e) {
+                (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+                return 1;
+            }
+            for (const { runtime, device } of sims) {
+                const p = simPlatform(runtime);
+                if (p === 'ios' && !includeIOS)
+                    continue;
+                if (p === 'tvos' && !includeTvOS)
+                    continue;
+                if (device.state === 'Booted')
+                    continue;
+                try {
+                    await deleteSimulator(device.udid);
+                    deleted.push({ id: device.udid, name: device.name, platform: p });
+                }
+                catch (e) {
+                    (0, output_js_1.printError)(`Failed to delete ${device.name} (${device.udid}): ${e instanceof Error ? e.message : String(e)}`, opts);
+                }
+            }
+        }
+        // Android: delete all non-running AVDs
+        if (includeAndroid) {
+            const avds = await listAVDs();
+            const running = await runningAVDs();
+            for (const avd of avds) {
+                if (running.has(avd))
+                    continue;
+                try {
+                    await deleteAVD(avd);
+                    deleted.push({ id: avd, name: avd, platform: 'android' });
+                }
+                catch (e) {
+                    (0, output_js_1.printError)(`Failed to delete AVD "${avd}": ${e instanceof Error ? e.message : String(e)}`, opts);
+                }
+            }
+        }
+        if (deleted.length === 0) {
+            (0, output_js_1.printError)('No devices to delete.', opts);
+            return 1;
+        }
+        if (opts.json) {
+            (0, output_js_1.printData)({ status: 'ok', deleted }, opts);
+        }
+        else {
+            for (const d of deleted) {
+                (0, output_js_1.printSuccess)(`Deleted ${d.platform} device: ${d.name} (${d.id})`, opts);
+            }
+        }
+        return 0;
+    }
+    // ── Single device mode ─────────────────────────────────────────────────
+    // Try iOS / tvOS first
+    if (includeIOS || includeTvOS) {
+        let sims;
+        try {
+            sims = await listSimulators();
+        }
+        catch (e) {
+            (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+            return 1;
+        }
+        const match = sims.find(({ runtime, device }) => {
+            const p = simPlatform(runtime);
+            if (p === 'ios' && !includeIOS)
+                return false;
+            if (p === 'tvos' && !includeTvOS)
+                return false;
+            return device.udid === nameOrId || device.name === nameOrId;
+        });
+        if (match) {
+            const { runtime, device } = match;
+            try {
+                if (device.state === 'Booted') {
+                    console.log(`Shutting down ${device.name}...`);
+                    await shutdownSimulator(device.udid);
+                }
+                await deleteSimulator(device.udid);
+            }
+            catch (e) {
+                (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+                return 1;
+            }
+            const p = simPlatform(runtime);
+            if (opts.json) {
+                (0, output_js_1.printData)({ status: 'ok', deleted: [{ id: device.udid, name: device.name, platform: p }] }, opts);
+            }
+            else {
+                (0, output_js_1.printSuccess)(`Deleted ${p} device: ${device.name} (${device.udid})`, opts);
+            }
+            return 0;
+        }
+    }
+    // Try Android
+    if (includeAndroid) {
+        const avds = await listAVDs();
+        if (avds.includes(nameOrId)) {
+            const running = await runningAVDs();
+            try {
+                const serial = running.get(nameOrId);
+                if (serial) {
+                    console.log(`Killing emulator ${serial}...`);
+                    await killEmulator(serial);
+                }
+                await deleteAVD(nameOrId);
+            }
+            catch (e) {
+                (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
+                return 1;
+            }
+            if (opts.json) {
+                (0, output_js_1.printData)({ status: 'ok', deleted: [{ id: nameOrId, name: nameOrId, platform: 'android' }] }, opts);
+            }
+            else {
+                (0, output_js_1.printSuccess)(`Deleted android AVD: ${nameOrId}`, opts);
+            }
+            return 0;
+        }
+    }
+    (0, output_js_1.printError)(`Device "${nameOrId}" not found.`, opts);
+    return 1;
+}

package/dist/commands/device-pool.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HELP = void 0;
+exports._testDeviceOverride = exports.HELP = void 0;
 exports.devicePool = devicePool;
 exports.HELP = `  device-pool --list                  List all devices and pool status
   device-pool --acquire               Claim a free device (prints device ID)
@@ -23,22 +23,24 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const output_js_1 = require("../output.js");
-const POOL_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'device-pool.json');
-const LOCK_FILE = POOL_FILE + '.lock';
+function poolFilePath() {
+    return (process.env.__CONDUCTOR_POOL_FILE ?? path_1.default.join(os_1.default.homedir(), '.conductor', 'device-pool.json'));
+}
 const LOCK_TIMEOUT_MS = 5000;
 // ── File locking ──────────────────────────────────────────────────────────────
 async function withLock(fn) {
+    const lockFile = poolFilePath() + '.lock';
     const deadline = Date.now() + LOCK_TIMEOUT_MS;
     while (Date.now() < deadline) {
         try {
-            const fd = fs_1.default.openSync(LOCK_FILE, 'wx'); // exclusive create
+            const fd = fs_1.default.openSync(lockFile, 'wx'); // exclusive create
             fs_1.default.closeSync(fd);
             try {
                 return await Promise.resolve(fn());
             }
             finally {
                 try {
-                    fs_1.default.unlinkSync(LOCK_FILE);
+                    fs_1.default.unlinkSync(lockFile);
                 }
                 catch {
                     /* ok */
@@ -53,7 +55,7 @@ async function withLock(fn) {
 }
 function readPool() {
     try {
-        const raw = fs_1.default.readFileSync(POOL_FILE, 'utf-8');
+        const raw = fs_1.default.readFileSync(poolFilePath(), 'utf-8');
         return JSON.parse(raw);
     }
     catch {
@@ -61,11 +63,13 @@ function readPool() {
     }
 }
 function writePool(state) {
-    fs_1.default.mkdirSync(path_1.default.dirname(POOL_FILE), { recursive: true });
-    fs_1.default.writeFileSync(POOL_FILE, JSON.stringify(state, null, 2));
+    const p = poolFilePath();
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(state, null, 2));
 }
-// ── Device discovery ──────────────────────────────────────────────────────────
 async function discoverAllDevices() {
+    if (exports._testDeviceOverride)
+        return exports._testDeviceOverride;
     const devices = [];
     // Android: adb devices
     try {
@@ -96,11 +100,29 @@ async function discoverAllDevices() {
     }
     return devices;
 }
+function pruneStaleAcquisitions(state) {
+    for (const entry of state.devices) {
+        if (entry.acquiredBy) {
+            try {
+                process.kill(parseInt(entry.acquiredBy, 10), 0);
+            }
+            catch {
+                delete entry.acquiredBy;
+                delete entry.acquiredAt;
+            }
+        }
+    }
+}
 // ── Commands ──────────────────────────────────────────────────────────────────
 async function devicePool(action, releaseId, opts = {}) {
     if (action === 'list') {
         const allDevices = await discoverAllDevices();
-        const pool = readPool();
+        const pool = await withLock(() => {
+            const state = readPool();
+            pruneStaleAcquisitions(state);
+            writePool(state);
+            return state;
+        });
         const rows = allDevices.map((id) => {
             const entry = pool.devices.find((e) => e.deviceId === id);
             const status = entry?.acquiredBy ? `acquired by PID ${entry.acquiredBy}` : 'free';
@@ -131,18 +153,7 @@ async function devicePool(action, releaseId, opts = {}) {
         }
         const result = await withLock(() => {
             const state = readPool();
-            // Prune stale acquisitions (process no longer running)
-            for (const entry of state.devices) {
-                if (entry.acquiredBy) {
-                    try {
-                        process.kill(parseInt(entry.acquiredBy, 10), 0);
-                    }
-                    catch {
-                        delete entry.acquiredBy;
-                        delete entry.acquiredAt;
-                    }
-                }
-            }
+            pruneStaleAcquisitions(state);
             // Ensure all discovered devices are in the pool
             for (const id of allDevices) {
                 if (!state.devices.find((e) => e.deviceId === id)) {

package/dist/commands/download-app.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.downloadApp = downloadApp;
+exports.HELP = `  download-app <appId> --output <path>  Download installed app binary from device`;
+const path_1 = __importDefault(require("path"));
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+async function downloadApp(appId, output, opts = {}, sessionName = 'default') {
+    if (!appId) {
+        (0, output_js_1.printError)('download-app requires <appId>', opts);
+        return 1;
+    }
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform === 'ios' || platform === 'tvos') {
+        // Get the .app bundle path from the simulator
+        const getPath = await (0, runner_js_1.spawnCommand)('xcrun', [
+            'simctl',
+            'get_app_container',
+            deviceId,
+            appId,
+            'app',
+        ]);
+        if (!getPath.success) {
+            (0, output_js_1.printError)(`Failed to locate app on device: ${getPath.stderr}`, opts);
+            return 1;
+        }
+        const appPath = getPath.stdout.trim();
+        const appName = path_1.default.basename(appPath);
+        const dest = output ?? path_1.default.join(process.cwd(), appName);
+        const copy = await (0, runner_js_1.spawnCommand)('cp', ['-R', appPath, dest]);
+        if (!copy.success) {
+            (0, output_js_1.printError)(`Failed to copy app bundle: ${copy.stderr}`, opts);
+            return 1;
+        }
+        if (opts.json) {
+            (0, output_js_1.printData)({ status: 'ok', appId, path: dest }, opts);
+        }
+        else {
+            (0, output_js_1.printSuccess)(`download-app "${appId}" → ${dest}`, opts);
+        }
+        return 0;
+    }
+    else {
+        // Android: find the APK path, then pull it
+        const pmPath = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'pm', 'path', appId]);
+        if (!pmPath.success) {
+            (0, output_js_1.printError)(`Failed to locate app on device: ${pmPath.stderr}`, opts);
+            return 1;
+        }
+        // pm path output: "package:/data/app/.../base.apk"
+        const apkPath = pmPath.stdout.trim().replace(/^package:/, '');
+        if (!apkPath) {
+            (0, output_js_1.printError)(`Could not resolve APK path for "${appId}"`, opts);
+            return 1;
+        }
+        const dest = output ?? path_1.default.join(process.cwd(), `${appId}.apk`);
+        const pull = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'pull', apkPath, dest]);
+        if (!pull.success) {
+            (0, output_js_1.printError)(`Failed to pull APK: ${pull.stderr}`, opts);
+            return 1;
+        }
+        if (opts.json) {
+            (0, output_js_1.printData)({ status: 'ok', appId, path: dest }, opts);
+        }
+        else {
+            (0, output_js_1.printSuccess)(`download-app "${appId}" → ${dest}`, opts);
+        }
+        return 0;
+    }
+}

package/dist/commands/erase-text.js

@@ -7,11 +7,15 @@ const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
 async function eraseText(characters, opts = {}, sessionName = 'default') {
     const result = await (0, runner_js_1.runDirect)(async (driver) => {
         if (driver instanceof android_js_1.AndroidDriver) {
             await driver.eraseAllText(characters);
         }
+        else if (driver instanceof web_js_1.WebDriver) {
+            await driver.eraseAllText(characters);
+        }
         else if (driver instanceof ios_js_1.IOSDriver) {
             for (let i = 0; i < characters; i++)
                 await driver.pressKey('delete');

package/dist/commands/focused.js

@@ -8,6 +8,7 @@ const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
 const element_resolver_js_1 = require("../drivers/element-resolver.js");
 // XCUIElementType rawValue → human-readable name.
 // Source: XCUIElementType enum in XCTest framework.
@@ -161,12 +162,50 @@ function formatAndroidNode(node) {
         },
     };
 }
+function findFocusedWeb(elements) {
+    for (const el of elements) {
+        if (el.children) {
+            const found = findFocusedWeb(el.children);
+            if (found)
+                return found;
+        }
+        if (el.focused)
+            return el;
+    }
+    return null;
+}
+function formatWebElement(node) {
+    const b = node.bounds;
+    return {
+        text: node.name || '',
+        ref: node.ref || '',
+        role: node.role,
+        enabled: node.enabled,
+        focused: node.focused,
+        checked: node.checked ?? null,
+        selected: node.selected ?? null,
+        bounds: b
+            ? {
+                x: Math.round(b.x),
+                y: Math.round(b.y),
+                width: Math.round(b.width),
+                height: Math.round(b.height),
+            }
+            : null,
+        center: b ? { x: Math.round(b.x + b.width / 2), y: Math.round(b.y + b.height / 2) } : null,
+    };
+}
 async function queryFocused(driver) {
     if (driver instanceof ios_js_1.IOSDriver) {
         const hierarchy = await driver.viewHierarchy(false);
         const node = findFocusedIOS(hierarchy.axElement);
         return node ? formatIOSElement(node) : null;
     }
+    else if (driver instanceof web_js_1.WebDriver) {
+        const hierarchy = await driver.viewHierarchy();
+        const node = findFocusedWeb(hierarchy.elements);
+        return node ? formatWebElement(node) : null;
+    }
     else if (driver instanceof android_js_1.AndroidDriver) {
         const xml = await driver.viewHierarchy();
         const nodes = (0, element_resolver_js_1.parseAndroidHierarchy)(xml);