@houwert/conductor 0.16.0 → 0.17.0

package/dist/commands/profile.js

@@ -0,0 +1,300 @@
+"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.profileCpu = profileCpu;
+exports.profileMemory = profileMemory;
+exports.profileReactStart = profileReactStart;
+exports.profileReactStop = profileReactStop;
+exports.HELP = `  profile cpu --duration <s> [--out <path>]
+                                       Record a CPU trace (iOS: xctrace, Android: simpleperf)
+  profile memory --track <s> [--interval <ms>] [<appId>]
+                                       Sample memory for N seconds, report deltas
+  profile react start                  Install a React commit-profiler hook in the JS runtime
+  profile react stop [--top N]         Stop and summarise captured React commits`;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const sdk_js_1 = require("../android/sdk.js");
+const memory_js_1 = require("./memory.js");
+const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
+function defaultTracePath(prefix, ext) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    return path_1.default.join(os_1.default.tmpdir(), `${prefix}-${ts}.${ext}`);
+}
+async function recordIosCpu(deviceId, appId, durationSec, out) {
+    const args = [
+        'xctrace',
+        'record',
+        '--template',
+        'Time Profiler',
+        '--device',
+        deviceId,
+        '--time-limit',
+        `${durationSec}s`,
+        '--output',
+        out,
+    ];
+    if (appId)
+        args.push('--attach', appId);
+    await new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)('xcrun', args, { stdio: 'inherit' });
+        proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`xctrace exited with code ${code}`)));
+        proc.on('error', reject);
+    });
+}
+async function recordAndroidCpu(deviceId, appId, durationSec, out) {
+    const adb = (0, sdk_js_1.resolveAndroidTool)('adb');
+    const env = (0, sdk_js_1.androidSpawnEnv)();
+    const remote = `/data/local/tmp/conductor-perf-${Date.now()}.data`;
+    const recordArgs = [
+        '-s',
+        deviceId,
+        'shell',
+        'simpleperf',
+        'record',
+        '-o',
+        remote,
+        '--duration',
+        String(durationSec),
+    ];
+    if (appId) {
+        recordArgs.push('--app', appId);
+    }
+    else {
+        recordArgs.push('-a');
+    }
+    await new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(adb, recordArgs, { stdio: 'inherit', env });
+        proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`simpleperf record exited with ${code}`)));
+        proc.on('error', reject);
+    });
+    await new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(adb, ['-s', deviceId, 'pull', remote, out], { stdio: 'inherit', env });
+        proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`adb pull exited with ${code}`)));
+        proc.on('error', reject);
+    });
+    await new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(adb, ['-s', deviceId, 'shell', 'rm', remote], { stdio: 'ignore', env });
+        proc.on('close', () => resolve());
+        proc.on('error', () => resolve());
+    });
+}
+async function profileCpu(opts, sessionName, profileOpts) {
+    if (sessionName === 'default') {
+        (0, output_js_1.printError)('profile cpu requires a --device', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => null);
+    const isIos = platform === 'ios' || platform === 'tvos';
+    const out = profileOpts.out ?? defaultTracePath('cpu', isIos ? 'trace' : 'perf.data');
+    try {
+        if (isIos) {
+            await recordIosCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out);
+        }
+        else if (platform === 'android') {
+            await recordAndroidCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out);
+        }
+        else {
+            (0, output_js_1.printError)(`profile cpu is not supported on platform ${platform ?? '(unknown)'}`, opts);
+            return 1;
+        }
+        if (opts.json)
+            (0, output_js_1.printData)({ out, durationSec: profileOpts.durationSec, platform }, opts);
+        else
+            (0, output_js_1.printSuccess)(`profile cpu — recorded ${profileOpts.durationSec}s → ${out}`, opts);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`profile cpu — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function profileMemory(opts, sessionName, profileOpts) {
+    const samples = [];
+    const start = Date.now();
+    const end = start + profileOpts.trackSec * 1000;
+    while (Date.now() < end) {
+        const at = Date.now() - start;
+        // Capture memory output for this sample by intercepting stdout.
+        const captured = await captureStdout(async () => {
+            await (0, memory_js_1.memory)(profileOpts.appId, { json: true }, sessionName, {});
+        });
+        samples.push({ at, sample: captured });
+        if (Date.now() < end) {
+            await new Promise((r) => setTimeout(r, profileOpts.intervalMs));
+        }
+    }
+    const parsed = samples.map((s) => {
+        try {
+            return { at: s.at, data: JSON.parse(s.sample) };
+        }
+        catch {
+            return { at: s.at, data: null };
+        }
+    });
+    if (opts.json) {
+        (0, output_js_1.printData)({ samples: parsed, durationMs: Date.now() - start }, opts);
+    }
+    else {
+        console.log(`profile memory — ${samples.length} samples over ${profileOpts.trackSec}s`);
+        for (const p of parsed) {
+            const summary = p.data && typeof p.data === 'object'
+                ? Object.entries(p.data)
+                    .slice(0, 4)
+                    .map(([k, v]) => `${k}=${typeof v === 'object' ? '…' : String(v)}`)
+                    .join(' ')
+                : '(parse error)';
+            console.log(`  t+${(p.at / 1000).toFixed(1)}s  ${summary}`);
+        }
+    }
+    return 0;
+}
+async function captureStdout(fn) {
+    const chunks = [];
+    const origWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((c) => {
+        chunks.push(typeof c === 'string' ? c : Buffer.from(c).toString());
+        return true;
+    });
+    try {
+        await fn();
+    }
+    finally {
+        process.stdout.write = origWrite;
+    }
+    return chunks.join('');
+}
+// ── React profiler ────────────────────────────────────────────────────────────
+const REACT_PROFILER_INSTALL = `
+(() => {
+  if (globalThis.__CONDUCTOR_REACT_PROFILER__) {
+    return { installed: true, already: true };
+  }
+  const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (!hook) return { installed: false, error: 'No React DevTools hook (Hermes only?)' };
+  const commits = [];
+  const MAX = 500;
+  const orig = hook.onCommitFiberRoot;
+  hook.onCommitFiberRoot = function(rendererID, root, priorityLevel) {
+    try {
+      const entry = { at: Date.now(), rendererID, components: [] };
+      let node = root.current;
+      const stack = [{ fiber: node, depth: 0 }];
+      let count = 0;
+      while (stack.length && count < 200) {
+        const { fiber, depth } = stack.pop();
+        if (!fiber) continue;
+        const dur = fiber.actualDuration ?? 0;
+        if (dur > 0) {
+          const name = (fiber.type && (fiber.type.displayName || fiber.type.name)) || (typeof fiber.type === 'string' ? fiber.type : null);
+          if (name) {
+            entry.components.push({ name, depth, actualDuration: dur, selfDuration: fiber.selfBaseDuration ?? 0 });
+            count++;
+          }
+        }
+        if (fiber.child) stack.push({ fiber: fiber.child, depth: depth + 1 });
+        if (fiber.sibling) stack.push({ fiber: fiber.sibling, depth });
+      }
+      commits.push(entry);
+      if (commits.length > MAX) commits.shift();
+    } catch (e) {}
+    if (typeof orig === 'function') return orig.apply(this, arguments);
+  };
+  globalThis.__CONDUCTOR_REACT_PROFILER__ = {
+    installed: true,
+    commits,
+    uninstall: () => { hook.onCommitFiberRoot = orig; }
+  };
+  return { installed: true, already: false };
+})()
+`;
+const REACT_PROFILER_READ = (top) => `
+(() => {
+  const p = globalThis.__CONDUCTOR_REACT_PROFILER__;
+  if (!p) return { installed: false, commits: [] };
+  const commits = p.commits.slice();
+  const byName = {};
+  for (const c of commits) {
+    for (const comp of c.components) {
+      byName[comp.name] = byName[comp.name] ?? { name: comp.name, totalMs: 0, renders: 0 };
+      byName[comp.name].totalMs += comp.actualDuration;
+      byName[comp.name].renders += 1;
+    }
+  }
+  const top = Object.values(byName).sort((a, b) => b.totalMs - a.totalMs).slice(0, ${top});
+  return { installed: true, commits, totalCommits: commits.length, top };
+})()
+`;
+const REACT_PROFILER_STOP = `
+(() => {
+  const p = globalThis.__CONDUCTOR_REACT_PROFILER__;
+  if (!p) return { installed: false };
+  if (typeof p.uninstall === 'function') p.uninstall();
+  delete globalThis.__CONDUCTOR_REACT_PROFILER__;
+  return { installed: true, stopped: true };
+})()
+`;
+async function profileReactStart(opts, sessionName, cdpOpts) {
+    try {
+        const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({
+            port: cdpOpts.port ?? 8081,
+            deviceId: sessionName !== 'default' ? sessionName : undefined,
+            platform,
+            targetIndex: cdpOpts.targetIndex,
+        });
+        const result = await client.evaluate(REACT_PROFILER_INSTALL);
+        client.close();
+        if (!result.installed) {
+            (0, output_js_1.printError)(`profile react start — ${result.error ?? 'install failed'}`, opts);
+            return 1;
+        }
+        if (opts.json)
+            (0, output_js_1.printData)(result, opts);
+        else
+            (0, output_js_1.printSuccess)(`profile react start — ${result.already ? 'already installed' : 'installed'}`, opts);
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`profile react start — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function profileReactStop(opts, sessionName, cdpOpts, top) {
+    try {
+        const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({
+            port: cdpOpts.port ?? 8081,
+            deviceId: sessionName !== 'default' ? sessionName : undefined,
+            platform,
+            targetIndex: cdpOpts.targetIndex,
+        });
+        const read = await client.evaluate(REACT_PROFILER_READ(top));
+        await client.evaluate(REACT_PROFILER_STOP);
+        client.close();
+        if (!read.installed) {
+            (0, output_js_1.printError)('profile react stop — profiler was not installed', opts);
+            return 1;
+        }
+        if (opts.json)
+            (0, output_js_1.printData)(read, opts);
+        else {
+            console.log(`profile react — ${read.totalCommits ?? 0} commit(s)`);
+            for (const t of read.top ?? []) {
+                console.log(`  ${t.totalMs.toFixed(1)}ms  ${t.renders}x  ${t.name}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`profile react stop — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}

package/dist/commands/run-sequence.js

@@ -0,0 +1,124 @@
+"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.runSequence = runSequence;
+exports.HELP = `  run-sequence [--file path.json]      Run a sequence of conductor commands serially against one session
+                                       JSON shape: {"steps":[{"cmd":"tap-on","args":["Login"]}, ...]}
+                                       Reads stdin when --file is omitted. Stops on first non-zero exit.`;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const output_js_1 = require("../output.js");
+function flagsToArgs(flags) {
+    if (!flags)
+        return [];
+    const out = [];
+    for (const [key, value] of Object.entries(flags)) {
+        if (value === false)
+            continue;
+        out.push(`--${key}`);
+        if (value !== true)
+            out.push(String(value));
+    }
+    return out;
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let buf = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => {
+            buf += chunk;
+        });
+        process.stdin.on('end', () => resolve(buf));
+        process.stdin.on('error', reject);
+    });
+}
+async function runSequence(filePath, opts = {}, sessionName = 'default') {
+    let raw;
+    if (filePath) {
+        const resolved = path_1.default.resolve(filePath);
+        if (!fs_1.default.existsSync(resolved)) {
+            (0, output_js_1.printError)(`run-sequence: file not found: ${resolved}`, opts);
+            return 1;
+        }
+        raw = fs_1.default.readFileSync(resolved, 'utf-8');
+    }
+    else {
+        raw = await readStdin();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`run-sequence: invalid JSON\n${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+    if (!parsed.steps || !Array.isArray(parsed.steps)) {
+        (0, output_js_1.printError)('run-sequence: input must be {"steps":[...]}', opts);
+        return 1;
+    }
+    const results = [];
+    const conductorBin = process.argv[1] ?? 'conductor';
+    const deviceArgs = sessionName !== 'default' ? ['--device', sessionName] : [];
+    for (let i = 0; i < parsed.steps.length; i++) {
+        const step = parsed.steps[i];
+        const args = [step.cmd, ...(step.args ?? []), ...flagsToArgs(step.flags), ...deviceArgs];
+        if (!opts.json) {
+            console.log(`[${i + 1}/${parsed.steps.length}] conductor ${args.join(' ')}`);
+        }
+        const result = await runStep(conductorBin, args);
+        results.push({
+            cmd: step.cmd,
+            args: step.args ?? [],
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        });
+        if (!opts.json && result.stdout)
+            process.stdout.write(result.stdout);
+        if (!opts.json && result.stderr)
+            process.stderr.write(result.stderr);
+        if (result.exitCode !== 0) {
+            if (opts.json) {
+                (0, output_js_1.printData)({ ok: false, completed: i, total: parsed.steps.length, results }, opts);
+            }
+            else {
+                (0, output_js_1.printError)(`run-sequence aborted at step ${i + 1}/${parsed.steps.length} (${step.cmd}, exit ${result.exitCode})`, opts);
+            }
+            return result.exitCode;
+        }
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ ok: true, completed: parsed.steps.length, total: parsed.steps.length, results }, opts);
+    }
+    else {
+        console.log(`run-sequence — completed ${parsed.steps.length} step(s)`);
+    }
+    return 0;
+}
+function runStep(bin, args) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(process.execPath, [bin, ...args], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (c) => {
+            stdout += c.toString();
+        });
+        proc.stderr.on('data', (c) => {
+            stderr += c.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({ exitCode: code ?? 1, stdout, stderr });
+        });
+        proc.on('error', (err) => {
+            resolve({ exitCode: 1, stdout: '', stderr: err.message });
+        });
+    });
+}

package/dist/commands/scroll-until-visible.js

@@ -13,6 +13,7 @@ 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 element_resolver_js_1 = require("../drivers/element-resolver.js");
+const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const utils_js_1 = require("../utils.js");
 async function scrollUntilVisible(element, opts = {}, sessionName = 'default', flags = {}) {
     if (!element && !flags.id && !flags.text) {
@@ -38,9 +39,25 @@ async function scrollUntilVisible(element, opts = {}, sessionName = 'default', f
     try {
         const driver = await (0, runner_js_1.getDriver)(sessionName);
         const deadline = Date.now() + timeoutMs;
+        // Resolve simple selectors with a direct runner query, skipping the
+        // full-tree snapshot on every scroll iteration.
+        const iosDirectResolve = driver instanceof ios_js_1.IOSDriver ? (0, direct_ios_selector_js_1.makeIOSDirectResolver)(driver, sel) : undefined;
         while (Date.now() < deadline) {
             try {
                 if (driver instanceof ios_js_1.IOSDriver) {
+                    if (iosDirectResolve) {
+                        let fast = null;
+                        try {
+                            fast = await iosDirectResolve();
+                        }
+                        catch {
+                            // direct query failed — fall back to the snapshot check below
+                        }
+                        if (fast) {
+                            (0, output_js_1.printSuccess)(`scroll-until-visible ${label} — found`, opts);
+                            return 0;
+                        }
+                    }
                     const root = await driver.viewHierarchy().then((h) => h.axElement);
                     if ((0, element_resolver_js_1.findIOSElement)(root, sel)) {
                         (0, output_js_1.printSuccess)(`scroll-until-visible ${label} — found`, opts);

package/dist/commands/start-device.js

@@ -165,6 +165,9 @@ async function startIOS(osVersion, opts, name, deviceType) {
                         }
                     }
                     const displayName = name ?? sim.name;
+                    // Prewarm the driver so the first interaction command is not the
+                    // one that pays the XCTest runner startup cost.
+                    await (0, runner_js_1.prewarmDriver)(sim.udid);
                     (0, output_js_1.printSuccess)(`Simulator already booted: ${displayName} (${sim.udid})`, opts);
                     return 0;
                 }
@@ -203,6 +206,9 @@ async function startIOS(osVersion, opts, name, deviceType) {
             }
             (0, child_process_1.spawn)('open', ['-a', 'Simulator'], { detached: true, stdio: 'ignore' }).unref();
             const displayName = name ?? deviceType;
+            // Prewarm the driver so the first interaction command is not the
+            // one that pays the XCTest runner startup cost.
+            await (0, runner_js_1.prewarmDriver)(udid);
             (0, output_js_1.printSuccess)(`Booted: ${displayName} (${udid})`, opts);
             return 0;
         }
@@ -238,6 +244,9 @@ async function startIOS(osVersion, opts, name, deviceType) {
     // Open the Simulator.app so the window appears
     (0, child_process_1.spawn)('open', ['-a', 'Simulator'], { detached: true, stdio: 'ignore' }).unref();
     const displayName = name ?? device.name;
+    // Prewarm the driver so the first interaction command is not the
+    // one that pays the XCTest runner startup cost.
+    await (0, runner_js_1.prewarmDriver)(device.udid);
     (0, output_js_1.printSuccess)(`Booted: ${displayName} (${device.udid})`, opts);
     return 0;
 }
@@ -320,6 +329,9 @@ async function startTvOS(osVersion, opts, name, deviceType) {
                         }
                     }
                     const displayName = name ?? sim.name;
+                    // Prewarm the driver so the first interaction command is not the
+                    // one that pays the XCTest runner startup cost.
+                    await (0, runner_js_1.prewarmDriver)(sim.udid);
                     (0, output_js_1.printSuccess)(`Simulator already booted: ${displayName} (${sim.udid})`, opts);
                     return 0;
                 }
@@ -358,6 +370,9 @@ async function startTvOS(osVersion, opts, name, deviceType) {
             }
             (0, child_process_1.spawn)('open', ['-a', 'Simulator'], { detached: true, stdio: 'ignore' }).unref();
             const displayName = name ?? deviceType;
+            // Prewarm the driver so the first interaction command is not the
+            // one that pays the XCTest runner startup cost.
+            await (0, runner_js_1.prewarmDriver)(udid);
             (0, output_js_1.printSuccess)(`Booted: ${displayName} (${udid})`, opts);
             return 0;
         }
@@ -393,6 +408,9 @@ async function startTvOS(osVersion, opts, name, deviceType) {
     // Open the Simulator.app so the window appears
     (0, child_process_1.spawn)('open', ['-a', 'Simulator'], { detached: true, stdio: 'ignore' }).unref();
     const displayName = name ?? device.name;
+    // Prewarm the driver so the first interaction command is not the
+    // one that pays the XCTest runner startup cost.
+    await (0, runner_js_1.prewarmDriver)(device.udid);
     (0, output_js_1.printSuccess)(`Booted: ${displayName} (${device.udid})`, opts);
     return 0;
 }

package/dist/commands/tap.js

@@ -23,6 +23,7 @@ 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 wait_js_1 = require("../drivers/wait.js");
+const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const utils_js_1 = require("../utils.js");
 async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
     if (!query && !flags.id && !flags.text) {
@@ -49,7 +50,7 @@ async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
         }
         let el;
         if (driver instanceof ios_js_1.IOSDriver) {
-            el = await (0, wait_js_1.waitForIOSElement)(() => driver.viewHierarchy().then((h) => h.axElement), sel);
+            el = await (0, wait_js_1.waitForIOSElement)((o) => driver.viewHierarchy(false, [], { cache: o?.cached }).then((h) => h.axElement), sel, undefined, undefined, (0, direct_ios_selector_js_1.makeIOSDirectResolver)(driver, sel));
         }
         else if (driver instanceof web_js_1.WebDriver) {
             el = await (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel);