rn-devtools-hub

Moves the frozen clock forward by ms. It moves the clock, it does NOT fire pending timers: driving the scheduler would mean replacing setTimeout under a running app.

Checks runtime evidence. network_response RETRIES until timeoutMs for an observed response matching required urlContains, method and status; mocked responses require allowMocked:true. Success carries the response evidence. network_ok means only no observed network error, never that a request completed. Negative event assertions require current capture coverage; unavailable coverage returns ok:false, conclusive:false. no_crash covers captured JS errors and rejections, not native crashes. Element kinds (visible, absent, text, count) retry until timeoutMs. Scope events with since from before the action, or windowMs; settleMs delays negative checks.

Compares what React renders with what the OS exposes and reports the DIFFERENCE: pressables with no accessible name, and text or controls missing from the accessibility tree. A tool with only the accessibility tree cannot find what is missing from it. Returns conclusive:false rather than a clean report when either tree came back empty.

Boots an iOS simulator by target id (sim:<udid>) and opens the Simulator app. Android emulators must be started externally.

Builds the app by delegating to expo run:ios, expo run:android or eas build, and streams the build's failures onto the SAME timestamped bus as the crashes and the requests. Compile error at t0, relaunch at t1, first JS crash at t2, one clock: the agent reads a continuous stream from broken code to running app. xcodebuild and gradle are delegated to, never reimplemented.

Captures the App Store and Play Store screenshots from the running app, driven by a manifest (devices from list_targets, locales, screens). Each screen is reached with the app's own dev actions (nav:*, seed:*, auth:*) and waited on with an event rather than a sleep, so the same set can be regenerated identically next release. Files are written to disk at the device's native resolution and NOTHING is resized: the answer is a manifest of paths and sizes, never the images, so this costs no context. Reports the sizes it does not recognise instead of uploading them as the wrong device class. Upload with asc_upload_screenshots and gplay_upload_screenshots.

Compares the current screen with a named baseline and EXPLAINS the difference: the changed ratio, the bounding box, the component that owns that region with its source file and line, and what the event bus recorded since the baseline. A percentage alone says something moved; this says what to edit.

Exports runtime actions and subsequent observed events. attribution:temporal means ordering, not proven causality; review background traffic before using the recording as a test. format:mcp returns replay calls, text a readable script, json the structure. Recorded failures make clean:false.

Exports one session as a single correlated artifact: network, console, crashes, navigation and UI changes on ONE timeline relative to the session start, plus the crash, failed-request and console-error sections an investigation opens first. Omit sessionId for the most recent session. format:"markdown" pastes into a GitHub issue as it is; format:"json" is for further processing.

Freezes the app's JS clock at an ISO instant (or now), so relative dates and time-dependent rendering stop drifting between runs. Deterministic at the JS level only: Date, new Date() and Date.now(). Native animations and Reanimated read native clocks and are unaffected.

Reads the accessibility tree the OS exposes, which is what assistive technology and any external automation see. Works when the React runtime cannot be reached (release build, WebView, native screen, splash). Android uses uiautomator; iOS needs AXe installed. Every node carries source:"accessibility" so it is never confused with a React node.

Returns app, device, OS, development mode and network connection information.

Reports what the selected app attached and the exact SDK call that enables each missing capability.

Returns recent crashes and unhandled errors.

Computes calls, errors and p50/p95 latencies per endpoint from the captured requests. With nothing captured it returns {endpoints: [], capture} instead, where capture says whether the network is instrumented at all.

Returns device events after a cursor (monotonic seq). Poll with the returned cursor to follow network, console, crash, nav, screen.ready and ui.change without missing anything. Omit cursor for the most recent events.

Reads and validates one project-relative .hubflow scenario.

Returns captured JavaScript console entries filtered by level, text and cursor.

Native device logs the JS console cannot see, with looping duplicates collapsed. Android: bounded logcat dump, fast (filter by app package via process). iOS: unified log dump of the last sinceMinutes (default 1); SLOW, roughly 10-30 s per minute of window, so keep the window small and filter by process. Catches crashes before the bundle loads and dev-client startup issues.

Reads the current rotation (Android).

Says whether the expo-dev-menu floating button is currently shown, and returns the dev-menu preferences behind it.

Returns what the project DECLARES (installed versions, Expo SDK, New Architecture, JS engine, plugins), what the app ACTUALLY runs (engine, Fabric, bridgeless, TurboModules, native React Native version, mounted React renderer), and the contradictions between the two. The divergence block catches stale native builds, Expo Go running a plugin project and release bundles before any other debugging.

Returns recent network events and explains whether an empty result means quiet traffic or missing instrumentation.

Reads a store the app registered with devtools.registerStore (Zustand, Redux, React Query or a custom adapter). Omit store to list what is available. path drills in with dots; for React Query it is the JSON query key.

Returns the visible React semantic tree with props, measured rectangles and source locations. Requires attachUiAutomation.

Installs an app bundle on the target (simctl install / adb install -r).

Launches the app with zero dialogs and nothing floating over the screen. iOS: simctl launch with --initialUrl (dev-client loads the given Metro URL directly, no deep link). Android: explicit-component am start with the URL as VIEW data. coldStart terminates first; the expo dev-menu onboarding is skipped automatically, and its floating action button is hidden (iOS), because it sits in its own window, is therefore invisible to get_ui_tree, and swallows taps meant for the buttons underneath it.

Lists the dev actions the app registered (name, label, description, argsSchema, danger). Conventions: nav:* navigate directly to a screen, auth:* instant sessions, seed:* fixtures, reset:* deterministic state.

Lists the React Native devices known to the hub and their connection state.

Lists versioned .hubflow scenarios in tests/hub with their latest local run.

Lists the hub plugins, which reach the services around the app rather than the app itself (App Store Connect, Google Play). For each one: whether it is configured, which tools it exposes, which of them CHANGE something (writeTools) and whether writes are enabled, the exact configuration keys still missing and where to set them, and every host it will contact. A plugin with no credentials exposes no tool at all, so this is the only place its tools are visible before it is set up. Credentials are never returned, only whether they are set and where they came from.

Lists the components the app registered with devtools.registerPreview, and whether the preview outlet is mounted.

Lists the persisted sessions, most recent first. Sessions survive hub restarts and app reloads, so an investigation can start long after the run it is about.

Lists OS-level targets: iOS simulators (simctl) and Android devices/emulators (adb), with their boot state. Native tools take these targets, distinct from the JS deviceId of list_devices.

Controls the requests going through the instrumented fetch: rules to stub a status and a body, or a condition among normal, offline, 3g and flaky. Failures are spaced deterministically rather than randomly, so a flaky profile stays reproducible. Mocked responses are flagged on the bus so an agent never mistakes a fixture for the backend. Only covers wrapFetch; an axios instance keeps its own adapter.

Opens a deep link on the target (simctl openurl / am start VIEW). On Android pass appId to pin the handler and avoid the chooser.

Writes a sibling .candidate.hubflow for a failed target only when recorded identity evidence strongly matches a reported candidate. It never changes assertions or the original file.

Runs a SQLite SELECT or PRAGMA query on the connected device.

Finds visible elements by semantic selector and returns values, rectangles and source locations. Retries until timeoutMs.

Mounts a registered component INSIDE the running app, under its real providers, session and cache: nothing to mock, unlike an isolated preview. Returns the measured rect and the rendered subtree. Verifying a component no longer means navigating to the screen that contains it.

Restores adb reverse mappings lost after an emulator or USB reconnection. Defaults to Metro 8081 and the current Hub port. Omit target only when exactly one Android target is ready.

Retries Metro symbolication for a source that remained via stack after the short inline budget expired. This is separate so source enrichment never delays a successful UI action.

Gives the app its real clock back.

Runs an action declared by the app with optional typed args (e.g. nav:packageDetail {id}). Discover actions and their schemas with list_actions. Dangerous actions must be confirmed in the MCP client.

Runs a validated .hubflow with explicit expectations and writes screenshots and a human-readable report under .rn-devtools. Recorded event association is temporal, not proven causality.

Saves the current action and consequence recording as a versioned .hubflow file under tests/hub by default.

Pixel screenshot of the target screen (PNG), complementing get_ui_tree: the tree gives structure, this gives the actual rendering.

Simulates a remote push notification on an iOS simulator (simctl push). payload is the APNs JSON with a top-level aps key. Rendering still depends on the app having notification permission.

One-call bootstrap and app switch: resolve target, pre-grant permissions, launch the dev build on the given Metro server, then wait for the expected app to connect. Pass appName when several runtimes share the hub so an event from the wrong app cannot satisfy the wait. Android derives the development-client scheme from app.json when scheme is omitted.

Enables or disables system animations on Android (window/transition/animator scales) for deterministic captures. Remember to re-enable at session end.