@houwert/conductor 0.21.0 → 0.23.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

@@ -0,0 +1,84 @@
+"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;
+/**
+ * List the CDP page targets exposed by an external browser (e.g. an Electron app
+ * launched with `--remote-debugging-port`). Each target is a controllable page —
+ * for the Lightning emulator, one per tile plus its control/remote chrome.
+ *
+ * Reads the DevTools HTTP endpoint (`/json/list`) directly, so it needs no
+ * 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);
+    });
+}
+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' +
+            'Launch the browser/Electron app with --remote-debugging-port to expose it.');
+        return 1;
+    }
+    let targets;
+    try {
+        targets = await fetchTargets(cdpUrl);
+    }
+    catch (err) {
+        console.error(`Could not reach CDP endpoint at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    // Only type="page" targets are controllable as Playwright Pages.
+    const pages = targets.filter((t) => t.type === 'page');
+    if (opts.json) {
+        (0, output_js_1.printData)(pages.map((t) => ({ id: t.id, title: t.title, url: t.url })), opts);
+        return 0;
+    }
+    if (pages.length === 0) {
+        console.log('No page targets found. Is the app loaded and started with --remote-debugging-port?');
+        return 0;
+    }
+    console.log(`Found ${pages.length} page target(s) at ${cdpUrl}:\n`);
+    pages.forEach((t, i) => {
+        console.log(`  [${i}] ${t.title || '(untitled)'}`);
+        console.log(`      url:    ${t.url}`);
+        console.log(`      target: ${t.id}`);
+        console.log(`      bind:   conductor --device web:chromium:t${i} --cdp-url ${cdpUrl} --cdp-target ${t.id} inspect`);
+        console.log('');
+    });
+    console.log('Bind a session to a target once (any command), then drop the --cdp-* flags on later\n' +
+        'commands for that --device — the attachment is remembered per session.');
+    return 0;
+}
+exports.HELP = '  web-targets --cdp-url <url>          List controllable CDP page targets (one per Electron webview/tile)';

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/flow-runner.js

@@ -17,6 +17,7 @@ const js_yaml_1 = __importDefault(require("js-yaml"));
 const ios_js_1 = require("./ios.js");
 const android_js_1 = require("./android.js");
 const web_js_1 = require("./web.js");
+const vega_js_1 = require("./vega.js");
 const wait_js_1 = require("./wait.js");
 const direct_ios_selector_js_1 = require("./direct-ios-selector.js");
 const perf_hooks_1 = require("perf_hooks");
@@ -25,6 +26,20 @@ const utils_js_1 = require("../utils.js");
 function fmtMs(ms) {
     return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
 }
+// vega (Amazon Fire TV) remote key names → VegaDriver button values, for flow pressKey.
+const VEGA_FLOW_BUTTONS = {
+    BACK: 'back',
+    HOME: 'home',
+    'REMOTE DPAD UP': 'up',
+    'REMOTE DPAD DOWN': 'down',
+    'REMOTE DPAD LEFT': 'left',
+    'REMOTE DPAD RIGHT': 'right',
+    'REMOTE DPAD CENTER': 'select',
+    ENTER: 'select',
+    RETURN: 'select',
+    VOLUME_UP: 'volumeUp',
+    VOLUME_DOWN: 'volumeDown',
+};
 function toElementSelector(sel) {
     // A bare string matches text OR id (Maestro's query semantics).
     // Only object form with explicit `text:` or `id:` keys forces one field.
@@ -507,7 +522,13 @@ async function executeCommand(cmd, driver, opts) {
     }
 }
 function getConductorObj(driver, output) {
-    const platform = driver instanceof ios_js_1.IOSDriver ? 'ios' : driver instanceof web_js_1.WebDriver ? 'web' : 'android';
+    const platform = driver instanceof ios_js_1.IOSDriver
+        ? 'ios'
+        : driver instanceof web_js_1.WebDriver
+            ? 'web'
+            : driver instanceof vega_js_1.VegaDriver
+                ? 'vega'
+                : 'android';
     return {
         platform,
         copiedText: output['__copiedText'] ?? '',
@@ -634,16 +655,14 @@ async function executeCommandBody(key, val, driver, opts) {
             const n = typeof val === 'number'
                 ? val
                 : (val?.charactersToErase ?? 50);
-            if (driver instanceof android_js_1.AndroidDriver) {
-                await driver.eraseAllText(n);
-            }
-            else if (driver instanceof web_js_1.WebDriver) {
-                await driver.eraseAllText(n);
-            }
-            else {
+            if (driver instanceof ios_js_1.IOSDriver) {
                 for (let i = 0; i < n; i++)
                     await driver.pressKey('delete');
             }
+            else {
+                // Android, web, and vega all expose eraseAllText.
+                await driver.eraseAllText(n);
+            }
             break;
         }
         case 'inputRandomText': {
@@ -782,6 +801,8 @@ async function executeCommandBody(key, val, driver, opts) {
                 await driver.back();
             else if (driver instanceof web_js_1.WebDriver)
                 await driver.goBack();
+            else if (driver instanceof vega_js_1.VegaDriver)
+                await driver.back();
             // iOS has no hardware back button — noop
             break;
         }
@@ -1055,6 +1076,12 @@ async function executeCommandBody(key, val, driver, opts) {
                 };
                 await driver.pressKey(WEB_KEY_MAP[keyName] ?? keyName);
             }
+            else if (driver instanceof vega_js_1.VegaDriver) {
+                const button = VEGA_FLOW_BUTTONS[keyName];
+                if (!button)
+                    throw new Error(`pressKey: key "${val}" is not supported on vega`);
+                await driver.pressButton(button);
+            }
             else {
                 const keycode = ANDROID_KEYCODES[keyName];
                 if (keycode === undefined)
@@ -1072,6 +1099,9 @@ async function executeCommandBody(key, val, driver, opts) {
             else if (driver instanceof web_js_1.WebDriver) {
                 // No virtual keyboard on web — noop
             }
+            else if (driver instanceof vega_js_1.VegaDriver) {
+                // No reliable keyboard-hide primitive on vega — noop
+            }
             else {
                 await driver.pressKeyEvent(111); // KEYCODE_ESCAPE
             }