@houwert/conductor 0.22.0 → 0.24.0

package/dist/commands/start-device.js

@@ -10,7 +10,7 @@ exports.pickSystemImage = pickSystemImage;
 exports.buildAvdmanagerCreateArgs = buildAvdmanagerCreateArgs;
 exports.startDevice = startDevice;
 exports.HELP = `  start-device
-    --platform <ios|android|tvos|web> Boot a simulator/emulator, or start the web driver (Playwright)
+    --platform <ios|android|tvos|web|vega> Boot a simulator/emulator, start the web driver (Playwright), or boot/attach a Vega VVD
     --os-version <n>                  iOS/tvOS version (e.g. 18) or Android API level (e.g. 33)
     --avd <name>                      Android AVD name (default: first available; created if missing + --device-type)
     --name <name>                     Set a custom name on the device after creation (iOS/tvOS/web)
@@ -28,6 +28,7 @@ const protocol_js_1 = require("../daemon/protocol.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const output_js_1 = require("../output.js");
 const utils_js_1 = require("../utils.js");
+const cli_js_1 = require("../drivers/vega/cli.js");
 const IOS_BOOT_TIMEOUT_MS = 120000;
 const ANDROID_BOOT_TIMEOUT_MS = 120000;
 const POLL_MS = 1000;
@@ -694,10 +695,64 @@ async function startWebDriver(opts, browser, name) {
     (0, output_js_1.printSuccess)(`Web driver ready: ${displayName} (${session})`, opts);
     return 0;
 }
+// ── Vega (Amazon Fire TV) ───────────────────────────────────────────────────
+const VEGA_BOOT_TIMEOUT_MS = 180000;
+/** Pick the target VVD from a device list: by name if given, else first virtual, else first. */
+function pickVegaDevice(devices, deviceName) {
+    return ((deviceName ? devices.find((d) => d.serial === deviceName) : undefined) ??
+        devices.find((d) => d.isVirtual) ??
+        devices[0]);
+}
+/**
+ * Boot (or attach to) a Vega Virtual Device. If one is already running we attach;
+ * otherwise we launch it via `vega virtual-device start` and poll `vega device
+ * list` until it appears — mirroring how the Android emulator is booted. Then we
+ * prewarm the log daemon.
+ */
+async function startVega(opts, deviceName) {
+    const cli = new cli_js_1.VegaCli();
+    let devices;
+    try {
+        devices = await cli.listDevices();
+    }
+    catch {
+        (0, output_js_1.printError)('The Vega SDK CLI (`vega`/`kepler`) was not found. Install it and ensure it is on ' +
+            'PATH (or set CONDUCTOR_VEGA_CLI), then retry.', opts);
+        return 1;
+    }
+    let device = pickVegaDevice(devices, deviceName);
+    if (!device) {
+        console.log(`No running Vega device — booting a VVD${deviceName ? ` (${deviceName})` : ''} ` +
+            `via \`vega virtual-device start\`...`);
+        try {
+            cli.spawnVirtualDeviceStart(deviceName);
+        }
+        catch (e) {
+            (0, output_js_1.printError)(`Failed to start a Vega Virtual Device: ${e instanceof Error ? e.message : String(e)}`, opts);
+            return 1;
+        }
+        const deadline = Date.now() + VEGA_BOOT_TIMEOUT_MS;
+        while (Date.now() < deadline && !device) {
+            await (0, utils_js_1.sleep)(POLL_MS);
+            const current = await cli.listDevices().catch(() => []);
+            device = pickVegaDevice(current, deviceName);
+        }
+        if (!device) {
+            (0, output_js_1.printError)(`Vega Virtual Device did not become ready within ${VEGA_BOOT_TIMEOUT_MS / 1000}s. ` +
+                `Check \`vega virtual-device list\` — you may need to create one first, or pass ` +
+                `--name <vvd>.`, opts);
+            return 1;
+        }
+    }
+    // Prewarm the daemon so device/Metro log collection is already running.
+    await (0, runner_js_1.prewarmDriver)(`vega:${device.serial}`);
+    (0, output_js_1.printSuccess)(`Vega device ready: ${device.serial}`, opts);
+    return 0;
+}
 // ── Entry point ───────────────────────────────────────────────────────────────
 async function startDevice(platform, opts, flags) {
     if (!platform) {
-        (0, output_js_1.printError)('start-device requires --platform ios|android|tvos|web', opts);
+        (0, output_js_1.printError)('start-device requires --platform ios|android|tvos|web|vega', opts);
         return 1;
     }
     switch (platform.toLowerCase()) {
@@ -709,8 +764,10 @@ async function startDevice(platform, opts, flags) {
             return startAndroid(flags.avd, opts, flags.deviceType, flags.osVersion, flags.systemImage);
         case 'web':
             return startWebDriver(opts, flags.browser, flags.name);
+        case 'vega':
+            return startVega(opts, flags.name);
         default:
-            (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios, android, tvos, or web.`, opts);
+            (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios, android, tvos, web, or vega.`, opts);
             return 1;
     }
 }

package/dist/commands/stop-app.js

@@ -9,6 +9,7 @@ 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 vega_js_1 = require("../drivers/vega.js");
 async function stopApp(appId, opts = {}, sessionName = 'default') {
     const session = await (0, session_js_1.getSession)(sessionName);
     const resolvedAppId = appId ?? session.appId;
@@ -23,6 +24,9 @@ async function stopApp(appId, opts = {}, sessionName = 'default') {
         else if (driver instanceof web_js_1.WebDriver) {
             await driver.terminateApp();
         }
+        else if (driver instanceof vega_js_1.VegaDriver) {
+            await driver.stopApp(resolvedAppId);
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             await driver.stopApp(resolvedAppId);
         }

package/dist/commands/stop-device.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.stopDevice = stopDevice;
 exports.HELP = `  stop-device [<name-or-id>]
-    --platform <ios|tvos|android|web> Scope to a single platform
+    --platform <ios|tvos|android|web|vega> Scope to a single platform
     --all                             Stop all booted simulators / running emulators / web sessions`;
 const runner_js_1 = require("../runner.js");
 const sdk_js_1 = require("../android/sdk.js");
@@ -35,6 +35,7 @@ async function stopDevice(nameOrId, opts, flags) {
     const includeTvOS = !platform || platform === 'tvos';
     const includeAndroid = !platform || platform === 'android';
     const includeWeb = !platform || platform === 'web';
+    const includeVega = !platform || platform === 'vega';
     const stopped = [];
     // ── --all mode ───────────────────────────────────────────────────────────
     if (flags.all) {
@@ -48,6 +49,8 @@ async function stopDevice(nameOrId, opts, flags) {
                 continue;
             if (d.platform === 'web' && !includeWeb)
                 continue;
+            if (d.platform === 'vega' && !includeVega)
+                continue;
             try {
                 if (d.platform === 'ios' || d.platform === 'tvos') {
                     await shutdownSimulator(d.id);
@@ -55,7 +58,8 @@ async function stopDevice(nameOrId, opts, flags) {
                 else if (d.platform === 'android') {
                     await killEmulator(d.id);
                 }
-                else if (d.platform === 'web') {
+                else if (d.platform === 'web' || d.platform === 'vega') {
+                    // Vega VVD lifecycle is owned by Amazon's tooling — we only stop our log daemon.
                     await (0, client_js_1.stopDaemon)(d.id);
                 }
                 stopped.push({ id: d.id, name: d.name, platform: d.platform });
@@ -96,7 +100,8 @@ async function stopDevice(nameOrId, opts, flags) {
         else if (match.platform === 'android') {
             await killEmulator(match.id);
         }
-        else if (match.platform === 'web') {
+        else if (match.platform === 'web' || match.platform === 'vega') {
+            // Vega VVD lifecycle is owned by Amazon's tooling — we only stop our log daemon.
             await (0, client_js_1.stopDaemon)(match.id);
         }
     }

package/dist/commands/swipe.js

@@ -12,6 +12,7 @@ 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 vega_js_1 = require("../drivers/vega.js");
 const utils_js_1 = require("../utils.js");
 function parseCoordPair(s) {
     const [xs, ys] = s.split(',').map((p) => p.trim());
@@ -70,7 +71,7 @@ async function swipe(direction, opts = {}, sessionName = 'default', flags = {})
             }
             await driver.swipe(startX, startY, endX, endY, durationMs);
         }
-        else if (driver instanceof android_js_1.AndroidDriver) {
+        else if (driver instanceof android_js_1.AndroidDriver || driver instanceof vega_js_1.VegaDriver) {
             const { widthPixels: w, heightPixels: h } = await driver.deviceInfo();
             const durationMs = flags.duration ?? 500;
             if (flags.start && flags.end) {

package/dist/commands/tap.js

@@ -22,6 +22,7 @@ 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 vega_js_1 = require("../drivers/vega.js");
 const wait_js_1 = require("../drivers/wait.js");
 const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const snapshot_store_js_1 = require("../snapshot-store.js");
@@ -68,6 +69,10 @@ async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
         else if (driver instanceof web_js_1.WebDriver) {
             el = await (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel);
         }
+        else if (driver instanceof vega_js_1.VegaDriver) {
+            // Vega emits uiautomator-style XML, so it reuses the Android resolver.
+            el = await (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel);
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             el = await (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel);
         }
@@ -75,14 +80,12 @@ async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
             return;
         }
         if (flags.longPress) {
-            if (driver instanceof ios_js_1.IOSDriver) {
-                await driver.tap(el.centerX, el.centerY, 1.5);
-            }
-            else if (driver instanceof web_js_1.WebDriver) {
-                await driver.tap(el.centerX, el.centerY, 1.5);
+            if (driver instanceof android_js_1.AndroidDriver) {
+                await driver.swipe(el.centerX, el.centerY, el.centerX, el.centerY, 1500);
             }
             else {
-                await driver.swipe(el.centerX, el.centerY, el.centerX, el.centerY, 1500);
+                // iOS, web, and vega express a long press as a held tap.
+                await driver.tap(el.centerX, el.centerY, 1.5);
             }
         }
         else if (flags.doubleTap) {

package/dist/commands/uninstall-app.js

@@ -8,6 +8,7 @@ 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 vega_js_1 = require("../drivers/vega.js");
 async function uninstallApp(appId, opts = {}, sessionName = 'default') {
     if (!appId) {
         (0, output_js_1.printError)('uninstall-app requires <appId>', opts);
@@ -20,6 +21,9 @@ async function uninstallApp(appId, opts = {}, sessionName = 'default') {
         else if (driver instanceof web_js_1.WebDriver) {
             throw new Error('uninstall-app is not supported on web');
         }
+        else if (driver instanceof vega_js_1.VegaDriver) {
+            throw new Error('uninstall-app is not supported on vega (Amazon Fire TV)');
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             await driver.uninstallApp(appId);
         }

package/dist/commands/web-targets.js

@@ -1,7 +1,4 @@
 "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.webTargets = webTargets;
@@ -14,37 +11,8 @@ exports.webTargets = webTargets;
  * Playwright browser and works before any daemon session exists. Use the printed
  * target IDs with `--cdp-url` / `--cdp-target` to bind a session to a tile.
  */
-const http_1 = __importDefault(require("http"));
 const output_js_1 = require("../output.js");
-/** Derive the `http://host:port` base from a CDP URL (which may be ws:// or include a path). */
-function httpBase(cdpUrl) {
-    const u = new URL(cdpUrl);
-    const proto = u.protocol === 'https:' || u.protocol === 'wss:' ? 'https:' : 'http:';
-    return `${proto}//${u.host}`;
-}
-function fetchTargets(cdpUrl) {
-    const url = `${httpBase(cdpUrl)}/json/list`;
-    return new Promise((resolve, reject) => {
-        const req = http_1.default.get(url, (res) => {
-            const chunks = [];
-            res.on('data', (c) => chunks.push(c));
-            res.on('end', () => {
-                if ((res.statusCode ?? 0) >= 300) {
-                    reject(new Error(`HTTP ${res.statusCode} from ${url}`));
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-        });
-        req.setTimeout(5000, () => req.destroy(new Error(`Timed out fetching ${url}`)));
-        req.on('error', reject);
-    });
-}
+const cdp_discovery_js_1 = require("../drivers/cdp-discovery.js");
 async function webTargets(cdpUrl, opts) {
     if (!cdpUrl) {
         console.error('web-targets requires --cdp-url <url> (e.g. --cdp-url http://127.0.0.1:9222).\n' +
@@ -53,7 +21,7 @@ async function webTargets(cdpUrl, opts) {
     }
     let targets;
     try {
-        targets = await fetchTargets(cdpUrl);
+        targets = await (0, cdp_discovery_js_1.fetchCdpTargets)(cdpUrl);
     }
     catch (err) {
         console.error(`Could not reach CDP endpoint at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}`);

package/dist/commands/workspace.js

@@ -112,7 +112,10 @@ async function workspaceInfo(opts = {}) {
     const devices = await (0, list_devices_js_1.discoverBootedDevices)().catch(() => []);
     let metroPort = null;
     for (const d of devices) {
-        if (d.platform !== 'ios' && d.platform !== 'tvos' && d.platform !== 'android')
+        if (d.platform !== 'ios' &&
+            d.platform !== 'tvos' &&
+            d.platform !== 'android' &&
+            d.platform !== 'vega')
             continue;
         const port = await (0, metro_discovery_js_1.discoverMetroPortForDevice)(d.platform, d.id).catch(() => null);
         if (port) {

package/dist/daemon/log-collector.js

@@ -32,6 +32,7 @@ const http_1 = __importDefault(require("http"));
 const types_js_1 = require("../drivers/log-sources/types.js");
 const ios_js_1 = require("../drivers/log-sources/ios.js");
 const android_js_1 = require("../drivers/log-sources/android.js");
+const vega_js_1 = require("../drivers/log-sources/vega.js");
 const metro_js_1 = require("../drivers/log-sources/metro.js");
 const metro_discovery_js_1 = require("../drivers/log-sources/metro-discovery.js");
 const MAX_BUFFER = 5000;
@@ -75,7 +76,10 @@ class LogCollector {
         // Metro is always auto-discovered. Discovery retries forever with a
         // backoff ceiling — the app may be launched long after the daemon starts,
         // and the cost per attempt is tiny (a few spawns + one HTTP call).
-        if (this.platform === 'ios' || this.platform === 'tvos' || this.platform === 'android') {
+        if (this.platform === 'ios' ||
+            this.platform === 'tvos' ||
+            this.platform === 'android' ||
+            this.platform === 'vega') {
             this.startMetroAutoDiscovery();
         }
     }
@@ -146,6 +150,10 @@ class LogCollector {
             else if (this.platform === 'android') {
                 this.source = new android_js_1.AndroidLogSource(this.deviceId, this.appId);
             }
+            else if (this.platform === 'vega') {
+                // deviceId is `vega:<serial>`; VegaCli wants the bare serial.
+                this.source = new vega_js_1.VegaLogSource(this.deviceId.replace(/^vega:/, ''));
+            }
             else {
                 return; // Unsupported platform for device log collection
             }

package/dist/daemon/server.js

@@ -85,6 +85,9 @@ let _driverStartError = null;
 async function ensureDriverRunning() {
     if (_restartInProgress || !_driverStarted)
         return;
+    // Vega has no driver process/port to health-check — control is host-side via the CLI.
+    if (driverPlatform === 'vega')
+        return;
     let alive;
     if (driverPlatform === 'android') {
         const probe = new android_js_1.AndroidDriver(sessionName, driverPort);
@@ -197,6 +200,9 @@ async function main() {
             if (driverPlatform === 'tvos') {
                 dlog('tvOS: leaving driver running to preserve app state');
             }
+            else if (driverPlatform === 'vega') {
+                dlog('vega: no driver process to stop (control is host-side via the CLI)');
+            }
             else if (driverPlatform === 'web') {
                 dlog('Stopping web driver');
                 try {
@@ -321,59 +327,14 @@ async function main() {
                 driverPlatform = platform;
                 driverPort = await (0, bootstrap_js_1.getDriverPort)(platform, sessionName);
                 dlog(`Platform: ${platform}, port: ${driverPort}`);
-                let driverAlive;
-                if (platform === 'android') {
-                    const probe = new android_js_1.AndroidDriver(sessionName, driverPort);
-                    await probe.connect();
-                    driverAlive = await probe.isAlive().catch(() => false);
-                    probe.close();
-                }
-                else {
-                    // 'ios', 'tvos', and 'web' all use an HTTP server — port open = alive
-                    driverAlive = await (0, bootstrap_js_1.isPortOpen)(driverPort);
-                }
-                if (driverAlive) {
+                // Vega has no driver process — control is host-side via the vega CLI.
+                // The daemon exists only to collect device + Metro logs.
+                if (platform === 'vega') {
                     _driverStarted = true;
-                    dlog(`Driver already running on port ${driverPort}`);
+                    dlog('vega: no driver process to start; collecting logs only');
                 }
                 else {
-                    // Android: install APKs before starting the driver.
-                    // iOS/tvOS: xcodebuild installs silently via DependentProductPaths.
-                    // Web: ensure Playwright browser binary is installed.
-                    if (platform === 'android') {
-                        dlog(`Installing Android driver on ${sessionName}`);
-                        await (0, bootstrap_js_1.installDriver)(sessionName);
-                        dlog(`Driver installation complete`);
-                    }
-                    else if (platform === 'web' && !cdpUrl) {
-                        // Only install Playwright browser when launching standalone.
-                        // In CDP mode we attach to the host app's browser (e.g. Electron).
-                        const browser = (0, bootstrap_js_1.webBrowserName)(sessionName);
-                        await (0, bootstrap_js_1.ensurePlaywrightBrowser)(browser, dlog);
-                    }
-                    dlog(`Starting ${platform} driver on port ${driverPort}`);
-                    try {
-                        if (platform === 'ios') {
-                            await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
-                        }
-                        else if (platform === 'tvos') {
-                            // First install — the runner takes foreground; ask it to hand
-                            // focus back to whatever app the user had open.
-                            await (0, bootstrap_js_1.startTvOSDriver)(sessionName, driverPort, /* restoreFocusAfterLaunch */ true);
-                        }
-                        else if (platform === 'web') {
-                            await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog, cdpUrl, cdpTargetId);
-                        }
-                        else {
-                            await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
-                        }
-                        _driverStarted = true;
-                        dlog(`Driver started successfully`);
-                    }
-                    catch (err) {
-                        _driverStartError = err instanceof Error ? err.message : String(err);
-                        dlog(`Driver startup error: ${_driverStartError}`);
-                    }
+                    await startDriverForPlatform(platform);
                 }
                 // Start collecting logs once the driver is (or was already) running.
                 if (_driverStarted) {
@@ -394,6 +355,65 @@ async function main() {
         }
     });
 }
+/**
+ * Bring up the driver process for a non-vega platform. Sets `_driverStarted` /
+ * `_driverStartError`. Extracted so the vega path can skip it entirely.
+ */
+async function startDriverForPlatform(platform) {
+    let driverAlive;
+    if (platform === 'android') {
+        const probe = new android_js_1.AndroidDriver(sessionName, driverPort);
+        await probe.connect();
+        driverAlive = await probe.isAlive().catch(() => false);
+        probe.close();
+    }
+    else {
+        // 'ios', 'tvos', and 'web' all use an HTTP server — port open = alive
+        driverAlive = await (0, bootstrap_js_1.isPortOpen)(driverPort);
+    }
+    if (driverAlive) {
+        _driverStarted = true;
+        dlog(`Driver already running on port ${driverPort}`);
+        return;
+    }
+    // Android: install APKs before starting the driver.
+    // iOS/tvOS: xcodebuild installs silently via DependentProductPaths.
+    // Web: ensure Playwright browser binary is installed.
+    if (platform === 'android') {
+        dlog(`Installing Android driver on ${sessionName}`);
+        await (0, bootstrap_js_1.installDriver)(sessionName);
+        dlog(`Driver installation complete`);
+    }
+    else if (platform === 'web' && !cdpUrl) {
+        // Only install Playwright browser when launching standalone.
+        // In CDP mode we attach to the host app's browser (e.g. Electron).
+        const browser = (0, bootstrap_js_1.webBrowserName)(sessionName);
+        await (0, bootstrap_js_1.ensurePlaywrightBrowser)(browser, dlog);
+    }
+    dlog(`Starting ${platform} driver on port ${driverPort}`);
+    try {
+        if (platform === 'ios') {
+            await (0, bootstrap_js_1.startIOSDriver)(sessionName, driverPort);
+        }
+        else if (platform === 'tvos') {
+            // First install — the runner takes foreground; ask it to hand
+            // focus back to whatever app the user had open.
+            await (0, bootstrap_js_1.startTvOSDriver)(sessionName, driverPort, /* restoreFocusAfterLaunch */ true);
+        }
+        else if (platform === 'web') {
+            await (0, web_server_js_1.startWebServer)(driverPort, (0, bootstrap_js_1.webBrowserName)(sessionName), dlog, cdpUrl, cdpTargetId);
+        }
+        else {
+            await (0, bootstrap_js_1.startAndroidDriver)(sessionName, driverPort);
+        }
+        _driverStarted = true;
+        dlog(`Driver started successfully`);
+    }
+    catch (err) {
+        _driverStartError = err instanceof Error ? err.message : String(err);
+        dlog(`Driver startup error: ${_driverStartError}`);
+    }
+}
 main().catch((err) => {
     console.error('Daemon error:', err);
     process.exit(1);

package/dist/drivers/bootstrap.js

@@ -53,6 +53,11 @@ async function detectPlatform(deviceId) {
         _platformCache.set(deviceId, 'web');
         return 'web';
     }
+    // Vega (Amazon Fire TV): "vega:<serial>" (e.g. "vega:VirtualDevice")
+    if (deviceId === 'vega' || deviceId.startsWith('vega:')) {
+        _platformCache.set(deviceId, 'vega');
+        return 'vega';
+    }
     // Check if it looks like an iOS/tvOS simulator UUID (8-4-4-4-12 hex chars)
     const iosUuidRe = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
     if (iosUuidRe.test(deviceId)) {
@@ -83,6 +88,7 @@ const IOS_BASE_PORT = 1075;
 const TVOS_BASE_PORT = 2075;
 const ANDROID_BASE_PORT = 3763;
 const WEB_BASE_PORT = 4075;
+const VEGA_BASE_PORT = 5075;
 const PORT_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'ports.json');
 const PORT_LOCK = PORT_FILE + '.lock';
 const PORT_LOCK_TIMEOUT_MS = 5000;
@@ -97,6 +103,7 @@ function readPortState() {
             nextTvosPort: TVOS_BASE_PORT,
             nextAndroidPort: ANDROID_BASE_PORT,
             nextWebPort: WEB_BASE_PORT,
+            nextVegaPort: VEGA_BASE_PORT,
         };
     }
 }
@@ -145,6 +152,8 @@ async function getDriverPort(platform, deviceId) {
             state.nextTvosPort = TVOS_BASE_PORT;
         if (state.nextWebPort === undefined)
             state.nextWebPort = WEB_BASE_PORT;
+        if (state.nextVegaPort === undefined)
+            state.nextVegaPort = VEGA_BASE_PORT;
         let port;
         if (platform === 'ios') {
             port = state.nextIosPort++;
@@ -155,6 +164,9 @@ async function getDriverPort(platform, deviceId) {
         else if (platform === 'web') {
             port = state.nextWebPort++;
         }
+        else if (platform === 'vega') {
+            port = state.nextVegaPort++;
+        }
         else {
             port = state.nextAndroidPort++;
         }

package/dist/drivers/cdp-discovery.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CDP_PORTS = void 0;
+exports.httpBase = httpBase;
+exports.fetchCdpTargets = fetchCdpTargets;
+exports.formatCdpDeviceId = formatCdpDeviceId;
+exports.parseCdpDeviceId = parseCdpDeviceId;
+exports.cdpTargetsToDevices = cdpTargetsToDevices;
+exports.discoverCdpDevices = discoverCdpDevices;
+/**
+ * Discovery of externally-launched CDP endpoints (e.g. an Electron app started
+ * with `--remote-debugging-port`, which exposes one page target per webview/tile).
+ *
+ * Unlike the Playwright web driver (which conductor launches itself) these
+ * browsers already exist — so "discovery" means finding the DevTools HTTP
+ * endpoint. CDP servers don't advertise themselves, so we probe a small range of
+ * localhost ports and enumerate each reachable endpoint's page targets via
+ * `/json/list`. The same target-fetch is reused by the `web-targets` command.
+ */
+const http_1 = __importDefault(require("http"));
+/** Default localhost ports scanned for CDP endpoints. Covers Chromium/Electron's
+ *  conventional `--remote-debugging-port` values without a wide scan. */
+exports.DEFAULT_CDP_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
+const PROBE_TIMEOUT_MS = 300;
+/** Derive the `http://host:port` base from a CDP URL (which may be ws:// or include a path). */
+function httpBase(cdpUrl) {
+    const u = new URL(cdpUrl);
+    const proto = u.protocol === 'https:' || u.protocol === 'wss:' ? 'https:' : 'http:';
+    return `${proto}//${u.host}`;
+}
+/** GET a CDP DevTools JSON endpoint, parsing the array response. */
+function getJson(url, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const req = http_1.default.get(url, (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                if ((res.statusCode ?? 0) >= 300) {
+                    reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.setTimeout(timeoutMs, () => req.destroy(new Error(`Timed out fetching ${url}`)));
+        req.on('error', reject);
+    });
+}
+/** Fetch the CDP page targets exposed at `cdpUrl`'s `/json/list`. */
+function fetchCdpTargets(cdpUrl, timeoutMs = 5000) {
+    return getJson(`${httpBase(cdpUrl)}/json/list`, timeoutMs);
+}
+/**
+ * Device-id encoding for a discovered CDP webview: `web:cdp:<port>:<targetId>`.
+ * Self-describing so the id alone hydrates the CDP url + target at bind time —
+ * a discovered webview is drivable with no `--cdp-*` flags. Localhost is assumed
+ * (discovery only scans localhost).
+ */
+function formatCdpDeviceId(port, targetId) {
+    return `web:cdp:${port}:${targetId}`;
+}
+/** Parse a `web:cdp:<port>:<targetId>` device id, or undefined if it isn't one. */
+function parseCdpDeviceId(deviceId) {
+    const m = /^web:cdp:(\d+):(.+)$/.exec(deviceId);
+    if (!m)
+        return undefined;
+    const port = Number(m[1]);
+    if (!Number.isInteger(port) || port <= 0)
+        return undefined;
+    return { port, targetId: m[2], cdpUrl: `http://127.0.0.1:${port}` };
+}
+/** Map a reachable endpoint's page targets to discovered `web` devices. */
+function cdpTargetsToDevices(port, targets) {
+    return targets
+        .filter((t) => t.type === 'page')
+        .map((t) => ({
+        id: formatCdpDeviceId(port, t.id),
+        name: t.title || t.url || t.id,
+        platform: 'web',
+        status: 'running',
+    }));
+}
+/**
+ * Scan localhost CDP ports and return every discovered webview as a device.
+ * Probes run in parallel with a short timeout and swallow all errors — an
+ * unreachable port simply contributes nothing. Safe to call on the hot device-
+ * resolution path.
+ */
+async function discoverCdpDevices(ports = exports.DEFAULT_CDP_PORTS) {
+    const results = await Promise.all(ports.map(async (port) => {
+        try {
+            const targets = await fetchCdpTargets(`http://127.0.0.1:${port}`, PROBE_TIMEOUT_MS);
+            return cdpTargetsToDevices(port, targets);
+        }
+        catch {
+            return [];
+        }
+    }));
+    return results.flat();
+}