@houwert/conductor 0.16.0 → 0.18.0

package/dist/commands/gestures.js

@@ -0,0 +1,196 @@
+"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.pinch = pinch;
+exports.rotateGesture = rotateGesture;
+exports.gesture = gesture;
+exports.HELP = `  pinch [--scale N] [--center x,y] [--duration ms] [--angle deg]
+                                       Two-finger pinch (scale<1 zoom out, scale>1 zoom in)
+  rotate-gesture [--degrees N] [--center x,y] [--duration ms]
+                                       Two-finger rotate gesture
+  gesture <json|--file path>           Play a multi-touch path
+                                       JSON: [{"steps":[{"x":,"y":,"dt":}]},...]
+                                       dt is delay since previous step (seconds for iOS, see docs)`;
+const fs_1 = __importDefault(require("fs"));
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const web_js_1 = require("../drivers/web.js");
+function parseCenter(s) {
+    if (!s)
+        return null;
+    const m = s.match(/^\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/);
+    if (!m)
+        return null;
+    return { x: Number(m[1]), y: Number(m[2]) };
+}
+async function screenCenter(driver) {
+    if (driver instanceof ios_js_1.IOSDriver) {
+        const info = await driver.deviceInfo();
+        return {
+            width: info.widthPoints,
+            height: info.heightPoints,
+            cx: info.widthPoints / 2,
+            cy: info.heightPoints / 2,
+        };
+    }
+    const info = await driver.deviceInfo();
+    return {
+        width: info.widthPixels,
+        height: info.heightPixels,
+        cx: info.widthPixels / 2,
+        cy: info.heightPixels / 2,
+    };
+}
+/**
+ * Build two synchronized finger paths for a pinch. The two fingers start at
+ * `startDistance` apart, end at `endDistance`, along an axis rotated by
+ * `angleDeg`. We emit a coarse path (~60fps) — the drivers interpolate inside.
+ *
+ * Distances are in pixels (iOS uses points, Android uses pixels — caller
+ * passes the raw value; we don't normalize).
+ */
+function buildPinchPaths(cx, cy, startDist, endDist, angleDeg, durationMs) {
+    const rad = (angleDeg * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const steps = Math.max(2, Math.round(durationMs / 16));
+    const dtStep = durationMs / steps / 1000;
+    const finger1 = [];
+    const finger2 = [];
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+        const dist = startDist + (endDist - startDist) * t;
+        const half = dist / 2;
+        const dx = half * cos;
+        const dy = half * sin;
+        const dt = i === 0 ? 0 : dtStep;
+        finger1.push({ x: cx - dx, y: cy - dy, dt });
+        finger2.push({ x: cx + dx, y: cy + dy, dt });
+    }
+    return [{ steps: finger1 }, { steps: finger2 }];
+}
+function buildRotatePaths(cx, cy, radius, degrees, durationMs) {
+    const steps = Math.max(2, Math.round(durationMs / 16));
+    const dtStep = durationMs / steps / 1000;
+    const finger1 = [];
+    const finger2 = [];
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+        const theta = (degrees * Math.PI * t) / 180;
+        const dx = radius * Math.cos(theta);
+        const dy = radius * Math.sin(theta);
+        const dt = i === 0 ? 0 : dtStep;
+        finger1.push({ x: cx - dx, y: cy - dy, dt });
+        finger2.push({ x: cx + dx, y: cy + dy, dt });
+    }
+    return [{ steps: finger1 }, { steps: finger2 }];
+}
+async function playPaths(driver, paths) {
+    if (driver instanceof ios_js_1.IOSDriver) {
+        await driver.gesturePath(paths);
+    }
+    else {
+        // Android proto uses dt_ms (ms), our internal model uses seconds.
+        const androidPaths = paths.map((p) => ({
+            steps: p.steps.map((s) => ({ x: s.x, y: s.y, dt_ms: Math.round(s.dt * 1000) })),
+        }));
+        await driver.gesturePath(androidPaths);
+    }
+}
+async function pinch(opts, sessionName, pinchOpts) {
+    const scale = pinchOpts.scale ?? 0.5;
+    const duration = pinchOpts.duration ?? 400;
+    const angle = pinchOpts.angle ?? 0;
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof web_js_1.WebDriver)
+            throw new Error('pinch is not supported on Web');
+        const { width, height, cx: defCx, cy: defCy } = await screenCenter(driver);
+        const center = parseCenter(pinchOpts.center) ?? { x: defCx, y: defCy };
+        // Start span is half the shorter screen dimension; end is scaled.
+        const baseSpan = Math.min(width, height) * 0.5;
+        const startDist = scale < 1 ? baseSpan : baseSpan * scale;
+        const endDist = scale < 1 ? baseSpan * scale : baseSpan;
+        const paths = buildPinchPaths(center.x, center.y, startDist, endDist, angle, duration);
+        await playPaths(driver, paths);
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('pinch — done', opts);
+        return 0;
+    }
+    (0, output_js_1.printError)(`pinch — failed\n${result.stderr}`, opts);
+    return 1;
+}
+async function rotateGesture(opts, sessionName, rotateOpts) {
+    const degrees = rotateOpts.degrees ?? 90;
+    const duration = rotateOpts.duration ?? 500;
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof web_js_1.WebDriver)
+            throw new Error('rotate-gesture is not supported on Web');
+        const { width, height, cx: defCx, cy: defCy } = await screenCenter(driver);
+        const center = parseCenter(rotateOpts.center) ?? { x: defCx, y: defCy };
+        const radius = Math.min(width, height) * 0.25;
+        const paths = buildRotatePaths(center.x, center.y, radius, degrees, duration);
+        await playPaths(driver, paths);
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)('rotate-gesture — done', opts);
+        return 0;
+    }
+    (0, output_js_1.printError)(`rotate-gesture — failed\n${result.stderr}`, opts);
+    return 1;
+}
+function inputToPaths(tracks) {
+    return tracks.map((t) => {
+        const pts = t.steps ?? t.points ?? [];
+        let prevT = 0;
+        return {
+            steps: pts.map((p) => {
+                let dt = p.dt;
+                if (dt === undefined && p.t !== undefined) {
+                    dt = (p.t - prevT) / 1000;
+                    prevT = p.t;
+                }
+                return { x: p.x, y: p.y, dt: dt ?? 0 };
+            }),
+        };
+    });
+}
+function readGestureInput(raw, filePath) {
+    let json;
+    if (filePath)
+        json = fs_1.default.readFileSync(filePath, 'utf-8');
+    else if (raw)
+        json = raw;
+    else
+        throw new Error('gesture requires a JSON argument or --file <path>');
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed))
+        throw new Error('gesture input must be a JSON array of tracks');
+    return parsed;
+}
+async function gesture(rawJson, filePath, opts, sessionName) {
+    let tracks;
+    try {
+        tracks = readGestureInput(rawJson, filePath);
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`gesture — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+    const paths = inputToPaths(tracks);
+    const result = await (0, runner_js_1.runDirect)(async (driver) => {
+        if (driver instanceof web_js_1.WebDriver)
+            throw new Error('gesture is not supported on Web');
+        await playPaths(driver, paths);
+    }, sessionName);
+    if (result.success) {
+        (0, output_js_1.printSuccess)(`gesture — played ${tracks.length} track(s)`, opts);
+        return 0;
+    }
+    (0, output_js_1.printError)(`gesture — failed\n${result.stderr}`, opts);
+    return 1;
+}

package/dist/commands/inspect.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.inspect = inspect;
-exports.HELP = `  inspect [--dump]                     Print UI hierarchy (--dump for raw driver output)`;
+exports.HELP = `  inspect [--dump]                     Print UI hierarchy (--dump for raw driver output)
+  inspect --at <x,y> [--tappable]      Print the topmost view at a screen point`;
 const runner_js_1 = require("../runner.js");
 const output_js_1 = require("../output.js");
 const ios_js_1 = require("../drivers/ios.js");
@@ -13,6 +14,45 @@ const a11y_js_1 = require("../drivers/a11y.js");
 async function inspect(opts = {}, sessionName = 'default', inspectOpts = {}) {
     try {
         const driver = await (0, runner_js_1.getDriver)(sessionName);
+        if (inspectOpts.at) {
+            const m = inspectOpts.at.match(/^\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*$/);
+            if (!m) {
+                (0, output_js_1.printError)(`inspect --at expects "<x>,<y>", got "${inspectOpts.at}"`, opts);
+                return 1;
+            }
+            const x = Number(m[1]);
+            const y = Number(m[2]);
+            const tappable = !!inspectOpts.tappableOnly;
+            let hit;
+            if (driver instanceof ios_js_1.IOSDriver) {
+                const hierarchy = await driver.viewHierarchy(false);
+                hit = (0, element_resolver_js_1.findIOSViewAtPoint)(hierarchy.axElement, x, y, tappable);
+            }
+            else if (driver instanceof android_js_1.AndroidDriver) {
+                const xml = await driver.viewHierarchy();
+                hit = (0, element_resolver_js_1.findAndroidViewAtPoint)(xml, x, y, tappable);
+            }
+            else if (driver instanceof web_js_1.WebDriver) {
+                const vh = await driver.viewHierarchy();
+                hit = (0, element_resolver_js_1.findWebViewAtPoint)(vh, x, y, tappable);
+            }
+            else {
+                throw new Error('Unknown driver type');
+            }
+            if (!hit) {
+                const message = `No ${tappable ? 'tappable view' : 'view'} found at (${x}, ${y})`;
+                if (opts.json)
+                    (0, output_js_1.printData)({ found: false, x, y, tappable }, opts);
+                else
+                    console.log(message);
+                return tappable ? 1 : 0;
+            }
+            if (opts.json)
+                (0, output_js_1.printData)({ found: true, x, y, tappable, hit }, opts);
+            else
+                console.log(hit.summary);
+            return 0;
+        }
         if (inspectOpts.dump) {
             let raw;
             if (driver instanceof ios_js_1.IOSDriver) {

package/dist/commands/metro.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.metroStop = metroStop;
+exports.metroReload = metroReload;
+exports.HELP = `  metro stop [--port N]                Stop the Metro bundler process on a port (default 8081)
+  metro reload [--port N] [--target N]  Reload the JS bundle without restarting native`;
+const child_process_1 = require("child_process");
+const output_js_1 = require("../output.js");
+const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+async function pidsOnPort(port) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)('lsof', ['-ti', `tcp:${port}`], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        let out = '';
+        proc.stdout.on('data', (c) => {
+            out += c.toString();
+        });
+        proc.on('close', () => {
+            const pids = out
+                .split('\n')
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => Number.isFinite(n) && n > 0);
+            resolve(pids);
+        });
+        proc.on('error', () => resolve([]));
+    });
+}
+async function metroStop(opts, metroOpts) {
+    const port = metroOpts.port ?? 8081;
+    const pids = await pidsOnPort(port);
+    if (pids.length === 0) {
+        (0, output_js_1.printData)({ stopped: false, port, pids: [] }, opts);
+        if (!opts.json)
+            (0, output_js_1.printSuccess)(`No Metro process found on port ${port}`, opts);
+        return 0;
+    }
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // Process may already be gone
+        }
+    }
+    // Give SIGTERM 2s, then SIGKILL anything still alive.
+    await new Promise((r) => setTimeout(r, 2000));
+    const survivors = await pidsOnPort(port);
+    for (const pid of survivors) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ stopped: true, port, pids }, opts);
+    }
+    else {
+        (0, output_js_1.printSuccess)(`Stopped Metro on port ${port} (pids: ${pids.join(', ')})`, opts);
+    }
+    return 0;
+}
+async function metroReload(opts, sessionName, metroOpts) {
+    const port = metroOpts.port ?? 8081;
+    let deviceId;
+    let platform;
+    if (sessionName && sessionName !== 'default') {
+        deviceId = sessionName;
+        platform = await (0, bootstrap_js_1.detectPlatform)(deviceId).catch(() => undefined);
+    }
+    // Try CDP Page.reload first (works on Hermes/Fusebox).
+    try {
+        await (0, metro_cdp_js_1.cdpCall)('Page.reload', undefined, {
+            port,
+            deviceId,
+            platform,
+            targetIndex: metroOpts.targetIndex,
+        });
+        if (opts.json)
+            (0, output_js_1.printData)({ reloaded: true, port, method: 'cdp' }, opts);
+        else
+            (0, output_js_1.printSuccess)(`Reloaded Metro bundle on port ${port} (cdp)`, opts);
+        return 0;
+    }
+    catch (cdpErr) {
+        // Fall back to Metro's HTTP /reload endpoint.
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/reload`);
+            if (!res.ok) {
+                throw new Error(`HTTP /reload returned ${res.status}`);
+            }
+            if (opts.json)
+                (0, output_js_1.printData)({ reloaded: true, port, method: 'http' }, opts);
+            else
+                (0, output_js_1.printSuccess)(`Reloaded Metro bundle on port ${port} (http)`, opts);
+            return 0;
+        }
+        catch (httpErr) {
+            const cdpMsg = cdpErr instanceof Error ? cdpErr.message : String(cdpErr);
+            const httpMsg = httpErr instanceof Error ? httpErr.message : String(httpErr);
+            (0, output_js_1.printError)(`metro reload failed.\n  cdp:  ${cdpMsg}\n  http: ${httpMsg}`, opts);
+            return 1;
+        }
+    }
+}

package/dist/commands/network.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.networkLogs = networkLogs;
+exports.networkRequest = networkRequest;
+exports.HELP = `  network logs [--port N] [--limit N]  Read recent HTTP traffic (installs a fetch/XHR shim once)
+  network request <url> [--method M] [--body STR] [--header K=V] [--port N]
+                                       Issue an HTTP request from the app's context`;
+const output_js_1 = require("../output.js");
+const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const INSTALL_SHIM_SCRIPT = `
+(() => {
+  if (globalThis.__CONDUCTOR_NET__ && globalThis.__CONDUCTOR_NET__.installed) {
+    return { installed: true, already: true };
+  }
+  const ring = [];
+  const MAX = 200;
+  function push(entry) {
+    ring.push(entry);
+    if (ring.length > MAX) ring.shift();
+  }
+  globalThis.__CONDUCTOR_NET__ = {
+    installed: true,
+    entries: ring,
+    clear: () => { ring.length = 0; },
+  };
+
+  const realFetch = globalThis.fetch;
+  if (typeof realFetch === 'function') {
+    globalThis.fetch = function patchedFetch(input, init) {
+      const url = typeof input === 'string' ? input : (input && input.url) || String(input);
+      const method = (init && init.method) || (input && input.method) || 'GET';
+      const start = Date.now();
+      const id = Math.random().toString(36).slice(2, 10);
+      const entry = { id, kind: 'fetch', method, url, status: null, durationMs: null, error: null, start };
+      push(entry);
+      let p;
+      try { p = realFetch.apply(this, arguments); } catch (e) {
+        entry.error = String(e && e.message || e);
+        entry.durationMs = Date.now() - start;
+        throw e;
+      }
+      return p.then(res => {
+        entry.status = res.status;
+        entry.durationMs = Date.now() - start;
+        return res;
+      }, err => {
+        entry.error = String(err && err.message || err);
+        entry.durationMs = Date.now() - start;
+        throw err;
+      });
+    };
+  }
+
+  const RealXHR = globalThis.XMLHttpRequest;
+  if (RealXHR) {
+    const origOpen = RealXHR.prototype.open;
+    const origSend = RealXHR.prototype.send;
+    RealXHR.prototype.open = function open(method, url) {
+      this.__c_meta = { id: Math.random().toString(36).slice(2, 10), kind: 'xhr', method, url, status: null, durationMs: null, error: null, start: 0 };
+      return origOpen.apply(this, arguments);
+    };
+    RealXHR.prototype.send = function send() {
+      const meta = this.__c_meta;
+      if (meta) {
+        meta.start = Date.now();
+        push(meta);
+        this.addEventListener('loadend', () => {
+          meta.status = this.status;
+          meta.durationMs = Date.now() - meta.start;
+        });
+        this.addEventListener('error', () => {
+          meta.error = 'xhr error';
+          meta.durationMs = Date.now() - meta.start;
+        });
+      }
+      return origSend.apply(this, arguments);
+    };
+  }
+  return { installed: true, already: false };
+})()
+`;
+const READ_SCRIPT = (limit) => `
+(() => {
+  const tap = globalThis.__CONDUCTOR_NET__;
+  if (!tap) return { installed: false, entries: [] };
+  const entries = tap.entries.slice(-${limit});
+  return { installed: true, count: entries.length, entries };
+})()
+`;
+function resolveSession(sessionName) {
+    if (!sessionName || sessionName === 'default') {
+        return { deviceId: undefined, platformPromise: Promise.resolve(undefined) };
+    }
+    return {
+        deviceId: sessionName,
+        platformPromise: (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined),
+    };
+}
+async function networkLogs(opts, sessionName, netOpts) {
+    const port = netOpts.port ?? 8081;
+    const limit = netOpts.limit ?? 50;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: netOpts.targetIndex });
+        await client.evaluate(INSTALL_SHIM_SCRIPT);
+        const result = await client.evaluate(READ_SCRIPT(limit));
+        client.close();
+        const entries = result.entries ?? [];
+        if (opts.json) {
+            (0, output_js_1.printData)({ installed: result.installed, count: entries.length, entries }, opts);
+        }
+        else {
+            if (entries.length === 0) {
+                console.log('No network entries captured yet. The shim is installed; reload the app and try again.');
+            }
+            for (const e of entries) {
+                const ts = new Date(e.start).toISOString().slice(11, 23);
+                const status = e.error ? `ERR ${e.error}` : e.status !== null ? String(e.status) : '...';
+                const dur = e.durationMs !== null ? `${e.durationMs}ms` : '-';
+                console.log(`${ts}  ${status.padEnd(6)} ${e.method.padEnd(6)} ${e.url} (${dur}, ${e.kind})`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`network logs — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}
+async function networkRequest(url, opts, sessionName, reqOpts) {
+    if (!url) {
+        (0, output_js_1.printError)('network request requires a URL', opts);
+        return 1;
+    }
+    const method = (reqOpts.method ?? 'GET').toUpperCase();
+    const headers = {};
+    for (const h of reqOpts.headers ?? []) {
+        const idx = h.indexOf('=');
+        if (idx > 0)
+            headers[h.slice(0, idx)] = h.slice(idx + 1);
+    }
+    const body = reqOpts.body;
+    const init = JSON.stringify({
+        method,
+        headers,
+        ...(body !== undefined ? { body } : {}),
+    });
+    const script = `
+(async () => {
+  try {
+    const res = await fetch(${JSON.stringify(url)}, ${init});
+    const text = await res.text();
+    const hdrs = {};
+    res.headers.forEach((v, k) => { hdrs[k] = v; });
+    return { ok: res.ok, status: res.status, headers: hdrs, body: text };
+  } catch (e) {
+    return { ok: false, error: String(e && e.message || e) };
+  }
+})()
+`;
+    const port = reqOpts.port ?? 8081;
+    const { deviceId, platformPromise } = resolveSession(sessionName);
+    try {
+        const platform = await platformPromise;
+        const client = new metro_cdp_js_1.MetroCdpClient();
+        await client.connect({ port, deviceId, platform, targetIndex: reqOpts.targetIndex });
+        const result = await client.evaluate(script);
+        client.close();
+        if (opts.json)
+            (0, output_js_1.printData)(result, opts);
+        else {
+            if (result.error)
+                console.error(`error: ${result.error}`);
+            console.log(`status: ${result.status ?? 'n/a'}`);
+            if (result.headers) {
+                for (const [k, v] of Object.entries(result.headers))
+                    console.log(`${k}: ${v}`);
+            }
+            if (result.body !== undefined) {
+                console.log('');
+                console.log(result.body);
+            }
+        }
+        return result.ok ? 0 : 1;
+    }
+    catch (err) {
+        (0, output_js_1.printError)(`network request — ${err instanceof Error ? err.message : String(err)}`, opts);
+        return 1;
+    }
+}