@houwert/conductor 0.24.1 → 0.26.0

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,8 @@ 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 stream_server_js_1 = require("./commands/stream-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 +84,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 +135,8 @@ 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,
+    'stream-server': stream_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 +267,9 @@ async function main() {
             'cdp-url',
             'cdp-target',
             'duration',
+            'react-tag',
+            'path',
+            'value',
         ],
         alias: { h: 'help', v: 'verbose', V: 'version', o: 'output', y: 'yes' },
     });
@@ -424,9 +454,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);
@@ -706,6 +846,12 @@ 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 'stream-server':
+            exitCode = await (0, stream_server_js_1.streamServer)(opts, sessionName);
+            break;
         case 'device-pool': {
             const acquire = argv['acquire'];
             const release = argv['release'];

package/dist/runner.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectFirstDevice = detectFirstDevice;
 exports.getDriver = getDriver;
 exports.prewarmDriver = prewarmDriver;
+exports.inputServerInfo = inputServerInfo;
+exports.streamServerInfo = streamServerInfo;
 exports.runDirect = runDirect;
 exports.spawnCommand = spawnCommand;
 exports.runInlineFlow = runInlineFlow;
@@ -243,6 +245,82 @@ async function prewarmDriver(deviceId) {
         /* best-effort: a later command will report a real failure */
     }
 }
+/**
+ * Resolve the streaming-input socket for a session's device, starting the
+ * daemon (and its driver + input server) if needed. Returns the loopback
+ * WebSocket URL the host IDE connects to. Throws if the platform has no
+ * streaming input (web/vega) or the port never comes up.
+ */
+async function inputServerInfo(sessionName = 'default') {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        throw new Error('No device found. Connect a device or start a simulator, then run again.');
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform !== 'ios' && platform !== 'tvos' && platform !== 'android') {
+        throw new Error(`Streaming input is not available for ${platform} devices.`);
+    }
+    await (0, client_js_1.startDaemon)(deviceId);
+    // The input server starts just after the driver — poll status until its port appears.
+    const deadline = Date.now() + 60000;
+    while (Date.now() < deadline) {
+        const status = await (0, client_js_1.fetchDaemonStatus)(deviceId);
+        if (status && typeof status.inputPort === 'number') {
+            return {
+                device: deviceId,
+                platform,
+                inputPort: status.inputPort,
+                url: `ws://127.0.0.1:${status.inputPort}/input`,
+            };
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`Input server for ${deviceId} did not come up within timeout.`);
+}
+/**
+ * Resolve the streaming-video socket for a session's device, starting the
+ * daemon (and its driver + video server) if needed. Returns the loopback
+ * WebSocket URL a viewer subscribes to. Throws if the platform has no live
+ * stream, the capture binary isn't built, or the port never comes up.
+ */
+async function streamServerInfo(sessionName = 'default') {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        throw new Error('No device found. Connect a device or start a simulator, then run again.');
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    if (platform !== 'ios' && platform !== 'tvos') {
+        throw new Error(`Live video streaming is not yet available for ${platform} devices.`);
+    }
+    await (0, client_js_1.startDaemon)(deviceId);
+    // The video server starts just after the input server — poll status until its port appears.
+    const start = Date.now();
+    const deadline = start + 60000;
+    while (Date.now() < deadline) {
+        const status = await (0, client_js_1.fetchDaemonStatus)(deviceId);
+        if (status && typeof status.streamPort === 'number') {
+            return {
+                device: deviceId,
+                platform,
+                streamPort: status.streamPort,
+                url: `ws://127.0.0.1:${status.streamPort}/stream?device=${encodeURIComponent(deviceId)}&platform=${platform}`,
+                codec: 'h264',
+            };
+        }
+        // A daemon whose input server is up but that still reports no streamPort
+        // after a grace period means the capture binary isn't built/available —
+        // fail fast rather than waiting out the full timeout.
+        if (status &&
+            status.streamPort === null &&
+            typeof status.inputPort === 'number' &&
+            Date.now() - start > 5000) {
+            throw new Error(`Video capture backend is not available for ${deviceId} ` +
+                `(the conductor-capture binary is missing from the installed drivers).`);
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`Video server for ${deviceId} did not come up within timeout.`);
+}
 /**
  * Execute a function with the driver for the given session.
  * Returns a RunResult for consistent error handling across commands.

package/package.json

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

package/skills/conductor-device-interact/SKILL.md

@@ -51,6 +51,34 @@ conductor assert-visible "Dashboard"
 | `conductor gesture <json\|--file path>` | Play a multi-touch path |
 | `conductor clipboard read` / `clipboard write <text>` / `paste` | Clipboard (iOS) |
 | `conductor list-options [command]` | List valid values for enumerated params |
+| `conductor input-server` | Start (if needed) and print the streaming-input WebSocket URL for the device |
+| `conductor stream-server` | Start (if needed) and print the live video-stream WebSocket URL for the device |
+
+## Streaming input (host IDEs)
+
+For continuous, low-latency input (live drags, fast typing) a host IDE can open
+one persistent WebSocket per device instead of spawning a command per event.
+`conductor input-server` ensures the daemon + driver are up and prints the
+loopback URL (`ws://127.0.0.1:<port>/input`; also in `daemon-status --json` as
+`inputPort`). The server sends a `hello` with per-platform capabilities, then
+accepts normalized (0..1) frames: `pointer{id,phase,x,y}`, `key{code,mods,down}`,
+`text{value}`, `button{name}`, `scroll{x,y,dx,dy}`, `tvremote{button}`. Conductor
+owns coord→device translation and keymaps. For scripted, one-off actions use the
+discrete commands above — this is for interactive host UIs.
+
+## Streaming video (host IDEs / device viewers)
+
+For live device mirroring, `conductor stream-server` ensures the daemon + capture
+backend are up and prints the loopback URL
+(`ws://127.0.0.1:<port>/stream?device=<id>&platform=<ios|tvos|android|web>`; also
+in `daemon-status --json` as `streamPort`). One capture fans out to N subscribers.
+On connect the server sends a JSON `config` frame
+(`{t:"config",codec:"h264",width,height,rotation,fps,sps,pps,avcC,codecString}`),
+then **binary** frames — each one H.264 Annex B access unit, keyframe-led; a late
+joiner gets the cached config + a keyframe immediately. iOS/tvOS only for now
+(host-side SimulatorKit → VideoToolbox capture); Android/web are follow-ons.
+This is capture only — input stays on `input-server`. For a still image use
+`screenshot` / `capture-ui`; this socket is for continuous low-latency mirroring.
 
 ## Discovering valid values
 

package/skills/conductor-device-setup/SKILL.md

@@ -74,7 +74,7 @@ screen recording, clipboard, `clear-state`/`uninstall-app`.
 | Command                                               | Purpose                                                                |
 | ----------------------------------------------------- | ---------------------------------------------------------------------- |
 | `conductor install-app <path>`                        | Install .app / .ipa / .apk                                             |
-| `conductor launch-app <appId>`                        | Launch app (saved to session); `--no-stop-app`, `--argument key=value` |
+| `conductor launch-app <appId>`                        | Launch app (saved to session); `--no-stop-app`, `--argument key=value`, `--inject` |
 | `conductor stop-app [<appId>]`                        | Stop app                                                               |
 | `conductor uninstall-app <appId>`                     | Uninstall app                                                          |
 | `conductor copy-app <bundleId> --from <id> --to <id>` | Copy an installed app between iOS simulators                           |

package/skills/conductor-inspect/SKILL.md

@@ -29,6 +29,49 @@ conductor capture-ui --output /tmp/screen.json
 conductor tap-on @e5
 ```
 
+## Native in-process inspection (iOS/tvOS simulator)
+
+The commands above observe the app **externally** (accessibility snapshots), so
+they can't see real component colors, fonts, or the view-controller stack. When
+you need that native detail, launch the app with an injected in-process library
+and use the `native-*` commands. Requires `launch-app <appId> --inject` first
+(iOS/tvOS simulator only).
+
+| Command | Purpose |
+|---|---|
+| `conductor native-ping` | Verify the injected in-process control library is alive |
+| `conductor native-inspect` | Real UIView/CALayer tree: resolved colors (`#RRGGBBAA`), fonts, text (incl. React Native Fabric), corner radius, borders, shadows, gradients, and each node's `absFrame` |
+| `conductor native-nav` | Navigation state: `UINavigationController` stacks, tab selection, presented controllers, titles |
+| `conductor native-screenshot --output <p.png>` | In-process PNG of the key window |
+| `conductor native-image <x,y,w,h> --output <p.png>` | Extract a component as a PNG — pass a node's `absFrame` from `native-inspect` |
+| `conductor native-snapshot <id> --output <p.png>` | Isolated PNG of one view's own content (transparent) — per-layer texture for a 3D explosion; `--with-subviews` composites the subtree |
+| `conductor native-console [--since <n>]` / `native-network [--since <n>]` | App stdout/stderr + captured HTTP; poll with the returned `cursor` |
+| `conductor native-heap --pattern <s> \| --class <name> \| --read <addr> [--key <keyPath>]` | Live-object browser (find classes/instances, read a property off an address) |
+| `conductor native-appearance <light\|dark\|system> \| --direction <ltr\|rtl> \| --anim-speed <n>` | Force appearance / RTL / freeze animations app-wide |
+| `conductor native-eval '<swift>'` | Compile & run arbitrary Swift inside the app (full UIKit / ObjC-runtime access); `--mode full` for a whole function body. e.g. `native-eval 'UIScreen.main.bounds'` |
+| `conductor native-raw <path>` | Escape hatch — GET any in-process endpoint (e.g. `'/get?id=..&keyPath=layer.cornerRadius'`, `'/class?id=..'`, `'/responders?id=..'`, `'/swiftui'`, `'/defaults'`, `'/focus'`, `'/snapshots?scale=0.5'`). Full list in `packages/ios-inproc/README.md`. |
+| `conductor native-view <id>` | Full property detail for one view (class chain, transform, layer, gestures, text/font) |
+| `conductor native-set <id> <key> <value>` | **Live-edit** a property: alpha, hidden, backgroundColor, tintColor, cornerRadius, borderWidth, borderColor, frame, text, textColor. `text`/`textColor` work on RN Fabric text views too |
+| `conductor native-props <id>` | React Native Fabric props: typed `ViewProps` + the raw JS prop bag (Fabric host views only) |
+
+> **Editing RN Fabric text/props:** the native plane can't set text on `RCTParagraphComponentView` (no native setter) and `native-props` returns `rawProps: null` on Fabric. Edit through React instead with `conductor native-rn-set --react-tag <n> --path children --value '"…"'` (and read raw JSX props with `native-rn-props --react-tag <n>`). `reactTag` comes from this tree's `rn.reactTag`. See the conductor-metro-debugger skill. Dev builds only.
+| `conductor native-constraints <id>` | Auto Layout constraints affecting a view + ambiguity |
+| `conductor native-hittest <x,y>` | Topmost view at a point + ancestor chain (select-by-point) |
+| `conductor native-highlight <id>` | Flash a highlight over the view on the device |
+| `conductor native-find [--class <name>] [--text <s>]` | Search views by class and/or text |
+
+Every `native-inspect` node has a stable `id` (for this launch). The Reveal-style loop:
+inspect → pick an `id` → `native-view` for detail → `native-set` to edit live → see it
+on the device. IDs are pointer-based and reset each launch, so re-inspect after relaunch.
+
+```bash
+conductor launch-app com.example.app --inject
+conductor native-inspect                              # tree with ids, colors, fonts, absFrame
+conductor native-view 0x10280d0c0                     # full detail for a view
+conductor native-set 0x10280d0c0 backgroundColor '#FF3B30FF'   # live-edit, visible on device
+conductor native-image 816,286,288,288 --output /tmp/avatar.png
+```
+
 ## Assertions
 
 | Command | Purpose |

package/skills/conductor-metro-debugger/SKILL.md

@@ -18,6 +18,16 @@ Playwright web.
 | `conductor debug component-tree [--port N]` | On-screen React component tree |
 | `conductor debug inspect-element <x,y>` | React component at a screen point |
 | `conductor debug log-registry [--source metro]` | Summarize recent Metro/Hermes console logs |
+| `conductor native-rn-set --react-tag <n> --path <dot.path> --value <json>` | Live-edit an RN component's props via React DevTools `overrideProps` (text via `--path children`, color via `--path style.color`). Dev builds only |
+| `conductor native-rn-props --react-tag <n>` | Raw JSX props (`memoizedProps`) of an RN fiber by reactTag — the JS-side truth for Fabric where native `/props` `rawProps` is null |
+
+`--react-tag` comes from `native-inspect`'s `rn.reactTag`. `--value` is JSON (a bare
+string works for text). `--path` is a dot path into props: `children`, `style.color`,
+`style.fontSize`, `accessibilityLabel`. `style.color` works whether the component's
+`style` is an object or a composed array. These drive React itself over Metro CDP, so
+they need a **dev/debug build** (the DevTools backend must be active) and a running
+Metro; on a release build they return a clear "not a dev build" error. Output is
+`{"status":"ok","applied":true}` or `{"status":"error","message":"…"}`.
 
 ## Logs