@houwert/conductor 0.24.0 → 0.24.1

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/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/index.js

@@ -370,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.24.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                                                        |