@houwert/conductor 0.24.0 → 0.25.0

package/dist/drivers/ios-inproc.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InprocClient = void 0;
+exports.getInprocPort = getInprocPort;
+/**
+ * Client + port allocation for the injected in-process control library
+ * (`packages/ios-inproc`). This is a second inspection plane that runs *inside*
+ * the target app — distinct from the external XCUITest driver in `ios.ts`.
+ *
+ * The dylib is injected at launch (see IOSDriver.launchApp `inject` option). The
+ * CLI allocates a loopback port per device, hands it to the app via
+ * SIMCTL_CHILD_CONDUCTOR_INPROC_PORT, and connects here. Simulator apps share
+ * the host loopback, so 127.0.0.1:<port> reaches the in-process server — the same
+ * mechanism the XCUITest driver uses on :1075.
+ */
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const INPROC_BASE_PORT = 6075;
+const PORT_FILE = path_1.default.join(os_1.default.homedir(), '.conductor', 'inproc-ports.json');
+function readState() {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(PORT_FILE, 'utf-8'));
+    }
+    catch {
+        return { assignments: {}, nextPort: INPROC_BASE_PORT };
+    }
+}
+/**
+ * Deterministic in-process control port for a device. Stable across calls so
+ * the launcher and any later `native-*` command agree without a discovery file.
+ */
+function getInprocPort(deviceId) {
+    const state = readState();
+    const existing = state.assignments[deviceId];
+    if (existing !== undefined)
+        return existing;
+    const port = state.nextPort;
+    state.assignments[deviceId] = port;
+    state.nextPort = port + 1;
+    fs_1.default.mkdirSync(path_1.default.dirname(PORT_FILE), { recursive: true });
+    fs_1.default.writeFileSync(PORT_FILE, JSON.stringify(state, null, 2));
+    return port;
+}
+/** HTTP/JSON client for the in-process control server. */
+class InprocClient {
+    constructor(port, host = '127.0.0.1') {
+        this.port = port;
+        this.host = host;
+    }
+    get(reqPath, timeoutMs = 5000) {
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.request({ hostname: this.host, port: this.port, path: reqPath, method: 'GET' }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    try {
+                        resolve(JSON.parse(Buffer.concat(chunks).toString('utf-8')));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+                res.on('error', reject);
+            });
+            req.setTimeout(timeoutMs, () => req.destroy(new Error('in-proc request timed out')));
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    ping(timeoutMs = 5000) {
+        return this.get('/ping', timeoutMs);
+    }
+    /** Full native view hierarchy with colors, fonts, text, and layer visuals. */
+    inspect(timeoutMs = 15000) {
+        return this.get('/inspect', timeoutMs);
+    }
+    /** Navigation / view-controller hierarchy (stacks, tabs, presented, titles). */
+    nav(timeoutMs = 15000) {
+        return this.get('/nav', timeoutMs);
+    }
+    /** Full property detail for one view (by id from inspect). */
+    view(id, timeoutMs = 8000) {
+        return this.get(`/view?id=${encodeURIComponent(id)}`, timeoutMs);
+    }
+    /** Live-set a whitelisted property on a view (alpha, backgroundColor, text, frame, …). */
+    set(id, key, value, timeoutMs = 8000) {
+        const q = `id=${encodeURIComponent(id)}&key=${encodeURIComponent(key)}&value=${encodeURIComponent(value)}`;
+        return this.get(`/set?${q}`, timeoutMs);
+    }
+    /** React Native Fabric props: typed ViewProps + the raw JS prop bag. */
+    props(id, timeoutMs = 8000) {
+        return this.get(`/props?id=${encodeURIComponent(id)}`, timeoutMs);
+    }
+    /** Auto Layout constraints affecting a view + ambiguity flag. */
+    constraints(id, timeoutMs = 8000) {
+        return this.get(`/constraints?id=${encodeURIComponent(id)}`, timeoutMs);
+    }
+    /** Topmost view at a window point, plus its ancestor chain. */
+    hittest(x, y, timeoutMs = 8000) {
+        return this.get(`/hittest?x=${x}&y=${y}`, timeoutMs);
+    }
+    /** Flash a highlight overlay over a view on the device. */
+    highlight(id, timeoutMs = 8000) {
+        return this.get(`/highlight?id=${encodeURIComponent(id)}`, timeoutMs);
+    }
+    /** Search views by class-name substring and/or text substring. */
+    find(q, timeoutMs = 10000) {
+        const parts = [];
+        if (q.className)
+            parts.push(`class=${encodeURIComponent(q.className)}`);
+        if (q.text)
+            parts.push(`text=${encodeURIComponent(q.text)}`);
+        return this.get(`/find?${parts.join('&')}`, timeoutMs);
+    }
+    /** PNG of the whole key window. */
+    screenshot(timeoutMs = 20000) {
+        return this.getBuffer('/screenshot', timeoutMs);
+    }
+    /**
+     * PNG of a single view in isolation — the texture for a 3D exploded-layer
+     * viewer. Default (`includeSubviews=false`) captures only this view's own
+     * content, so each node is a distinct transparent layer plane.
+     */
+    snapshot(id, includeSubviews = false, timeoutMs = 15000) {
+        const q = `id=${encodeURIComponent(id)}&subviews=${includeSubviews ? 'true' : 'false'}`;
+        return this.getBuffer(`/snapshot?${q}`, timeoutMs);
+    }
+    /**
+     * PNG crop of a window-absolute rect (use a node's `absFrame` from inspect).
+     * Composites whatever is drawn there — works for UIImageView, RN Fabric, etc.
+     */
+    image(frame, timeoutMs = 15000) {
+        return this.getBuffer(`/image?frame=${frame.x},${frame.y},${frame.w},${frame.h}`, timeoutMs);
+    }
+    /** Raw GET to any endpoint, parsed as JSON. */
+    rawJson(reqPath, timeoutMs = 15000) {
+        const path = reqPath.startsWith('/') ? reqPath : `/${reqPath}`;
+        return this.get(path, timeoutMs);
+    }
+    /** Raw GET to any endpoint — returns the content-type and bytes (json or image). */
+    rawRequest(reqPath, timeoutMs = 20000) {
+        const path = reqPath.startsWith('/') ? reqPath : `/${reqPath}`;
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.request({ hostname: this.host, port: this.port, path, method: 'GET' }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => resolve({ contentType: res.headers['content-type'] ?? '', body: Buffer.concat(chunks) }));
+                res.on('error', reject);
+            });
+            req.setTimeout(timeoutMs, () => req.destroy(new Error('in-proc request timed out')));
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    getBuffer(reqPath, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const req = http_1.default.request({ hostname: this.host, port: this.port, path: reqPath, method: 'GET' }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    const buf = Buffer.concat(chunks);
+                    const type = res.headers['content-type'] ?? '';
+                    if (!type.startsWith('image/')) {
+                        reject(new Error(`expected an image, got: ${buf.toString('utf-8').slice(0, 200)}`));
+                        return;
+                    }
+                    resolve(buf);
+                });
+                res.on('error', reject);
+            });
+            req.setTimeout(timeoutMs, () => req.destroy(new Error('in-proc image request timed out')));
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    /** True once the in-process server answers a ping (poll after an injected launch). */
+    async waitUntilReady(timeoutMs = 10000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                const res = await this.ping(1500);
+                if (res.status === 'ok')
+                    return true;
+            }
+            catch {
+                /* not up yet */
+            }
+            await new Promise((r) => setTimeout(r, 300));
+        }
+        return false;
+    }
+}
+exports.InprocClient = InprocClient;

package/dist/drivers/ios.js

@@ -89,14 +89,35 @@ class IOSDriver {
     invalidateHierarchyCache() {
         this.hierarchyCache = null;
     }
-    simctl(args) {
+    simctl(args, childEnv) {
         const _id = this.requireDeviceId();
         return new Promise((resolve, reject) => {
-            const proc = (0, child_process_1.spawn)('xcrun', ['simctl', ...args], { stdio: 'ignore' });
+            const proc = (0, child_process_1.spawn)('xcrun', ['simctl', ...args], {
+                stdio: 'ignore',
+                env: childEnv ? this.launchEnv(childEnv) : undefined,
+            });
             proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`xcrun simctl ${args[0]} failed (exit ${code})`)));
             proc.on('error', reject);
         });
     }
+    /**
+     * Build the env for a `simctl launch` that must forward vars into the target
+     * app. `simctl` copies `SIMCTL_CHILD_*` vars into the app's real environment at
+     * exec() — the only path dyld honours for restricted vars like
+     * DYLD_INSERT_LIBRARIES. Inherited SIMCTL_CHILD_* are stripped first so stale
+     * values (from a parent shell) can't override ours and silently break injection.
+     */
+    launchEnv(childEnv) {
+        const env = { ...process.env };
+        for (const key of Object.keys(env)) {
+            if (key.startsWith('SIMCTL_CHILD_'))
+                delete env[key];
+        }
+        for (const [key, value] of Object.entries(childEnv)) {
+            env[`SIMCTL_CHILD_${key}`] = value;
+        }
+        return env;
+    }
     simctlCapture(args) {
         this.requireDeviceId();
         return new Promise((resolve, reject) => {
@@ -167,15 +188,25 @@ class IOSDriver {
         });
         this.invalidateHierarchyCache();
     }
-    async launchApp(bundleId, args) {
-        if (args && Object.keys(args).length > 0) {
+    async launchApp(bundleId, args, inject) {
+        const argPairs = [];
+        for (const [key, value] of Object.entries(args ?? {})) {
+            argPairs.push(`-${key}`, value);
+        }
+        if (inject) {
+            // Injection requires simctl launch with SIMCTL_CHILD_ env — the XCTest
+            // /launchApp path only activates and can't set environment.
+            const deviceId = this.requireDeviceId();
+            await this.simctl(['terminate', deviceId, bundleId]).catch(() => { });
+            await this.simctl(['launch', '--terminate-running-process', deviceId, bundleId, ...argPairs], {
+                DYLD_INSERT_LIBRARIES: inject.dylibPath,
+                CONDUCTOR_INPROC_PORT: String(inject.inprocPort),
+            });
+        }
+        else if (argPairs.length > 0) {
             const deviceId = this.requireDeviceId();
             // xctest /launchApp doesn't support launch args — use simctl
             await this.simctl(['terminate', deviceId, bundleId]).catch(() => { });
-            const argPairs = [];
-            for (const [key, value] of Object.entries(args)) {
-                argPairs.push(`-${key}`, value);
-            }
             await this.simctl(['launch', '--terminate-running-process', deviceId, bundleId, ...argPairs]);
         }
         else {

package/dist/drivers/metro-scripts.js

@@ -16,6 +16,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeComponentTreeScript = makeComponentTreeScript;
+exports.makeOverridePropsScript = makeOverridePropsScript;
+exports.makeRnPropsScript = makeRnPropsScript;
 exports.makeInspectElementScript = makeInspectElementScript;
 /** RN internals + navigation/safe-area wrappers we always strip from the tree. */
 const SKIP_NAMES = [
@@ -289,6 +291,178 @@ function makeComponentTreeScript(requestId) {
     }
   })();`;
 }
+/**
+ * Shared JS: locate a host fiber by its native reactTag, across every registered
+ * renderer and both RN architectures (Paper `_nativeTag`/`canonical.nativeTag`,
+ * Fabric bridgeless `__nativeTag` on the state node / public instance). Defines
+ * `findByTag(hook, TAG)` returning `{ fiber, renderer }` or null.
+ */
+const FIBER_BY_TAG_HELPERS = `
+    function nativeTagOf(f) {
+      if (typeof f.type !== 'string' || !f.stateNode) return null;
+      var sn = f.stateNode;
+      if (typeof sn._nativeTag === 'number') return sn._nativeTag;
+      if (typeof sn.__nativeTag === 'number') return sn.__nativeTag;
+      if (sn.canonical) {
+        if (typeof sn.canonical.nativeTag === 'number') return sn.canonical.nativeTag;
+        var pi = sn.canonical.publicInstance;
+        if (pi && typeof pi.__nativeTag === 'number') return pi.__nativeTag;
+      }
+      if (sn.node && typeof sn.node.__nativeTag === 'number') return sn.node.__nativeTag;
+      return null;
+    }
+    function findHostByTag(root, TAG) {
+      var stack = [root.current || root], seen = 0;
+      while (stack.length && seen < 40000) {
+        var f = stack.pop(); seen++;
+        if (!f) continue;
+        if (nativeTagOf(f) === TAG) return f;
+        if (f.sibling) stack.push(f.sibling);
+        if (f.child) stack.push(f.child);
+      }
+      return null;
+    }
+    function findByTag(hook, TAG) {
+      var entries = [];
+      hook.renderers.forEach(function(r, id) { entries.push([id, r]); });
+      for (var i = 0; i < entries.length; i++) {
+        var id = entries[i][0], r = entries[i][1], roots = null;
+        try { roots = hook.getFiberRoots(id); } catch (e) {}
+        if (!roots) continue;
+        var arr = Array.from(roots);
+        for (var j = 0; j < arr.length; j++) {
+          var hf = findHostByTag(arr[j], TAG);
+          if (hf) return { fiber: hf, renderer: r };
+        }
+      }
+      return null;
+    }`;
+/**
+ * Live-edit props via React DevTools' `overrideProps(fiber, path, value)` — the
+ * same call the DevTools "edit prop" UI makes. Maps `reactTag` → host fiber, then
+ * picks the fiber that owns the top-level path key (for `children`, prefers the
+ * composite `<Text>` ancestor, so the visible string changes). Returns a JSON
+ * string: `{status:'ok',applied:true}` or `{status:'error',message}`.
+ */
+function makeOverridePropsScript(reactTag, path, valueJson) {
+    return `(function() {
+    try {
+      var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook || !hook.renderers || !hook.getFiberRoots) {
+        return JSON.stringify({ status: 'error', message: 'No React DevTools hook — not a dev/debug build?' });
+      }
+      var TAG = ${JSON.stringify(reactTag)};
+      var PATH = ${JSON.stringify(path)};
+      var VALUE = ${valueJson};
+      ${FIBER_BY_TAG_HELPERS}
+      var hit = findByTag(hook, TAG);
+      if (!hit) return JSON.stringify({ status: 'error', message: 'no fiber for reactTag ' + TAG });
+      var renderer = hit.renderer;
+      if (!renderer || typeof renderer.overrideProps !== 'function') {
+        return JSON.stringify({ status: 'error', message: 'renderer has no overrideProps — is this a dev build?' });
+      }
+      // Pick the fiber that owns the top path key. For 'children' prefer the
+      // nearest fiber whose children is a string (the renderable <Text>/RCTText),
+      // so overriding actually swaps the visible glyphs.
+      var key = PATH[0];
+      var cur = hit.fiber, hops = 0, fallback = null;
+      while (cur && hops < 10) {
+        var p = cur.memoizedProps;
+        if (p && typeof p === 'object' && Object.prototype.hasOwnProperty.call(p, key)) {
+          if (fallback === null) fallback = cur;
+          if (key !== 'children') { fallback = cur; break; }
+          if (typeof p.children === 'string') { fallback = cur; break; }
+        }
+        cur = cur.return; hops++;
+      }
+      var target = fallback || hit.fiber;
+      // RN styles are often arrays (StyleSheet composition). overrideProps' setIn
+      // can't create missing intermediates, and a key set on the array object is
+      // ignored by flattening — so for a 'style.<key>' path we flatten the current
+      // style to a plain object (what RN does anyway), apply the override, and set
+      // the whole 'style'. Works whether style started as an object or an array.
+      if (PATH[0] === 'style' && PATH.length >= 2) {
+        function flattenStyle(s) {
+          var acc = {};
+          (function merge(x) {
+            if (!x) return;
+            if (Array.isArray(x)) { for (var i = 0; i < x.length; i++) merge(x[i]); return; }
+            if (typeof x === 'object') { for (var k in x) if (Object.prototype.hasOwnProperty.call(x, k)) acc[k] = x[k]; }
+          })(s);
+          return acc;
+        }
+        var flat = flattenStyle(target.memoizedProps && target.memoizedProps.style);
+        var keys = PATH.slice(1), o = flat;
+        for (var i = 0; i < keys.length - 1; i++) {
+          if (typeof o[keys[i]] !== 'object' || o[keys[i]] === null) o[keys[i]] = {};
+          o = o[keys[i]];
+        }
+        o[keys[keys.length - 1]] = VALUE;
+        renderer.overrideProps(target, ['style'], flat);
+        return JSON.stringify({ status: 'ok', applied: true, note: 'style flattened to object; override applied' });
+      }
+      renderer.overrideProps(target, PATH, VALUE);
+      return JSON.stringify({ status: 'ok', applied: true });
+    } catch (e) {
+      return JSON.stringify({ status: 'error', message: String((e && e.message) || e) });
+    }
+  })();`;
+}
+/**
+ * Dump a host fiber's `memoizedProps` (the real JSX props RN passed to the native
+ * view — the JS-side analog of the native `/props` rawProps that Fabric drops).
+ * Functions become `"[Function: name]"`; cycles/over-depth become markers.
+ * Returns a JSON string `{status:'ok',props:{...}}` or `{status:'error',message}`.
+ */
+function makeRnPropsScript(reactTag) {
+    return `(function() {
+    try {
+      var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook || !hook.renderers || !hook.getFiberRoots) {
+        return JSON.stringify({ status: 'error', message: 'No React DevTools hook — not a dev/debug build?' });
+      }
+      var TAG = ${JSON.stringify(reactTag)};
+      ${FIBER_BY_TAG_HELPERS}
+      var hit = findByTag(hook, TAG);
+      if (!hit) return JSON.stringify({ status: 'error', message: 'no fiber for reactTag ' + TAG });
+      var seen = [];
+      function ser(v, depth) {
+        if (v === null || v === undefined) return v === undefined ? undefined : null;
+        var t = typeof v;
+        if (t === 'string' || t === 'boolean') return v;
+        if (t === 'number') return isFinite(v) ? v : String(v);
+        if (t === 'function') return '[Function: ' + (v.name || 'anonymous') + ']';
+        if (t === 'symbol') return v.toString();
+        if (t === 'bigint') return String(v) + 'n';
+        if (t === 'object') {
+          if (depth > 6) return '[Object: max depth]';
+          if (seen.indexOf(v) !== -1) return '[Circular]';
+          if (v && v.$$typeof) return '[ReactElement]';
+          seen.push(v);
+          var out;
+          if (Array.isArray(v)) {
+            out = [];
+            for (var i = 0; i < v.length && i < 200; i++) out.push(ser(v[i], depth + 1));
+          } else {
+            out = {};
+            var keys = Object.keys(v);
+            for (var k = 0; k < keys.length; k++) {
+              var val = ser(v[keys[k]], depth + 1);
+              if (val !== undefined) out[keys[k]] = val;
+            }
+          }
+          seen.pop();
+          return out;
+        }
+        return String(v);
+      }
+      var props = ser(hit.fiber.memoizedProps || {}, 0);
+      return JSON.stringify({ status: 'ok', props: props });
+    } catch (e) {
+      return JSON.stringify({ status: 'error', message: String((e && e.message) || e) });
+    }
+  })();`;
+}
 /**
  * Inspect-at-point script. Uses React DevTools's own
  * `renderer.rendererConfig.getInspectorDataForViewAtPoint(inspectRef, x, y, cb)`,

package/dist/index.js

@@ -9,6 +9,8 @@ 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 native_js_1 = require("./commands/native.js");
+const native_rn_js_1 = require("./commands/native-rn.js");
 const stop_app_js_1 = require("./commands/stop-app.js");
 const clear_state_js_1 = require("./commands/clear-state.js");
 const uninstall_app_js_1 = require("./commands/uninstall-app.js");
@@ -27,6 +29,7 @@ const run_flow_inline_js_1 = require("./commands/run-flow-inline.js");
 const press_key_js_1 = require("./commands/press-key.js");
 const session_js_1 = require("./commands/session.js");
 const daemon_js_1 = require("./commands/daemon.js");
+const input_server_js_1 = require("./commands/input-server.js");
 const install_js_1 = require("./commands/install.js");
 const init_js_1 = require("./commands/init.js");
 const device_pool_js_1 = require("./commands/device-pool.js");
@@ -80,6 +83,27 @@ const COMMAND_HELP = {
     'download-app': download_app_js_1.HELP,
     'install-app': install_app_js_1.HELP,
     'launch-app': launch_app_js_1.HELP,
+    'native-ping': native_js_1.PING_HELP,
+    'native-inspect': native_js_1.INSPECT_HELP,
+    'native-nav': native_js_1.NAV_HELP,
+    'native-screenshot': native_js_1.SCREENSHOT_HELP,
+    'native-image': native_js_1.IMAGE_HELP,
+    'native-snapshot': native_js_1.SNAPSHOT_HELP,
+    'native-view': native_js_1.VIEW_HELP,
+    'native-set': native_js_1.SET_HELP,
+    'native-props': native_js_1.PROPS_HELP,
+    'native-rn-set': native_rn_js_1.RN_SET_HELP,
+    'native-rn-props': native_rn_js_1.RN_PROPS_HELP,
+    'native-constraints': native_js_1.CONSTRAINTS_HELP,
+    'native-hittest': native_js_1.HITTEST_HELP,
+    'native-highlight': native_js_1.HIGHLIGHT_HELP,
+    'native-find': native_js_1.FIND_HELP,
+    'native-raw': native_js_1.RAW_HELP,
+    'native-console': native_js_1.CONSOLE_HELP,
+    'native-network': native_js_1.NETWORK_HELP,
+    'native-heap': native_js_1.HEAP_HELP,
+    'native-appearance': native_js_1.APPEARANCE_HELP,
+    'native-eval': native_js_1.EVAL_HELP,
     'stop-app': stop_app_js_1.HELP,
     'clear-state': clear_state_js_1.HELP,
     'uninstall-app': uninstall_app_js_1.HELP,
@@ -110,6 +134,7 @@ const COMMAND_HELP = {
     'daemon-start': daemon_js_1.HELP_DAEMON_START,
     'daemon-stop': daemon_js_1.HELP_DAEMON_STOP,
     'daemon-status': daemon_js_1.HELP_DAEMON_STATUS,
+    'input-server': input_server_js_1.HELP,
     'device-pool': device_pool_js_1.HELP,
     'run-parallel': run_parallel_js_1.HELP,
     'run-sequence': run_sequence_js_1.HELP,
@@ -240,6 +265,9 @@ async function main() {
             'cdp-url',
             'cdp-target',
             'duration',
+            'react-tag',
+            'path',
+            'value',
         ],
         alias: { h: 'help', v: 'verbose', V: 'version', o: 'output', y: 'yes' },
     });
@@ -370,6 +398,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':
@@ -423,9 +452,119 @@ async function main() {
                 clearKeychain: argv['clear-keychain'],
                 stopApp: argv['stop-app'] !== false,
                 launchArgs,
+                inject: argv['inject'],
             });
             break;
         }
+        case 'native-ping': {
+            exitCode = await (0, native_js_1.nativePing)(opts, sessionName);
+            break;
+        }
+        case 'native-inspect': {
+            exitCode = await (0, native_js_1.nativeInspect)(opts, sessionName);
+            break;
+        }
+        case 'native-nav': {
+            exitCode = await (0, native_js_1.nativeNav)(opts, sessionName);
+            break;
+        }
+        case 'native-screenshot': {
+            exitCode = await (0, native_js_1.nativeScreenshot)(argv['output'], opts, sessionName);
+            break;
+        }
+        case 'native-image': {
+            exitCode = await (0, native_js_1.nativeImage)(rest[0], argv['output'], opts, sessionName);
+            break;
+        }
+        case 'native-snapshot': {
+            exitCode = await (0, native_js_1.nativeSnapshot)(rest[0], argv['with-subviews'], argv['output'], opts, sessionName);
+            break;
+        }
+        case 'native-view': {
+            exitCode = await (0, native_js_1.nativeView)(rest[0], opts, sessionName);
+            break;
+        }
+        case 'native-set': {
+            exitCode = await (0, native_js_1.nativeSet)(rest, opts, sessionName);
+            break;
+        }
+        case 'native-props': {
+            exitCode = await (0, native_js_1.nativeProps)(rest[0], opts, sessionName);
+            break;
+        }
+        case 'native-rn-set': {
+            const rnOpts = {
+                port: argv['port'] !== undefined ? Number(argv['port']) : undefined,
+                targetIndex: argv['target'] !== undefined ? Number(argv['target']) : undefined,
+            };
+            exitCode = await (0, native_rn_js_1.nativeRnSet)({
+                reactTag: argv['react-tag'],
+                path: argv['path'],
+                value: argv['value'],
+            }, opts, sessionName, rnOpts);
+            break;
+        }
+        case 'native-rn-props': {
+            const rnOpts = {
+                port: argv['port'] !== undefined ? Number(argv['port']) : undefined,
+                targetIndex: argv['target'] !== undefined ? Number(argv['target']) : undefined,
+            };
+            exitCode = await (0, native_rn_js_1.nativeRnProps)({ reactTag: argv['react-tag'] }, opts, sessionName, rnOpts);
+            break;
+        }
+        case 'native-constraints': {
+            exitCode = await (0, native_js_1.nativeConstraints)(rest[0], opts, sessionName);
+            break;
+        }
+        case 'native-hittest': {
+            exitCode = await (0, native_js_1.nativeHittest)(rest[0], opts, sessionName);
+            break;
+        }
+        case 'native-highlight': {
+            exitCode = await (0, native_js_1.nativeHighlight)(rest[0], opts, sessionName);
+            break;
+        }
+        case 'native-find': {
+            exitCode = await (0, native_js_1.nativeFind)({
+                className: argv['class'],
+                text: argv['text'],
+            }, opts, sessionName);
+            break;
+        }
+        case 'native-raw': {
+            exitCode = await (0, native_js_1.nativeRaw)(rest[0], argv['output'], opts, sessionName);
+            break;
+        }
+        case 'native-console': {
+            exitCode = await (0, native_js_1.nativeConsole)(argv['since'] !== undefined ? Number(argv['since']) : undefined, opts, sessionName);
+            break;
+        }
+        case 'native-network': {
+            exitCode = await (0, native_js_1.nativeNetwork)(argv['since'] !== undefined ? Number(argv['since']) : undefined, opts, sessionName);
+            break;
+        }
+        case 'native-heap': {
+            exitCode = await (0, native_js_1.nativeHeap)({
+                className: argv['class'],
+                pattern: argv['pattern'],
+                read: argv['read'],
+                key: argv['key'],
+            }, opts, sessionName);
+            break;
+        }
+        case 'native-appearance': {
+            exitCode = await (0, native_js_1.nativeAppearance)({
+                style: rest[0],
+                direction: argv['direction'],
+                contentSize: argv['content-size'],
+                animSpeed: argv['anim-speed'],
+            }, opts, sessionName);
+            break;
+        }
+        case 'native-eval': {
+            exitCode = await (0, native_js_1.nativeEval)(rest.join(' '), argv['mode'] === 'full' ? 'full' : 'expr', opts, sessionName);
+            break;
+        }
         case 'stop-app': {
             const appId = rest[0];
             exitCode = await (0, stop_app_js_1.stopApp)(appId, opts, sessionName);
@@ -705,6 +844,9 @@ async function main() {
         case 'daemon-status':
             exitCode = await (0, daemon_js_1.daemonStatusCmd)(opts, sessionName);
             break;
+        case 'input-server':
+            exitCode = await (0, input_server_js_1.inputServer)(opts, sessionName);
+            break;
         case 'device-pool': {
             const acquire = argv['acquire'];
             const release = argv['release'];