@houwert/conductor 0.13.0 → 0.14.0

package/dist/commands/run-parallel.js

@@ -21,6 +21,7 @@ exports.HELP = `  run-parallel --flows-dir <path>     Run flows in parallel acro
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const sdk_js_1 = require("../android/sdk.js");
 const output_js_1 = require("../output.js");
 async function runParallel(flowsDir, opts = {}) {
     if (!flowsDir) {
@@ -107,7 +108,7 @@ async function runShard(deviceId, flowFile) {
 async function discoverAllDevices() {
     const devices = [];
     try {
-        const out = await spawnCapture('adb', ['devices']);
+        const out = await spawnCapture((0, sdk_js_1.resolveAndroidTool)('adb'), ['devices']);
         for (const line of out.split('\n').slice(1)) {
             const id = line.trim().split(/\s+/)[0];
             if (id && !line.includes('offline') && id !== '')

package/dist/commands/start-device.js

@@ -15,6 +15,7 @@ exports.HELP = `  start-device
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const runner_js_1 = require("../runner.js");
+const sdk_js_1 = require("../android/sdk.js");
 const client_js_1 = require("../daemon/client.js");
 const protocol_js_1 = require("../daemon/protocol.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
@@ -390,7 +391,9 @@ async function startTvOS(osVersion, opts, name, deviceType) {
 }
 // ── Android ───────────────────────────────────────────────────────────────────
 async function listAVDs() {
-    const result = await (0, runner_js_1.spawnCommand)('emulator', ['-list-avds']);
+    const result = await (0, runner_js_1.spawnCommand)((0, sdk_js_1.resolveAndroidTool)('emulator'), ['-list-avds'], {
+        env: (0, sdk_js_1.androidSpawnEnv)(),
+    });
     if (!result.success)
         throw new Error(`emulator -list-avds failed: ${result.stderr}`);
     return result.stdout
@@ -402,7 +405,9 @@ async function waitForAndroidBoot(avdName) {
     const deadline = Date.now() + ANDROID_BOOT_TIMEOUT_MS;
     const connectedBefore = new Set();
     // Snapshot currently connected devices so we can identify the new one
-    const before = await (0, runner_js_1.spawnCommand)('adb', ['devices']);
+    const before = await (0, runner_js_1.spawnCommand)((0, sdk_js_1.resolveAndroidTool)('adb'), ['devices'], {
+        env: (0, sdk_js_1.androidSpawnEnv)(),
+    });
     for (const line of before.stdout.split('\n').slice(1)) {
         const id = line.trim().split(/\s+/)[0];
         if (id)
@@ -410,7 +415,9 @@ async function waitForAndroidBoot(avdName) {
     }
     while (Date.now() < deadline) {
         await (0, utils_js_1.sleep)(POLL_MS);
-        const result = await (0, runner_js_1.spawnCommand)('adb', ['devices']);
+        const result = await (0, runner_js_1.spawnCommand)((0, sdk_js_1.resolveAndroidTool)('adb'), ['devices'], {
+            env: (0, sdk_js_1.androidSpawnEnv)(),
+        });
         if (!result.success)
             continue;
         for (const line of result.stdout.split('\n').slice(1)) {
@@ -419,13 +426,7 @@ async function waitForAndroidBoot(avdName) {
             const status = parts[1];
             if (id && status === 'device' && !connectedBefore.has(id)) {
                 // Check boot completed
-                const boot = await (0, runner_js_1.spawnCommand)('adb', [
-                    '-s',
-                    id,
-                    'shell',
-                    'getprop',
-                    'sys.boot_completed',
-                ]);
+                const boot = await (0, runner_js_1.spawnCommand)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', id, 'shell', 'getprop', 'sys.boot_completed'], { env: (0, sdk_js_1.androidSpawnEnv)() });
                 if (boot.stdout.trim() === '1')
                     return id;
             }
@@ -452,10 +453,7 @@ async function startAndroid(avdName, opts) {
         return 1;
     }
     console.log(`Launching emulator: ${target}...`);
-    const proc = (0, child_process_1.spawn)('emulator', ['-avd', target, '-netdelay', 'none', '-netspeed', 'full'], {
-        detached: true,
-        stdio: 'ignore',
-    });
+    const proc = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('emulator'), ['-avd', target, '-netdelay', 'none', '-netspeed', 'full'], { detached: true, stdio: 'ignore', env: (0, sdk_js_1.androidSpawnEnv)() });
     proc.unref();
     let deviceId;
     try {

package/dist/commands/stop-device.js

@@ -6,6 +6,7 @@ exports.HELP = `  stop-device [<name-or-id>]
     --platform <ios|tvos|android|web> 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");
 const output_js_1 = require("../output.js");
 const client_js_1 = require("../daemon/client.js");
 const list_devices_js_1 = require("./list-devices.js");
@@ -18,7 +19,7 @@ async function shutdownSimulator(udid) {
 }
 // ── Android ──────────────────────────────────────────────────────────────────
 async function killEmulator(serial) {
-    const result = await (0, runner_js_1.spawnCommand)('adb', ['-s', serial, 'emu', 'kill']);
+    const result = await (0, runner_js_1.spawnCommand)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', serial, 'emu', 'kill']);
     if (!result.success) {
         throw new Error(`Failed to kill emulator ${serial}: ${result.stderr.trim()}`);
     }

package/dist/daemon/server.js

@@ -19,6 +19,7 @@ const url_1 = __importDefault(require("url"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const protocol_js_1 = require("./protocol.js");
+const sdk_js_1 = require("../android/sdk.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const android_js_1 = require("../drivers/android.js");
 const web_server_js_1 = require("./web-server.js");
@@ -129,6 +130,7 @@ async function ensureDriverRunning() {
 }
 // ── Daemon main ──────────────────────────────────────────────────────────────
 async function main() {
+    (0, sdk_js_1.ensureAndroidEnv)();
     // Ensure per-session daemon directory exists
     fs_1.default.mkdirSync(path_1.default.dirname(PID_FILE), { recursive: true });
     fs_1.default.writeFileSync(PID_FILE, String(process.pid));

package/dist/daemon/web-server.js

@@ -868,6 +868,44 @@ async function handleRequest(req, res, dlog) {
                 }
                 return;
             }
+            case '/heapSnapshot': {
+                // V8 heap snapshot via CDP. The snapshot streams as JSON chunks via
+                // `HeapProfiler.addHeapSnapshotChunk` events; we concatenate them and
+                // return the assembled JSON. Snapshots are large (10-100+ MB on real
+                // pages) — fine over localhost HTTP.
+                const p = await getPage(dlog);
+                const session = await p.context().newCDPSession(p);
+                const chunks = [];
+                const onChunk = (e) => {
+                    chunks.push(e.chunk);
+                };
+                try {
+                    await session.send('HeapProfiler.enable').catch(() => { });
+                    // Optional: collect garbage before snapshotting so transient
+                    // allocations don't muddy diff comparisons. Triggered via ?gc=1.
+                    if (parsedUrl.query['gc']) {
+                        await session.send('HeapProfiler.collectGarbage').catch(() => { });
+                    }
+                    session.on('HeapProfiler.addHeapSnapshotChunk', onChunk);
+                    await session.send('HeapProfiler.takeHeapSnapshot', {
+                        reportProgress: false,
+                        captureNumericValue: false,
+                        exposeInternals: false,
+                    });
+                    // Each chunk is already JSON text; concatenation yields the full snapshot JSON.
+                    const body = chunks.join('');
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(body),
+                    });
+                    res.end(body);
+                }
+                finally {
+                    session.off('HeapProfiler.addHeapSnapshotChunk', onChunk);
+                    await session.detach().catch(() => { });
+                }
+                return;
+            }
             case '/consoleLogs': {
                 const since = parsedUrl.query['since'] ?? '';
                 const entries = since

package/dist/drivers/android.js

@@ -50,6 +50,7 @@ const protoLoader = __importStar(require("@grpc/proto-loader"));
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const sdk_js_1 = require("../android/sdk.js");
 // __dirname is available in CommonJS — points to dist/drivers/
 const PROTO_PATH = path_1.default.join(__dirname, '../../proto/conductor_android.proto');
 let _packageDef = null;
@@ -148,7 +149,9 @@ class AndroidDriver {
     // ── ADB-shell operations (not in gRPC proto) ─────────────────────────────
     adb(args) {
         return new Promise((resolve, reject) => {
-            const proc = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, ...args], { stdio: 'ignore' });
+            const proc = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', this.deviceId, ...args], {
+                stdio: 'ignore',
+            });
             proc.on('close', (code) => {
                 if (code === 0)
                     resolve();
@@ -182,7 +185,7 @@ class AndroidDriver {
     }
     adbOutput(args) {
         return new Promise((resolve, reject) => {
-            const proc = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, ...args], {
+            const proc = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', this.deviceId, ...args], {
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
             let stdout = '';
@@ -326,7 +329,7 @@ class AndroidDriver {
         if (this._recordingProcess)
             await this.stopRecording();
         this._recordingOutputPath = outputPath;
-        this._recordingProcess = (0, child_process_1.spawn)('adb', ['-s', this.deviceId, 'shell', 'screenrecord', '/sdcard/conductor_recording.mp4'], { stdio: 'ignore' });
+        this._recordingProcess = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', this.deviceId, 'shell', 'screenrecord', '/sdcard/conductor_recording.mp4'], { stdio: 'ignore' });
     }
     async stopRecording() {
         if (this._recordingProcess) {

package/dist/drivers/bootstrap.js

@@ -42,6 +42,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const verbose_js_1 = require("../verbose.js");
 const utils_js_1 = require("../utils.js");
+const sdk_js_1 = require("../android/sdk.js");
 /** Cache: deviceId → platform */
 const _platformCache = new Map();
 async function detectPlatform(deviceId) {
@@ -353,8 +354,24 @@ async function installDriver(deviceId) {
         throw new Error(`Conductor driver APKs not found at ${path_1.default.join(driversDir, 'android')}.\n` +
             `Run 'make package-cli' from the repo root to build and bundle the drivers.`);
     }
-    await spawnAndWait('adb', ['-s', deviceId, 'install', '-r', '-t', '-g', appApk]);
-    await spawnAndWait('adb', ['-s', deviceId, 'install', '-r', '-t', '-g', serverApk]);
+    await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+        '-s',
+        deviceId,
+        'install',
+        '-r',
+        '-t',
+        '-g',
+        appApk,
+    ]);
+    await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+        '-s',
+        deviceId,
+        'install',
+        '-r',
+        '-t',
+        '-g',
+        serverApk,
+    ]);
     (0, verbose_js_1.log)(`installDriver: done`);
 }
 // ── iOS bootstrap ─────────────────────────────────────────────────────────────
@@ -598,9 +615,15 @@ async function startAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
     }
     (0, verbose_js_1.log)(`Starting Android driver for device ${deviceId} on port ${port}`);
     // Step 1: ADB port forward
-    await spawnAndWait('adb', ['-s', deviceId, 'forward', `tcp:${port}`, `tcp:${port}`]);
+    await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+        '-s',
+        deviceId,
+        'forward',
+        `tcp:${port}`,
+        `tcp:${port}`,
+    ]);
     // Step 2: Get device API level to decide instrumentation flags
-    const apiResult = await spawnCapture('adb', [
+    const apiResult = await spawnCapture((0, sdk_js_1.resolveAndroidTool)('adb'), [
         '-s',
         deviceId,
         'shell',
@@ -628,7 +651,7 @@ async function startAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
         String(port),
         CONDUCTOR_TEST_RUNNER,
     ];
-    const proc = (0, child_process_1.spawn)('adb', instrArgs, {
+    const proc = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('adb'), instrArgs, {
         detached: true,
         stdio: ['ignore', 'ignore', 'ignore'],
     });
@@ -647,7 +670,7 @@ async function startAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
         `Try running: conductor install --device ${deviceId}`);
 }
 async function stopAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
-    await spawnAndWait('adb', [
+    await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
         '-s',
         deviceId,
         'shell',
@@ -655,7 +678,13 @@ async function stopAndroidDriver(deviceId, port = ANDROID_BASE_PORT) {
         'force-stop',
         'dev.houwert.conductor',
     ]).catch(() => { });
-    await spawnAndWait('adb', ['-s', deviceId, 'forward', '--remove', `tcp:${port}`]).catch(() => { });
+    await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+        '-s',
+        deviceId,
+        'forward',
+        '--remove',
+        `tcp:${port}`,
+    ]).catch(() => { });
 }
 // ── Web bootstrap ────────────────────────────────────────────────────────────
 /**
@@ -783,8 +812,18 @@ async function uninstallDriver(deviceId, platform) {
         await spawnAndWait('xcrun', ['simctl', 'uninstall', deviceId, TVOS_RUNNER_BUNDLE_ID]).catch(() => { });
     }
     else {
-        await spawnAndWait('adb', ['-s', deviceId, 'uninstall', 'dev.houwert.conductor']).catch(() => { });
-        await spawnAndWait('adb', ['-s', deviceId, 'uninstall', 'dev.houwert.conductor.test']).catch(() => { });
+        await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+            '-s',
+            deviceId,
+            'uninstall',
+            'dev.houwert.conductor',
+        ]).catch(() => { });
+        await spawnAndWait((0, sdk_js_1.resolveAndroidTool)('adb'), [
+            '-s',
+            deviceId,
+            'uninstall',
+            'dev.houwert.conductor.test',
+        ]).catch(() => { });
     }
 }
 // ── Helpers ───────────────────────────────────────────────────────────────────

package/dist/drivers/log-sources/android.js

@@ -5,6 +5,7 @@ exports.AndroidLogSource = void 0;
  * Android log source — streams logs from an Android device/emulator via `adb logcat`.
  */
 const child_process_1 = require("child_process");
+const sdk_js_1 = require("../../android/sdk.js");
 function mapPriority(priority) {
     // Android log priorities: 2=V, 3=D, 4=I, 5=W, 6=E, 7=F
     const p = typeof priority === 'string' ? priority.toUpperCase() : String(priority);
@@ -44,10 +45,7 @@ class AndroidLogSource {
         let pid;
         if (this.appId) {
             try {
-                pid = (0, child_process_1.execSync)(`adb -s ${this.deviceId} shell pidof ${this.appId}`, {
-                    encoding: 'utf-8',
-                    timeout: 5000,
-                }).trim();
+                pid = (0, child_process_1.execFileSync)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', this.deviceId, 'shell', 'pidof', this.appId], { encoding: 'utf-8', timeout: 5000 }).trim();
             }
             catch {
                 // App may not be running yet — proceed without PID filter
@@ -55,7 +53,9 @@ class AndroidLogSource {
         }
         // Clear existing logcat buffer so we start fresh
         try {
-            (0, child_process_1.execSync)(`adb -s ${this.deviceId} logcat -c`, { timeout: 5000 });
+            (0, child_process_1.execFileSync)((0, sdk_js_1.resolveAndroidTool)('adb'), ['-s', this.deviceId, 'logcat', '-c'], {
+                timeout: 5000,
+            });
         }
         catch {
             // Ignore clear failures
@@ -71,7 +71,7 @@ class AndroidLogSource {
         if (pid) {
             args.push('--pid', pid);
         }
-        this.proc = (0, child_process_1.spawn)('adb', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        this.proc = (0, child_process_1.spawn)((0, sdk_js_1.resolveAndroidTool)('adb'), args, { stdio: ['ignore', 'pipe', 'pipe'] });
         let stderrChunks = '';
         this.proc.stderr.on('data', (chunk) => {
             stderrChunks += chunk.toString('utf-8');

package/dist/drivers/log-sources/metro-discovery.js

@@ -24,6 +24,7 @@ exports.targetsForDevice = targetsForDevice;
  */
 const child_process_1 = require("child_process");
 const metro_js_1 = require("./metro.js");
+const sdk_js_1 = require("../../android/sdk.js");
 /** Metro dev-server port ranges we consider. */
 const METRO_PORT_RANGES = [
     [8080, 8099], // Metro default range
@@ -58,7 +59,12 @@ async function discoverMetroPortForDevice(platform, deviceId) {
 }
 async function discoverMetroPortAndroid(deviceId) {
     try {
-        const output = await spawnCapture('adb', ['-s', deviceId, 'reverse', '--list']);
+        const output = await spawnCapture((0, sdk_js_1.resolveAndroidTool)('adb'), [
+            '-s',
+            deviceId,
+            'reverse',
+            '--list',
+        ]);
         // Lines look like: host-13 tcp:8082 tcp:8082
         for (const line of output.split('\n')) {
             const match = line.match(/tcp:(\d+)\s+tcp:(\d+)/);
@@ -172,7 +178,7 @@ async function getDeviceDisplayName(platform, deviceId) {
     }
     if (platform === 'android') {
         try {
-            const output = await spawnCapture('adb', [
+            const output = await spawnCapture((0, sdk_js_1.resolveAndroidTool)('adb'), [
                 '-s',
                 deviceId,
                 'shell',

package/dist/drivers/web.js

@@ -18,7 +18,7 @@ class WebDriver {
         this.host = host;
         this.deviceId = deviceId;
     }
-    request(method, path, body) {
+    request(method, path, body, timeoutMs = 30000) {
         return new Promise((resolve, reject) => {
             const bodyBuf = body !== undefined ? Buffer.from(JSON.stringify(body), 'utf-8') : undefined;
             const options = {
@@ -38,7 +38,7 @@ class WebDriver {
                 res.on('end', () => resolve({ status: res.statusCode ?? 0, data: Buffer.concat(chunks) }));
                 res.on('error', reject);
             });
-            req.setTimeout(30000, () => {
+            req.setTimeout(timeoutMs, () => {
                 req.destroy(new Error(`Web driver request timed out: ${method} ${path}`));
             });
             req.on('error', reject);
@@ -139,6 +139,20 @@ class WebDriver {
     async memory() {
         return this.get('memory');
     }
+    /**
+     * Take a V8 heap snapshot via CDP. Returns the raw JSON text (large; tens
+     * of MB on a real page). Caller can write it to a `.heapsnapshot` file for
+     * Chrome DevTools and/or parse it for class statistics.
+     */
+    async heapSnapshot(opts = {}) {
+        // 5-minute timeout — large pages can take 30-60s to snapshot + transfer.
+        const qs = opts.gc ? '?gc=1' : '';
+        const { status, data } = await this.request('GET', `/heapSnapshot${qs}`, undefined, 5 * 60000);
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver heapSnapshot failed (HTTP ${status}): ${data.toString('utf-8').slice(0, 200)}`);
+        }
+        return data.toString('utf-8');
+    }
     async eraseAllText(count = 50) {
         await this.post('eraseText', { count });
     }

package/dist/index.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const minimist_1 = __importDefault(require("minimist"));
 const verbose_js_1 = require("./verbose.js");
+const sdk_js_1 = require("./android/sdk.js");
 const list_devices_js_1 = require("./commands/list-devices.js");
 const launch_app_js_1 = require("./commands/launch-app.js");
 const stop_app_js_1 = require("./commands/stop-app.js");
@@ -110,6 +111,7 @@ ${Object.values(COMMAND_HELP).join('\n')}
 
 ${OPTIONS_HELP}`;
 async function main() {
+    (0, sdk_js_1.ensureAndroidEnv)();
     (0, update_check_js_1.checkForUpdates)();
     const argv = (0, minimist_1.default)(process.argv.slice(2), {
         boolean: [
@@ -131,6 +133,11 @@ async function main() {
             'optional',
             'benchmark',
             'dump',
+            'objects',
+            'heap',
+            'leaks',
+            'snapshots',
+            'growth-only',
         ],
         string: [
             'device',
@@ -160,6 +167,11 @@ async function main() {
             'to',
             'source',
             'level',
+            'save',
+            'diff',
+            'vs',
+            'top',
+            'filter',
         ],
         alias: { h: 'help', v: 'verbose', V: 'version' },
     });
@@ -475,7 +487,20 @@ async function main() {
             break;
         case 'memory': {
             const appId = rest[0];
-            exitCode = await (0, memory_js_1.memory)(appId, opts, sessionName);
+            const all = argv['all'];
+            exitCode = await (0, memory_js_1.memory)(appId, opts, sessionName, {
+                objects: argv['objects'] || argv['heap'] || all,
+                leaks: argv['leaks'] || all,
+                top: argv['top'] !== undefined ? Number(argv['top']) : undefined,
+                save: argv['save'],
+                diff: argv['diff'],
+                diffOther: argv['vs'],
+                listSnapshots: argv['snapshots'],
+                // minimist treats --no-gc as gc=false; default-on lives in memory.ts.
+                gc: argv['gc'],
+                filter: argv['filter'],
+                growthOnly: argv['growth-only'],
+            });
             break;
         }
         case 'run-flow': {

package/dist/runner.js

@@ -6,6 +6,7 @@ exports.runDirect = runDirect;
 exports.spawnCommand = spawnCommand;
 exports.runInlineFlow = runInlineFlow;
 const child_process_1 = require("child_process");
+const sdk_js_1 = require("./android/sdk.js");
 const session_js_1 = require("./session.js");
 const flow_runner_js_1 = require("./drivers/flow-runner.js");
 const verbose_js_1 = require("./verbose.js");
@@ -24,7 +25,9 @@ async function detectFirstDevice() {
     if (_cachedDeviceId !== undefined)
         return _cachedDeviceId ?? undefined;
     // Android: adb devices
-    const adb = await spawnCommand('adb', ['devices', '-l']).catch(() => null);
+    const adb = await spawnCommand((0, sdk_js_1.resolveAndroidTool)('adb'), ['devices', '-l'], {
+        env: (0, sdk_js_1.androidSpawnEnv)(),
+    }).catch(() => null);
     if (adb) {
         for (const line of adb.stdout.split('\n').slice(1)) {
             const id = line.trim().split(/\s+/)[0];
@@ -217,9 +220,12 @@ async function runDirect(fn, sessionName = 'default') {
     }
 }
 // ── Spawn helpers ─────────────────────────────────────────────────────────────
-async function spawnCommand(cmd, args) {
+async function spawnCommand(cmd, args, options) {
     return new Promise((resolve) => {
-        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const proc = (0, child_process_1.spawn)(cmd, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: options?.env,
+        });
         let stdout = '';
         let stderr = '';
         proc.stdout.on('data', (chunk) => {

package/package.json

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