@houwert/conductor 0.23.0 → 0.24.1

package/dist/commands/list-devices.js

@@ -16,6 +16,7 @@ const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const client_js_1 = require("../daemon/client.js");
 const protocol_js_1 = require("../daemon/protocol.js");
 const cli_js_1 = require("../drivers/vega/cli.js");
+const cdp_discovery_js_1 = require("../drivers/cdp-discovery.js");
 // Captured during discoverAvailableDevices so listDevices() can report it.
 // Module-scoped because the discover function returns Device[]; bolting an
 // extra return field onto the public type would ripple beyond this fix.
@@ -104,6 +105,9 @@ async function discoverBootedDevices() {
     catch {
         /* vega CLI not installed */
     }
+    // External CDP endpoints (e.g. an Electron app started with
+    // --remote-debugging-port): one device per discovered webview/tile.
+    devices.push(...(await (0, cdp_discovery_js_1.discoverCdpDevices)()));
     return devices;
 }
 async function discoverAvailableDevices() {

package/dist/commands/start-device.js

@@ -8,6 +8,7 @@ exports.pickAndroidArch = pickAndroidArch;
 exports.parseInstalledSystemImages = parseInstalledSystemImages;
 exports.pickSystemImage = pickSystemImage;
 exports.buildAvdmanagerCreateArgs = buildAvdmanagerCreateArgs;
+exports.raiseAvdConfigRam = raiseAvdConfigRam;
 exports.startDevice = startDevice;
 exports.HELP = `  start-device
     --platform <ios|android|tvos|web|vega> Boot a simulator/emulator, start the web driver (Playwright), or boot/attach a Vega VVD
@@ -16,10 +17,14 @@ exports.HELP = `  start-device
     --name <name>                     Set a custom name on the device after creation (iOS/tvOS/web)
     --device-type <name>              iOS/tvOS device type (e.g. "iPhone 16 Pro", "Apple TV 4K") or
                                       Android device profile (e.g. "pixel_7"); creates if needed
+    --memory <mb>                     Android only: RAM (MB) for a newly-created AVD (default: 4096).
+                                      Only raises; applied at creation time, never to an existing AVD
     --system-image <id>               Android only: override auto-picked system image
                                       (e.g. "system-images;android-34;google_apis;arm64-v8a")
     --browser <chromium|firefox|webkit> Web only: which Playwright browser to launch (default: chromium)`;
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const runner_js_1 = require("../runner.js");
 const sdk_js_1 = require("../android/sdk.js");
@@ -32,6 +37,10 @@ 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;
+// Stock TV device profiles default to 1024MB RAM, which OOM-kills heavy RN debug
+// builds during JS bundle load. Raise freshly-created AVDs to this floor.
+const ANDROID_AVD_RAM_FLOOR_MB = 4096;
+const ANDROID_AVD_HEAP_MB = 512;
 async function listIOSSimulators() {
     const result = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'list', 'devices', '--json']);
     if (!result.success)
@@ -496,6 +505,38 @@ function pickSystemImage(installed, apiLevel, arch) {
 function buildAvdmanagerCreateArgs(avdName, systemImage, deviceProfile) {
     return ['create', 'avd', '-n', avdName, '-k', systemImage, '-d', deviceProfile];
 }
+/** Parse a config.ini RAM value; only plain integer MB counts — `M`-suffixed or bogus values are 0. */
+function parsePlainMb(value) {
+    const m = /^(\d+)$/.exec(value.trim());
+    return m ? parseInt(m[1], 10) : 0;
+}
+/**
+ * Rewrite an AVD `config.ini` to raise `hw.ramSize`/`vm.heapSize` to the given floors.
+ * Pure and exported for tests. Values are written as plain integer MB — an `M` suffix
+ * makes the emulator silently fall back to 1024MB. Only ever raises; higher existing
+ * values are kept, and non-integer/`M`-suffixed existing values are treated as 0 so they
+ * get overwritten. Missing keys are appended; all other lines/ordering are preserved.
+ */
+function raiseAvdConfigRam(configIni, targetRamMb, heapMb = ANDROID_AVD_HEAP_MB) {
+    const raiseKey = (contents, key, target) => {
+        const lines = contents.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const m = /^(\s*)([^=\s]+)(\s*=\s*)(.*)$/.exec(lines[i]);
+            if (!m || m[2] !== key)
+                continue;
+            const next = Math.max(parsePlainMb(m[4]), target);
+            lines[i] = `${m[1]}${key}${m[3]}${next}`;
+            return lines.join('\n');
+        }
+        let out = contents;
+        if (out.length > 0 && !out.endsWith('\n'))
+            out += '\n';
+        return `${out}${key} = ${target}\n`;
+    };
+    let result = raiseKey(configIni, 'hw.ramSize', targetRamMb);
+    result = raiseKey(result, 'vm.heapSize', heapMb);
+    return result;
+}
 async function listInstalledSystemImages() {
     const result = await (0, runner_js_1.spawnCommand)('sdkmanager', ['--list_installed']);
     if (!result.success) {
@@ -524,7 +565,7 @@ async function spawnAvdmanagerCreate(args) {
         proc.stdin.end('no\n');
     });
 }
-async function createAndroidAVD(avdName, deviceProfile, apiLevel, systemImageOverride) {
+async function createAndroidAVD(avdName, deviceProfile, apiLevel, systemImageOverride, targetRamMb) {
     const arch = pickAndroidArch();
     let systemImage;
     if (systemImageOverride) {
@@ -562,6 +603,22 @@ async function createAndroidAVD(avdName, deviceProfile, apiLevel, systemImageOve
     if (!avds.includes(avdName)) {
         throw new Error(`AVD "${avdName}" was not registered after creation (not in emulator -list-avds).`);
     }
+    // Raise RAM above the stock profile default so heavy RN debug builds aren't OOM-killed.
+    const avdHome = process.env.ANDROID_AVD_HOME || path_1.default.join(os_1.default.homedir(), '.android', 'avd');
+    const configPath = path_1.default.join(avdHome, `${avdName}.avd`, 'config.ini');
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            const current = fs_1.default.readFileSync(configPath, 'utf-8');
+            fs_1.default.writeFileSync(configPath, raiseAvdConfigRam(current, targetRamMb), 'utf-8');
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.warn(`Warning: could not raise RAM for AVD "${avdName}" (${msg}). Continuing.`);
+        }
+    }
+    else {
+        console.warn(`Warning: config.ini not found for AVD "${avdName}" at ${configPath}. Continuing.`);
+    }
 }
 async function waitForAndroidBoot(avdName) {
     const deadline = Date.now() + ANDROID_BOOT_TIMEOUT_MS;
@@ -596,7 +653,7 @@ async function waitForAndroidBoot(avdName) {
     }
     throw new Error(`Android emulator (${avdName}) did not appear within ${ANDROID_BOOT_TIMEOUT_MS / 1000}s`);
 }
-async function startAndroid(avdName, opts, deviceType, osVersion, systemImage) {
+async function startAndroid(avdName, opts, deviceType, osVersion, systemImage, memory) {
     let avds;
     try {
         avds = await listAVDs();
@@ -616,8 +673,9 @@ async function startAndroid(avdName, opts, deviceType, osVersion, systemImage) {
             return 1;
         }
         console.log(`No AVD "${avdName}" found. Creating one with device profile "${deviceType}"...`);
+        const targetRamMb = memory && memory > 0 ? memory : ANDROID_AVD_RAM_FLOOR_MB;
         try {
-            await createAndroidAVD(avdName, deviceType, osVersion, systemImage);
+            await createAndroidAVD(avdName, deviceType, osVersion, systemImage, targetRamMb);
         }
         catch (e) {
             (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);
@@ -761,7 +819,7 @@ async function startDevice(platform, opts, flags) {
         case 'tvos':
             return startTvOS(flags.osVersion, opts, flags.name, flags.deviceType);
         case 'android':
-            return startAndroid(flags.avd, opts, flags.deviceType, flags.osVersion, flags.systemImage);
+            return startAndroid(flags.avd, opts, flags.deviceType, flags.osVersion, flags.systemImage, flags.memory);
         case 'web':
             return startWebDriver(opts, flags.browser, flags.name);
         case 'vega':

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/daemon/web-server.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAriaSnapshot = parseAriaSnapshot;
+exports.mergeCanvasNodes = mergeCanvasNodes;
 exports.startWebServer = startWebServer;
 exports.stopWebServer = stopWebServer;
 exports.getCdpPort = getCdpPort;
@@ -225,11 +226,22 @@ async function resolveBoundingBoxes(page, elements) {
         const el = queue.shift();
         if (el.ref) {
             try {
-                const locator = page.locator(`aria-ref=${el.ref}`);
-                const box = await locator.boundingBox({ timeout: 750 });
-                if (box && box.width > 0 && box.height > 0) {
-                    el.bounds = { x: box.x, y: box.y, width: box.width, height: box.height };
+                // One round-trip per ref for bounds + the element's own `data-testid`. Reading identity
+                // from the element itself (not by geometric overlap) is what lets canvas focus later be
+                // joined to the right node by identity — see mergeCanvasNodes.
+                const info = (await page
+                    .locator(`aria-ref=${el.ref}`)
+                    .first()
+                    .evaluate(`(node) => {
+              const r = node.getBoundingClientRect();
+              return { x: r.x, y: r.y, width: r.width, height: r.height,
+                       testId: node.getAttribute('data-testid') || '' };
+            }`, undefined, { timeout: 750 }));
+                if (info.width > 0 && info.height > 0) {
+                    el.bounds = { x: info.x, y: info.y, width: info.width, height: info.height };
                 }
+                if (info.testId)
+                    el.testId = info.testId;
             }
             catch {
                 // Element not visible or locator failed — skip
@@ -469,44 +481,56 @@ async function stampFocusFromDocumentActiveElement(page, elements) {
         rectPick.best.focused = true;
     }
 }
-/** IoU + center-inside score of a candidate node's bounds against a mirror rect. */
-function overlapScore(bounds, m) {
-    const x1 = Math.max(m.x, bounds.x);
-    const y1 = Math.max(m.y, bounds.y);
-    const x2 = Math.min(m.x + m.width, bounds.x + bounds.width);
-    const y2 = Math.min(m.y + m.height, bounds.y + bounds.height);
-    const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
-    if (inter <= 0)
-        return 0;
-    const union = m.width * m.height + bounds.width * bounds.height - inter;
-    const iou = union > 0 ? inter / union : 0;
-    const mcx = m.x + m.width / 2;
-    const mcy = m.y + m.height / 2;
-    const centerInside = mcx >= bounds.x &&
-        mcx <= bounds.x + bounds.width &&
-        mcy >= bounds.y &&
-        mcy <= bounds.y + bounds.height;
-    return centerInside ? iou + 1 : iou;
-}
-/** Find the existing tree node whose bounds best overlap a mirror rect (>0.5 score). */
-function bestOverlappingNode(elements, m) {
-    let best = null;
-    let bestScore = 0.5;
-    const walk = (els) => {
+/**
+ * Merge canvas scene-graph nodes into the ARIA tree by identity (`data-testid`), never by
+ * geometry. A mirror node that shares a testId with an existing (natively-read) tree node
+ * enriches it and, authoritatively, carries its `data-focused` state onto it. Mirror nodes with
+ * no counterpart (canvas-only / off-screen scene nodes) are appended as their own nodes.
+ *
+ * Because focus rides identity — not bounds — an open drawer overlapping a focused tile can no
+ * longer steal the tile's focus, and a tile's identity can't smear onto a neighbour it happens
+ * to overlap.
+ */
+function mergeCanvasNodes(elements, mirror) {
+    const byTestId = new Map();
+    const index = (els) => {
         for (const el of els) {
-            if (el.bounds) {
-                const s = overlapScore(el.bounds, m);
-                if (s > bestScore) {
-                    bestScore = s;
-                    best = el;
-                }
-            }
+            if (el.testId)
+                byTestId.set(el.testId, el);
             if (el.children)
-                walk(el.children);
+                index(el.children);
         }
     };
-    walk(elements);
-    return best;
+    index(elements);
+    for (const m of mirror) {
+        const bounds = m.width > 0 && m.height > 0
+            ? { x: m.x, y: m.y, width: m.width, height: m.height }
+            : undefined;
+        const existing = m.testId ? byTestId.get(m.testId) : undefined;
+        if (existing) {
+            if (m.focused)
+                existing.focused = true;
+            if (!existing.name && m.name)
+                existing.name = m.name;
+            if (bounds && !existing.bounds)
+                existing.bounds = bounds;
+        }
+        else {
+            const node = {
+                role: m.role,
+                name: m.name,
+                ref: '',
+                testId: m.testId || undefined,
+                bounds,
+                enabled: !m.disabled,
+                focused: m.focused,
+                children: [],
+            };
+            elements.push(node);
+            if (m.testId)
+                byTestId.set(m.testId, node);
+        }
+    }
 }
 /**
  * Harvest a canvas DOM-inspector mirror into the hierarchy. Canvas webtv frameworks
@@ -514,10 +538,11 @@ function bestOverlappingNode(elements, m) {
  * off-screen `<div>`s carrying `data-testid` (real identity) and `data-focused="true"` (focus
  * — the canvas owns `document.activeElement`, so the normal focus path can't see it).
  *
- * Each mirror node is matched to an existing ARIA node by bounds overlap and used to enrich it
- * (testId + focus); unmatched mirror nodes are appended as new nodes. Mirror rects come from
- * `getBoundingClientRect`, i.e. the same viewport-CSS-pixel space taps use — drive TV apps at
- * the app's native resolution (e.g. `set-viewport 1920 1080`) so lower nodes aren't off-screen.
+ * Nodes are joined to the ARIA tree by identity (see mergeCanvasNodes); canvas-only nodes are
+ * appended. Mirror rects come from `getBoundingClientRect`, i.e. the same viewport-CSS-pixel
+ * space taps use — drive TV apps at the app's native resolution (e.g. `set-viewport 1920 1080`)
+ * so lower scene nodes aren't off-screen. Returns true when a mirror was present (a canvas app),
+ * so the caller can skip the DOM `activeElement` focus fallback.
  */
 async function harvestDomMirror(page, elements) {
     let mirror = null;
@@ -541,40 +566,12 @@ async function harvestDomMirror(page, elements) {
     })()`));
     }
     catch {
-        return;
+        return false;
     }
     if (!mirror || mirror.length === 0)
-        return;
-    // data-focused is authoritative for canvas apps (activeElement is the <canvas>, never the
-    // focused scene node), so clear any focus already inferred from the ARIA snapshot.
-    if (mirror.some((m) => m.focused))
-        clearFocusedFlags(elements);
-    for (const m of mirror) {
-        const bounds = m.width > 0 && m.height > 0
-            ? { x: m.x, y: m.y, width: m.width, height: m.height }
-            : undefined;
-        const target = bounds ? bestOverlappingNode(elements, m) : null;
-        if (target) {
-            if (m.testId)
-                target.testId = m.testId;
-            if (m.focused)
-                target.focused = true;
-            if (!target.name && m.name)
-                target.name = m.name;
-        }
-        else {
-            elements.push({
-                role: m.role,
-                name: m.name,
-                ref: '',
-                testId: m.testId || undefined,
-                bounds,
-                enabled: !m.disabled,
-                focused: m.focused,
-                children: [],
-            });
-        }
-    }
+        return false;
+    mergeCanvasNodes(elements, mirror);
+    return true;
 }
 // ── Web server ───────────────────────────────────────────────────────────────
 const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
@@ -983,12 +980,16 @@ async function handleRequest(req, res, dlog) {
                 await resolveBoundingBoxes(p, elements);
                 await resolveBoundingBoxesBatch(p, elements);
                 await resolveBoundingBoxesByRole(p, elements);
+                // Focus source depends on the app, and the two are mutually exclusive:
+                //  • Canvas/inspector apps (Lightning/WPE) own document.activeElement on the <canvas>,
+                //    so focus lives on scene nodes as `data-focused` — merged by identity.
+                //  • Plain DOM apps expose focus via ARIA `[active]` / document.activeElement.
                 clearFocusedFlags(elements);
-                applyFocusFromAriaSnapshotYaml(ariaSnapshot, elements);
-                // Canvas webtv: merge the data-testid/data-focused mirror before falling back to
-                // document.activeElement (which is the <canvas>, not the focused scene node).
-                await harvestDomMirror(p, elements);
-                await stampFocusFromDocumentActiveElement(p, elements);
+                const isCanvasApp = await harvestDomMirror(p, elements);
+                if (!isCanvasApp) {
+                    applyFocusFromAriaSnapshotYaml(ariaSnapshot, elements);
+                    await stampFocusFromDocumentActiveElement(p, elements);
+                }
                 jsonResponse(res, {
                     url: p.url(),
                     title: await p.title(),

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();
+}

package/dist/index.js

@@ -64,6 +64,7 @@ const options_js_1 = require("./commands/options.js");
 const web_targets_js_1 = require("./commands/web-targets.js");
 const session_js_2 = require("./session.js");
 const device_picker_js_1 = require("./device-picker.js");
+const cdp_discovery_js_1 = require("./drivers/cdp-discovery.js");
 const update_check_js_1 = require("./update-check.js");
 const pkg_root_js_1 = require("./pkg-root.js");
 const fs_1 = __importDefault(require("fs"));
@@ -326,6 +327,9 @@ async function main() {
     if (isWebSession && !NO_DEVICE_COMMANDS.has(command)) {
         const cdpUrlFlag = argv['cdp-url'];
         const cdpTargetFlag = argv['cdp-target'];
+        // A discovered `web:cdp:<port>:<target>` device id is self-describing —
+        // derive the CDP url/target from it so it's drivable with no --cdp-* flags.
+        const fromDeviceId = (0, cdp_discovery_js_1.parseCdpDeviceId)(sessionName);
         if (cdpUrlFlag || cdpTargetFlag) {
             if (cdpUrlFlag)
                 process.env.CONDUCTOR_CDP_URL = cdpUrlFlag;
@@ -336,6 +340,13 @@ async function main() {
                 cdpTargetId: process.env.CONDUCTOR_CDP_TARGET_ID,
             }, sessionName);
         }
+        else if (fromDeviceId) {
+            if (!process.env.CONDUCTOR_CDP_URL)
+                process.env.CONDUCTOR_CDP_URL = fromDeviceId.cdpUrl;
+            if (!process.env.CONDUCTOR_CDP_TARGET_ID) {
+                process.env.CONDUCTOR_CDP_TARGET_ID = fromDeviceId.targetId;
+            }
+        }
         else {
             const saved = await (0, session_js_2.getSession)(sessionName);
             if (saved.cdpUrl && !process.env.CONDUCTOR_CDP_URL) {
@@ -359,6 +370,7 @@ async function main() {
                 deviceType: argv['device-type'],
                 systemImage: argv['system-image'],
                 browser: argv['browser'],
+                memory: argv['memory'] !== undefined ? Number(argv['memory']) : undefined,
             });
             break;
         case 'list-devices':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

package/skills/conductor-device-setup/SKILL.md

@@ -23,6 +23,7 @@ conductor list-apps          # installed app ids / package names
 | --------------------------------------------------------------------- | -------------------------------------------------------------------------- |
 | `conductor start-device --platform <ios\|android\|tvos\|web\|vega>`   | Boot a simulator/emulator, start the web driver, or attach to a Vega VVD    |
 | `conductor start-device --os-version <n> --device-type <name>`        | Pick OS version + device type (creates if needed)                          |
+| `conductor start-device --platform android --avd <name> --device-type <profile> --memory <mb>` | Create an Android AVD with a RAM floor (default 4096MB; only raises, creation-time only) |
 | `conductor stop-device [<name-or-id>] [--all]`                        | Shut down device(s)                                                        |
 | `conductor delete-device <name-or-id> [--all]`                        | Delete simulator(s)/AVD(s)/web session(s)                                  |
 | `conductor set-location --lat <n> --lng <n>`                          | Set GPS coordinates                                                        |
@@ -47,6 +48,13 @@ Use a distinct fully-qualified `--device web:chromium:<label>` per target (a bar
 several webviews can be driven concurrently. Only `type=page` targets are
 controllable. See [Web testing → Attaching to an existing browser](../../../docs/web.md).
 
+**Discovery:** endpoints on the conventional debugging ports (9222–9229 on
+localhost) are found automatically — `list-devices` shows each webview as a
+booted `web:cdp:<port>:<targetId>` device. That id is self-describing, so you can
+drive it directly (`conductor --device web:cdp:9222:<targetId> <cmd>`) without
+`--cdp-url`/`--cdp-target`. Use `web-targets --cdp-url <url>` for endpoints on a
+non-default port, or to list targets before binding.
+
 ### Vega (Amazon Fire TV)
 
 Vega is a React Native OS driven through Amazon's own `vega`/`kepler` CLI (not