# Ceraph (npm · @ceraph/react-native-mcp)

MCP server for agent-driven React Native and Expo development and mobile testing

- Trust score: 60/100 (medium)
- Change this week: +18
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-26

## Components

- npm · `@ceraph/react-native-mcp`: 60/100 (this document), [markdown](https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp.md), [page](https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp)

## Channel facts

- Registry: `npm`
- Package: `@ceraph/react-native-mcp`
- Version: `1.0.4`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-26.

- **Supply Chain Security**: 86/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Install-script check failed: the install command fetches or executes arbitrary code (inline_eval). An install hook runs on every machine, in CI, and on transitive installs, whether or not you ever run the server.
  - 60 of 173 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (SEE LICENSE IN LICENSE) isn't a recognized OSI-approved license.
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 61/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 14113 tokens (~282/item across 50 items; 50 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 33/100
  - Stability observed for 10 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 94/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 82% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 51 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Ceraph MCP server?

Ceraph runs locally as an npm package, launched with npx -y @ceraph/react-native-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add dev-ceraph-react-native-mcp -- npx -y @ceraph/react-native-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "dev-ceraph-react-native-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@ceraph/react-native-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "dev-ceraph-react-native-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@ceraph/react-native-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add dev-ceraph-react-native-mcp -- npx -y @ceraph/react-native-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dev-ceraph-react-native-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@ceraph/react-native-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add dev-ceraph-react-native-mcp --command npx --arg -y --arg @ceraph/react-native-mcp
```

### Hermes

```yaml
mcp_servers:
  dev-ceraph-react-native-mcp:
    command: "npx"
    args: ["-y", "@ceraph/react-native-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "dev-ceraph-react-native-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@ceraph/react-native-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add dev-ceraph-react-native-mcp -t stdio -c npx -a -y @ceraph/react-native-mcp
```

### Other

```json
{
  "mcpServers": {
    "dev-ceraph-react-native-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@ceraph/react-native-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-26 (score 60, 0)

- [functional] Package version: 1.0.3 → 1.0.4

### 2026-09-25 (score 60, +27)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 33, −26)

- [security regression] Malware scan: pass → unverified
- [security regression] Known CVEs: pass → unverified
- [functional regression] Dependency health: 0.85 → unverified
- [functional] Package version: 1.0.2 → 1.0.3

### 2026-09-23 (score 59, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-21 (score 58, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-20 (score 57, +15)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.10 → unverified
- [security improvement] Malware scan: unverified → pass
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 1.0.1 → 1.0.2

### 2026-09-19 (score 42, −12)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Stability: unverified → 0.10
- [functional] Destructive annotations: All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
- [functional] Package version: 1.0.0 → 1.0.1

### 2026-09-16 (score 54)

First indexed and scored.

## MCP tools (50)

### `rn_build_ios` (~300 tokens)

Advanced unmanaged iOS build diagnostic. A bare call starts nothing and steers to `ceraph_start({ rebuild: true })`; use `app_launch({ rebuild: true })` only for rebuild-and-open. Set `unmanaged:true` only when you accept responsibility for the build process. `clean:true` may regenerate the iOS native project for Expo apps.

Input parameters:

- `clean` (boolean): Request a clean build. For a headed Expo build this deletes and regenerates only `ios/`; bare React Native and headless builds preserve that directory.
- `configuration` (string): iOS build configuration (default Debug).
- `device` (string): Physical-device or simulator identifier, or simulator name. Omit to use the default target. Ignored when headless is true.
- `headless` (boolean): Build and launch on a simulator without opening Simulator.app. macOS only. Defaults to true when CERAPH_TARGET=headless; pass false to override the env for this call.
- `port` (number): Metro port (default 8081).
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `scheme` (string): Exact iOS Xcode scheme.
- `unmanaged` (boolean): Explicit opt-in to the advanced build-only primitive. Without exactly true, no build starts and the result steers to ceraph_start.

### `rn_build_android` (~166 tokens)

Advanced unmanaged Android build diagnostic. A bare call starts nothing and steers to `ceraph_start({ platform: 'android', rebuild: true })`. Set `unmanaged:true` only when you accept responsibility for the build process. `clean:true` may regenerate the Android native project for Expo apps.

Input parameters:

- `clean` (boolean)
- `device` (string): Exact adb serial, such as emulator-5554.
- `port` (integer)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `target` (string)
- `unmanaged` (boolean)
- `variant` (string): Exact debuggable Gradle variant, such as developmentDebug.

### `rn_metro_start` (~151 tokens)

Start or reuse this project's Metro dev server. Auto-detects Expo vs bare React Native. Monitors console output for runtime errors and warnings. To bring everything up in one call (Metro + build + verify), use ceraph_start.

Input parameters:

- `clear` (boolean): Clear Metro bundler cache on start
- `force` (boolean): Restart this project's Metro even when it is already running
- `port` (number): Port for Metro bundler (default: 8081)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `resetCache` (boolean): Alias for clear

### `ceraph_start` (~1412 tokens)

FIRST call for any app-driving session: the one-call bring-up that reaches a ready-to-test state. Starts or reuses Metro, the app, and the platform automation driver (WebDriverAgent on iOS or UiAutomator2 on Android), then verifies the selected exact runtime is ready. Runs only the steps that aren't already done and stops at the first failure with its remediation. Call this before ceraph_snapshot / screen_* taps / screenshots / typing — prefer it over calling rn_metro_start / rn_build_ios / rn_build_android / rn_wda_start / ceraph_doctor separately. Works against iOS or Android devices, iOS simulators, and Android emulators. Prefer target:'headless' for unattended or background simulator verification; use target:'simulator' when the user needs the Simulator.app window visible. For unattended Android verification use target:'no-window'; it launches the AVD without a window or host audio. Use target:'emulator' when a visible emulator window is useful.

Input parameters:

- `avd` (string): Exact Android Virtual Device name to boot for emulator or no-window targets.
- `bundleId` (string): Usually OMIT — Ceraph detects the project's iOS bundle ID or Android application ID. Pass only an intentional build-variant override (e.g., com.acme.myapp.dev). An explicit value is authoritative for…
- `clean` (boolean): Run `npx expo prebuild --clean` before a build, regenerating the selected platform's native folder. DESTRUCTIVE whenever this run resolves to a headed Expo build (a simulator or device — what 'auto'…
- `configuration` (string): iOS build configuration; defaults to Debug.
- `device` (string): Exact runtime to pin: an Android adb serial, an Apple device/simulator UDID, or an iOS simulator name (e.g. "iPhone 17"). A connected physical identifier auto-resolves its platform; use `target` to c…
- `expectedNetwork` (string): Optional WiFi SSID the user expects the laptop (and phone) to be on. Mismatch is a warning, not a stop.
- `focusWindow` (boolean): Set false to skip Ceraph's Simulator/emulator window activation for this bring-up. The app still opens inside its runtime. Does not affect physical-device keep-awake.
- `platform` (string): Mobile platform to drive. An exact connected physical device or target 'device' auto-resolves it; otherwise omit to use iOS on macOS and Android on Windows/Linux. target 'simulator'/'headless' implie…
- `port` (number): Port for Metro bundler (default: 8081)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `rebuild` (boolean): Rebuild and reinstall the app even when Ceraph considers the installed build current. Use this when the installed native app is stale or a normal start reports a native-module launch failure. This pr…
- `requiredEnv` (array): Env var names the app under test requires. Each must be set + non-empty for doctor to pass.
- `scheme` (string): Exact iOS Xcode build scheme.
- `signalPort` (integer): Signal-channel port for this runtime instance. Usually omit. When two agents drive the same project concurrently, give each exact device/simulator instance its own Metro `port` and `signalPort` in a…
- `target` (string): Which target kind to drive. On iOS, 'auto' (default) uses a USB-connected device unless a simulator session is already active; otherwise it selects and boots an available simulator when needed. A Wi-…
- `variant` (string): Android only: exact debuggable Gradle application variant, such as developmentDebug. Omit for the conventional debug variant or when the build exposes only one debuggable variant.
- `wifi` (boolean): Permit the exact physical device in `device` to connect over Wi-Fi. Requires target 'device' and an exact device identifier. Set true only when the user explicitly approved Wi-Fi device access; never…

### `rn_get_errors` (~76 tokens)

Return all captured errors from build and runtime. Includes structured build errors (file, line, column, message), runtime JS errors (message, stack trace), and warnings.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `rn_get_console` (~132 tokens)

Return recent app console output, including shim-forwarded output when Metro is externally owned, optionally filtered by log level.

Input parameters:

- `level` (string): Filter by log level (default: all)
- `lines` (number): Number of recent lines to return (default: 50)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `waitMs` (integer): Wait up to this many milliseconds for matching output when the current buffer is empty (default: 0). Resolves immediately on arrival.

### `rn_check_prebuild` (~116 tokens)

Check whether an Expo native project needs a clean prebuild for iOS or Android. Compares current dependencies and app config with that platform's last successful-build snapshot; iOS also checks Podfile.lock, while Android checks the package-manager lockfile used to resolve native packages.

Input parameters:

- `platform` (string): Platform to inspect; defaults to the active Ceraph platform.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `screen_tap` (~336 tokens)

Tap by a `ref` from ceraph_snapshot, snapshot bounds, or explicit coordinates. Prefer a stable `ref`; use `index` only when a non-unique accessibility ref matches multiple elements. Use bounds for synthetic accessibility refs. Screenshot-derived coordinate taps are best-effort.

Input parameters:

- `bounds` (object): Snapshot bounds in device points. Taps their center. Use this for synthetic or non-unique accessibility refs that cannot be resolved reliably by identity.
- `coordinateSource` (string): Coordinate space of x/y only; do not pass it with ref or bounds. Defaults to 'device', including ceraph_snapshot bounds. Use 'screenshot' only for a point measured from an image; screenshot-derived c…
- `includeOffScreen` (boolean): Only meaningful with a disambiguated ref: match the occurrence set from an includeOffScreen snapshot. Defaults to false.
- `index` (integer): Explicit zero-based match choice. Mutation tools refuse multiple matches when omitted; waits retain any-match semantics.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `ref` (string): Preferred element handle from ceraph_snapshot. Supports injected testIDs, accessibility ids/labels, and disambiguated `<id>::<N>` refs. Synthetic `ax:<n>` refs cannot be resolved; use bounds instead.
- `x` (number): X coordinate to tap (required with y when ref is omitted)
- `y` (number): Y coordinate to tap (required with x when ref is omitted)

### `ceraph_snapshot` (~557 tokens)

Return a structured snapshot of the CURRENT screen — the kind of accessibility-tree view the web exposes, for React Native: a tree of UI elements with roles (button/textInput/text/image/scrollView/switch/view), names, values, on-screen bounds (device points), live state (`onScreen`/enabled/focused), and a stable `ref` per element. `onScreen` means the node intersects the device viewport; it does not promise that every pixel is unobscured in a screenshot. To ACT on an element, ordinarily call screen_tap with its `ref`; use screen_tap_and_verify only when you also have an explicit postcondition. Other element actions (screen_type_into_field, screen_long_press, …) accept the same ref — never pass the snapshot `role` as a native-driver type. A `synthetic` or non-unique accessibility ref has no reliable identity handle, so pass its `bounds` directly to screen_tap. When a component is reused on one screen its instances share a testID, so each on-screen occurrence past the first gets a disambiguation ref `<id>::<N>` (e.g. `cer_btn::2`) and a `collision` field ({ baseRef, occurrence, totalOccurrences }); pass that `::N` ref back verbatim and the tap lands on that exact instance. `testIdCollisions` counts the colliding ids. Also returns a flat `tappable` list (on-screen + enabled interactive elements). Each successful response also includes `meta.capture.id`; link every clean-path snapshot that materially informs the recorded replay plan. Ceraph pairs those expected states with explicit replay waits and post-run observed frames. When this project's Ceraph-enabled app is foreground, the snapshot includes React Native Fiber detail. In another foreground app or native system surface, Ceraph returns the available native accessibility tree instead, which supports cross-app journeys without mixing project state into that screen. Requires a ready automation runtime; call ceraph_start first.

Input parameters:

- `includeOffScreen` (boolean): Include elements with zero / off-screen bounds. Default false (only on-screen, actionable elements).
- `includeStyles` (boolean): Include bounded render-time style inputs for uniquely matched visible elements. Use after styling, layout, typography, or design-system changes. Default false.
- `maxDepth` (integer): Usually omit: Ceraph then returns the complete visible logical tree. Use only to cap a response you already know is unwieldy; root nodes are depth 0 and meta.depth reports whether nodes were omitted.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `screen_swipe` (~195 tokens)

Swipe on the current mobile screen. Direction is up/down/left/right; optional from-point and distance default to a center-screen swipe of ~60% of the relevant axis. Coordinates are device-space by default — keep it that way and pass ceraph_snapshot `bounds` directly. Only pass coordinateSource: 'screenshot' if `from` was measured off a screenshot, and treat that as best-effort: the delivered image is usually downscaled by a factor Ceraph cannot observe.

Input parameters:

- `coordinateSource` (string)
- `direction` (string, required)
- `distancePx` (number): Swipe distance in points.
- `durationMs` (number): Swipe duration in ms.
- `from` (object): Optional swipe start point. Defaults to screen center.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `screen_scroll_to` (~484 tokens)

Repeatedly swipe until an element is actually on-screen (PREFER its `ref` from ceraph_snapshot; else text/accessibilityLabel). Returns without tapping. Default direction is 'up' (swipe up — reveals content below the fold), max 10 swipes. Pass direction: 'down' to scroll backward toward the top.

Input parameters:

- `accessibilityLabel` (string)
- `direction` (string)
- `distancePx` (number)
- `includeOffScreen` (boolean): Only meaningful with a disambiguation `ref` (`<id>::<N>`): enumerate off-screen occurrences too when resolving the ordinal. Defaults to false — match it to the snapshot the ref came from (pass true o…
- `index` (integer): Explicit zero-based match choice. Mutation tools refuse multiple matches when omitted; waits retain any-match semantics.
- `maxSwipes` (number)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `ref` (string): PREFERRED: target the element by its `ref` from ceraph_snapshot (its stable handle — the injected testID, a non-`cer_` accessibility id, or its accessibility label). Resolves the element's identity d…
- `text` (string)
- `type` (string): A platform-normalized native element-type filter (e.g. "Button", "TextField") — NOT the ceraph_snapshot `role`. Ceraph normalizes Android UiAutomator2 nodes into this shared type vocabulary. To act o…

### `screen_long_press` (~430 tokens)

Long-press an element (PREFER its `ref` from ceraph_snapshot; else text/accessibilityLabel). Default duration is 1000ms.

Input parameters:

- `accessibilityLabel` (string)
- `durationMs` (number)
- `includeOffScreen` (boolean): Only meaningful with a disambiguation `ref` (`<id>::<N>`): enumerate off-screen occurrences too when resolving the ordinal. Defaults to false — match it to the snapshot the ref came from (pass true o…
- `index` (integer): Explicit zero-based match choice. Mutation tools refuse multiple matches when omitted; waits retain any-match semantics.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `ref` (string): PREFERRED: target the element by its `ref` from ceraph_snapshot (its stable handle — the injected testID, a non-`cer_` accessibility id, or its accessibility label). Resolves the element's identity d…
- `text` (string)
- `type` (string): A platform-normalized native element-type filter (e.g. "Button", "TextField") — NOT the ceraph_snapshot `role`. Ceraph normalizes Android UiAutomator2 nodes into this shared type vocabulary. To act o…

### `screen_press_key` (~80 tokens)

Press a hardware/system button: back, home, volumeUp, volumeDown, or lock. Back uses Android's system key and iOS navigation fallback.

Input parameters:

- `key` (string, required)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `screen_open_url` (~130 tokens)

Open a URL / deep link on the device to jump straight to a screen — useful for testing your app's deep-link routes (e.g. myapp://product/42). If the scheme isn't registered in the app under test, the result carries an actionable message explaining the app needs a rebuild to pick up the scheme.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `url` (string, required): URL / deep link to open, e.g. myapp://product/42

### `screen_screenshot` (~65 tokens)

Capture a screenshot of the current mobile screen through the active automation driver. Returns the PNG as a viewable image.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `screen_wait_for` (~464 tokens)

Poll the active automation driver's native source tree until an element matching the query is on-screen (or, if disappear is true, until it is no longer on-screen). This checks accessibility geometry, not screenshot pixels. Default timeout is 5s.

Input parameters:

- `accessibilityLabel` (string)
- `disappear` (boolean)
- `includeOffScreen` (boolean): Only meaningful with a disambiguation `ref` (`<id>::<N>`): enumerate off-screen occurrences too when resolving the ordinal. Defaults to false — match it to the snapshot the ref came from (pass true o…
- `index` (integer): Explicit zero-based match choice. Mutation tools refuse multiple matches when omitted; waits retain any-match semantics.
- `pollIntervalMs` (number)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `ref` (string): PREFERRED: target the element by its `ref` from ceraph_snapshot (its stable handle — the injected testID, a non-`cer_` accessibility id, or its accessibility label). Resolves the element's identity d…
- `text` (string)
- `timeoutMs` (number)
- `type` (string): A platform-normalized native element-type filter (e.g. "Button", "TextField") — NOT the ceraph_snapshot `role`. Ceraph normalizes Android UiAutomator2 nodes into this shared type vocabulary. To act o…

### `screen_tap_and_verify` (~548 tokens)

Tap an element and assert an explicit postcondition in one call. PREFER the element's `ref` from ceraph_snapshot; use ordinary screen_tap for a tap without a postcondition. Finds the target, taps its center, and asserts the follow-up selector is on screen — all in one logical step. The result reports whether the optimized path was used (`batched`).

Input parameters:

- `accessibilityLabel` (string)
- `includeOffScreen` (boolean): Only meaningful with a disambiguation `ref` (`<id>::<N>`): enumerate off-screen occurrences too when resolving the ordinal. Defaults to false — match it to the snapshot the ref came from (pass true o…
- `index` (integer): Explicit zero-based match choice. Mutation tools refuse multiple matches when omitted; waits retain any-match semantics.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `ref` (string): PREFERRED: target the element by its `ref` from ceraph_snapshot (its stable handle — the injected testID, a non-`cer_` accessibility id, or its accessibility label). Resolves the element's identity d…
- `text` (string)
- `type` (string): A platform-normalized native element-type filter (e.g. "Button", "TextField") — NOT the ceraph_snapshot `role`. Ceraph normalizes Android UiAutomator2 nodes into this shared type vocabulary. To act o…
- `verifySelector` (object, required): Required follow-up assertion. The tool reports whether this selector is on-screen in `verifyResult` after the tap. Use screen_tap when no assertion is needed.
- `verifyTimeoutMs` (integer): Maximum time to wait for the post-tap selector, in milliseconds. Returns as soon as the postcondition is observed; defaults to 3000.

### `screen_type_into_field` (~274 tokens)

Compound primitive: focus an input field (PREFER its `ref` from ceraph_snapshot; else text/accessibilityLabel/type) and type into it. The result reports whether the optimized focus path was used (`batched`). Set `clearFirst: true` to clear an existing value before typing — off by default so we never silently overwrite form state. A successful Android call can set `dismissKeyboardAfter: true` to dismiss the software keyboard and verify it is no longer shown. A successful key dispatch is postcondition-checked against field value or focused edit state; phase timings are returned for latency diagnosis.

Input parameters:

- `clearFirst` (boolean): When true, clear the field's current value before typing. Defaults to false.
- `dismissKeyboardAfter` (boolean): Android only. When true, dismiss the software keyboard after successful typing and verify it is no longer shown. Defaults to false.
- `fieldQuery` (object, required): Query identifying the input field to focus. Prefer the snapshot `ref`; `type` is a platform-normalized native type filter, not the snapshot `role`.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `text` (string, required): Text to type into the focused field.

### `screen_tap_chain` (~171 tokens)

Compound primitive: tap a sequence of elements in one optimized call. Each query resolves against the same screen state. If any query fails to resolve, the chain stops and ZERO gestures are sent (we never partial-tap an intent). On bulk-action failure, Ceraph may use individual taps (`batched: false`). Use only for controls that are simultaneously on-screen and whose layout will not change between taps; any navigation or menu re-render needs separate taps and fresh snapshots.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `queries` (array, required): Ordered list of element queries to tap. Resolved against one screen state — don't use this for sequences that require re-rendering between taps.

### `app_launch` (~427 tokens)

Start, open, relaunch, or incrementally rebuild this project's iOS or Android app. With no bundleId—or when bundleId matches this project—starts/reuses Metro, connects the Expo dev client, and verifies that this project's JS bundle loaded. A physical iPhone Expo dev client may report reduced-confidence readiness when exact in-app confirmation is unavailable; other targets remain strict. It does not start or stop the platform automation driver or keep-awake service. Set rebuild:true only when the user explicitly asks for a native rebuild; it uses the managed build/install path without provisioning automation. For another app's explicit bundleId/package ID, performs a plain native launch without Metro. Use ceraph_start instead when the agent must inspect, test, or drive UI.

Input parameters:

- `avd` (string): Exact Android Virtual Device name to boot when needed.
- `bundleId` (string): Omit for this project; pass another iOS bundle ID or Android package ID for a plain native launch
- `device` (string): Exact runtime id (Android adb serial or Apple UDID).
- `platform` (string): Mobile platform; emulator/no-window imply Android, while simulator/headless imply iOS.
- `port` (number): Metro port for this project launch (default: current project port or 8081)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `rebuild` (boolean): Incrementally rebuild and install this project before opening it. Use only when the user explicitly asks to rebuild; it does not run the automation driver, keep-awake, doctor, or testing postflight.…
- `restart` (boolean): Terminate the existing app process before opening it (default: false)
- `target` (string): Launch target; omit for CERAPH_TARGET/auto policy
- `variant` (string): Android only: exact debuggable Gradle application variant, such as developmentDebug.

### `app_terminate` (~128 tokens)

Terminate an app by its iOS bundle ID or Android package ID on the active exact runtime. On a real iOS device, terminating the app under test keeps WebDriverAgent available for subsequent commands; the screen may show WDA's runner until app_activate or ceraph_start relaunches the app. iOS Simulator and Android runs do not need this iOS auto-lock safeguard.

Input parameters:

- `bundleId` (string, required)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `app_activate` (~81 tokens)

Bring an app to the foreground without a cold restart on the active exact runtime. Uses WebDriverAgent on iOS or an exact-serial Android activity launch.

Input parameters:

- `bundleId` (string, required)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `app_list_installed` (~72 tokens)

List apps installed on the active exact mobile runtime. Uses Apple device/simulator tooling on iOS or exact-serial package-manager data on Android.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `app_info` (~61 tokens)

Return the foreground app's identity and name on the active exact runtime. Android also reports its activity.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `device_ensure_awake` (~75 tokens)

Ensure the active iOS or Android runtime is awake and request keyguard dismissal. Returns a structured result with remediation guidance when the runtime cannot be made ready.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `device_set_orientation` (~83 tokens)

Request portrait or landscape through the active automation driver and verify both the device and active app's resulting orientation. Ceraph does not override the app's supported-orientation policy.

Input parameters:

- `orientation` (string, required)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_doctor` (~266 tokens)

Run the available platform setup checks before driving the app: exact runtime connected, automation driver reachable, app installed, required env vars present, plus connectivity checks available for that platform. Returns a structured result — when ok: false, follow each finding's remediation and DO NOT attempt to fix environment issues by editing source code. To bring everything up in one call (Metro + build + verify), use ceraph_start.

Input parameters:

- `bundleId` (string): Usually omit — Ceraph detects the project's iOS bundle ID or Android package ID. Pass an intentional build-variant override.
- `device` (string): Exact runtime id or adb serial.
- `expectedNetwork` (string): Optional WiFi SSID the user expects the laptop (and phone) to be on. Mismatch is a warning, not an error.
- `platform` (string)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `requiredEnv` (array): Env var names the app under test requires. Each must be set + non-empty.
- `target` (string)
- `variant` (string): Android only: exact debuggable Gradle application variant, such as developmentDebug.

### `rn_sync_camera_registry` (~112 tokens)

Refresh Ceraph camera fixtures after images or videos were added, removed, or changed manually under `.ceraph/`. The filename stem is the key used by `<CeraphCamera mediaKey>`. The camera fixture tools refresh their own writes, so call this only after manual file changes or a git update. Returns the available image and video keys.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_add_camera_image` (~283 tokens)

Add a JPEG, PNG, WebP, or HEIC camera fixture up to 5 MB. Pass the image as base64 or a data URI with a lowercase, hyphen-separated `mediaKey` used by `<CeraphCamera mediaKey>`. An existing key is preserved unless `overwrite: true` is set. Returns the key, format, replacement status, and size. Fixtures are development-only; production builds use the real camera and exclude test media.

Input parameters:

- `contentType` (string): Optional MIME hint (e.g. `image/jpeg`). If it differs from the detected format, the tool returns a warning and uses the detected format.
- `imageBase64` (string, required): Base64-encoded image payload. A `data:image/...;base64,...` URI prefix is accepted and stripped automatically.
- `mediaKey` (string, required): Lowercase + hyphen-separated stem (e.g. `profile`, `id-card`, `handwriting-sample-1`). Becomes both the filename stem AND the value devs pass to `<CeraphCamera mediaKey>`.
- `overwrite` (boolean): Allow replacing an existing mediaKey (across different extensions). Defaults to false.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_add_camera_video` (~304 tokens)

Add an MP4, MOV, or M4V camera video fixture up to 25 MB. Pass the video as base64 or a data URI with a lowercase, hyphen-separated `videoKey`; the matching `<CeraphCamera mediaKey>` uses it for recording. An existing key is preserved unless `overwrite: true` is set. Returns the key, format, replacement status, and size. Fixtures are development-only; production builds use the real camera and exclude test media.

Input parameters:

- `contentType` (string): Optional MIME hint (e.g. `video/mp4`). If it differs from the detected format, the tool returns a warning and uses the detected format.
- `overwrite` (boolean): Allow replacing an existing videoKey (across different extensions). Defaults to false.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `videoBase64` (string, required): Base64-encoded video payload. A `data:video/...;base64,...` URI prefix is accepted and stripped automatically.
- `videoKey` (string, required): Lowercase + hyphen-separated stem (e.g. `treadmill`, `id-scan-1`). Becomes both the filename stem AND the value devs pass to `<CeraphCamera mediaKey>` — the same key selects the still image for takeP…

### `ceraph_set_camera_test_media` (~166 tokens)

Switch the running development app's CeraphCamera between registered test media and the real camera without rebuilding or restarting. Enable before camera testing and disable when finished. Uses each component's mediaKey; it does not add gallery media. Set save to retain the choice for later Ceraph sessions on this machine. The runtime choice stays active through thinking pauses while connected; production always uses the real camera. Replay runtime-only changes as set-camera-test-media in ceraph_record_run.

Input parameters:

- `enabled` (boolean, required)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `save` (boolean): Also save this camera-testing preference for later Ceraph sessions on this machine.

### `ceraph_add_media` (~220 tokens)

Add one image or video to the exact runtime's system photo library before or while testing a native media picker. After this succeeds, drive the app's real image/video picker UI; do not use it as a CameraView replacement. Supports iOS simulators and Android emulators/devices. Physical iPhones require a project-owned hook because host tools cannot write to Photos directly.

Input parameters:

- `contentType` (string): Optional MIME type hint used to validate the supplied image or video.
- `device` (string): Exact Apple runtime ID or Android adb serial.
- `mediaBase64` (string, required): Base64-encoded image or video bytes. A complete data URI prefix is accepted and stripped.
- `platform` (string): Mobile platform; target emulator or no-window implies Android.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `target` (string): Runtime target. Omit to use the active Ceraph runtime or normal auto-selection.

### `rn_reload` (~120 tokens)

Request a JS bundle reload on the running development app through Ceraph's installed app integration. Waits up to `timeoutMs` for the platform automation driver to become responsive again, then captures a screenshot. Dev-only; does nothing in a production build.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `timeoutMs` (number): Max time in ms to wait for the app to come back after the reload (default 30000).

### `rn_stop` (~60 tokens)

Stop all managed React Native processes and this session's managed no-window Android emulator, if any.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `rn_target_status` (~88 tokens)

Report the active platform, physical-device or virtual-runtime target, exact runtime ID, presentation mode, and automation readiness. Call this when the developer asks which runtime is under test or before starting a flow if uncertain which target is active.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `rn_wda_start` (~269 tokens)

Advanced / simulator-only. Use `ceraph_start` for normal app bring-up. This tool prepares automation for an already-booted iOS Simulator and never targets a real iPhone. It requires the optional `appium-webdriveragent` dependency and may request the one-time Xcode signing setup. When a real iPhone is also connected, explicitly confirm simulator intent so Ceraph never changes targets silently.

Input parameters:

- `confirmSimulatorTarget` (boolean): Confirm you INTEND to drive the iOS SIMULATOR even though a real device is connected — rn_wda_start routes automation to the simulator. Set true ONLY when the user explicitly wants the simulator. Not…
- `derivedDataPath` (string): Optional Xcode derived-data directory for this simulator automation session.
- `force` (boolean): Stop and restart simulator WDA instead of reusing a healthy matching session
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `udid` (string): Simulator UDID; defaults to first booted simulator

### `rn_wda_stop` (~81 tokens)

Stop the managed iOS Simulator automation session started by rn_wda_start. Idempotent — calling it when no such session is running is a no-op. Real-device automation is unaffected.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `rn_wait_for_device` (~180 tokens)

Wait for a physical mobile runtime to connect. iOS uses macOS usbmuxd events; Android waits for one exact adb serial to become connected and authorized without selecting or probing a different runtime. The call waits until connection, an explicit deadline, or agent cancellation.

Input parameters:

- `device` (string): Exact runtime ID: Android adb serial, or Apple CoreDevice/classic hardware UDID.
- `platform` (string): Platform to wait for; defaults to the active Ceraph platform.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `timeoutMs` (integer): Optional explicit deadline in milliseconds. Default: none — the call waits forever and relies on the MCP abort signal for cancellation. Set this only when you want a hard cap.

### `ceraph_init` (~553 tokens)

Run the complete Ceraph project setup, equivalent to `npx @ceraph/react-native-mcp init`. This is the recommended agent path: it installs and integrates Ceraph, configures supported MCP clients and runtime-error delivery, prepares camera testing, and checks project and runtime readiness. It preserves existing project customizations and returns manual remediation when a file cannot be changed safely. It detects an active Pro account automatically. Otherwise it returns { status: 'needs-tier' } before mutation; show the plan options, call ceraph_init_select_tier with the user's choice, then re-call this tool. Starter continues without sign-in. Pro may return 'needs-auth' or 'needs-checkout'; complete that step and re-call. A temporary entitlement outage returns 'verification-unavailable'; retry it rather than presenting an upgrade. A 'needs-manual' result contains actions that must be completed before testing; 'ready' means no known setup actions remain. A userMcp call changes only user-level MCP registration, not project setup. Relay optional setup decisions when returned and complete them only after explicit user approval. Ask the collaboration question last. A collaboration follow-up uses Ceraph's narrowly scoped commit; do not substitute your own Git commit. Global CLI installation is also an approval-only follow-up. These optional decisions do not block testing; --agent and --yes do not authorize them.

Input parameters:

- `collaboration` (string): Complete the optional collaboration decision returned by agent init. Commit requires explicit user approval and uses Ceraph's scoped commit path.
- `collaborationId` (string): Exact collaboration decision identifier returned by init.
- `globalCli` (string): Install the global ceraph terminal command only after explicit user approval.
- `projectAccess` (string): Re-enable only the selected project after the user explicitly approves reversing its uninstall. This updates the saved project opt-out only; then call ceraph_start. Do not infer approval from a gener…
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `token` (string): Secret sign-in token the user pasted after opening the verificationUri. Never repeat it in output. When set, sign-in and setup continue in this call.
- `userApproved` (boolean): True only after the user explicitly approved the requested project or machine change. Reuse approval already given for this exact change; do not ask twice.
- `userMcp` (string): Only change user-level MCP registration across supported clients. Preserve project configuration, CLI and sign-in. Requires explicit user approval. Decline remembers project-only discovery without re…

### `ceraph_init_status` (~96 tokens)

Read the current Ceraph setup state, including app integration, supported client configuration, camera readiness, and any incomplete steps. Read-only. Call `ceraph_init` for complete setup; use a granular init tool only when Ceraph remediation asks for that specific repair.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_init_auth_browser` (~277 tokens)

Sign in to Ceraph through the browser. Returns { status: 'ok', email? } on success, or machine-selection-required with recently used installations when all three Pro slots are occupied. Relay the choices to the user; never select a machine to sign out without their explicit confirmation. After confirmation, resume with the selected id and generation. No second browser login is needed while approval remains valid. { status: 'aborted' } when the MCP client cancelled the tool call (don't prompt the user — just stop), or a stable remediation on failure. When browser sign-in cannot complete, relay the returned verificationUri to the user. If callback delivery fails, re-call with the browser-provided token. Treat the token as a secret and never repeat it in output. For complete project setup, prefer `ceraph_init`.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `replacement` (object): Exact installation the user explicitly confirmed should be signed out. Use only with resume: true.
- `resume` (boolean): Resume an approved, pending machine sign-in without reopening the browser.
- `token` (string): Secret token from this machine's browser approval. Finishes that sign-in without reopening the browser.

### `ceraph_init_select_tier` (~282 tokens)

Select the Ceraph plan and drive Pro onboarding. Call with no args to resume onboarding: an authenticated active Pro account returns { status: 'pro-ready' }; otherwise a fresh setup gets the two plan options ({ status: 'needs-tier' }). Call with { tier: 'starter' } for the free local toolset ({ status: 'starter-ready' }); call with { tier: 'pro' } to start Pro setup. The Pro path is a state machine resolved fresh each call: not signed in → { status: 'needs-auth', authUrl } (sign in via ceraph_init_auth_browser, then re-call); signed in but not yet paid → { status: 'needs-checkout', checkoutUrl } (selecting Pro is NOT being Pro — complete checkout, then re-call); paid → { status: 'pro-ready' }. Re-calling re-checks server-side, so an abandoned then-completed checkout self-heals. For a complete install (this tier step plus every other phase), call `ceraph_init` instead.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `tier` (string): The plan the user chose. Omit on the first call to receive the two options to surface.

### `ceraph_init_scan_camera` (~93 tokens)

Find Expo CameraView components that can use deterministic camera fixtures. Returns only the source locations and suggested media keys needed for setup. Choose a descriptive key for the app scenario, and pass the returned line and column to `ceraph_init_replace_camera`.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_init_replace_camera` (~251 tokens)

Replace one Expo CameraView with a configured CeraphCamera, or set the mediaKey on an unconfigured CeraphCamera. Use `default` when fixture content does not matter, or a lowercase-dashes key matching a camera fixture. Pass the source location returned by `ceraph_init_scan_camera`; column is required only when two cameras share a line. Preserves unrelated source and is safe to re-run with the same key.

Input parameters:

- `column` (integer): 1-based column of the opening tag (from scan_camera). Required to pick between two cameras on the SAME line; optional otherwise.
- `filePath` (string, required): Absolute path of the source file.
- `line` (integer, required): 1-based line of the opening <CameraView> tag.
- `mediaKey` (string, required): The mediaKey to use. Either "default" or a lowercase-dashes key matching a configured camera image (JPEG, PNG, WebP, or HEIC) or video (MP4, MOV, or M4V) fixture.
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_init_inject_boot` (~101 tokens)

Repair Ceraph's development app integration and required project configuration. Preserves existing app and bundler customizations, is safe to re-run, and reports exact manual remediation for dynamic configuration it cannot change safely. Prefer complete `ceraph_init` unless remediation specifically asks for this repair.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_init_register_scheme` (~78 tokens)

Configure the development URL scheme Ceraph needs to reconnect to the app. Updates supported static configuration and returns exact manual instructions when a dynamic or native configuration cannot be changed safely.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_init_setup_mcp_clients` (~109 tokens)

Configure Ceraph in every supported MCP client detected for this project. Preserves unrelated entries and leaves malformed or unfamiliar config untouched with a reason the user can resolve. In a monorepo, pass the chosen React Native app directory. This repairs client configuration only; prefer `ceraph_init` for complete project setup.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.

### `ceraph_run_hook` (~368 tokens)

Fire a registered project-owned Ceraph hook by route when the real UI cannot reliably establish a testing prerequisite. Before considering a hook, prefer the real UI when it can establish that prerequisite: the path itself provides end-to-end coverage and may reveal regressions. After setup, continue the representative end-to-end flow rather than testing only the changed screen or component. If login or payment is under review, exercise that flow rather than skipping it. Before considering testing blocked, inspect ceraph_snapshot.meta.availableHooks. Hooks can create or sign in as disposable test users; prepare sessions, OTPs, or magic links; seed non-production backend/database states; establish roles, subscriptions, entitlements, or feature flags; simulate webhook, payment, email, or push state; dismiss development-only blockers; insert picker media through an app-owned physical-iPhone test seam; and reset or clean up disposable data. Hooks can reach backend and database code: verify a disposable non-production target, never modify production or real-user data or take irreversible action without explicit human authorization, reuse existing app authentication/configuration instead of embedding secrets, and prefer idempotent runId-scoped effects that return created IDs and have companion cleanup. The hook's run() code lives in your app (.ceraph/hooks, wired by `ceraph init`); this tool triggers it over Ceraph's command channel and reports the outcome.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `route` (string, required): The hook route to fire — the `route` a `.ceraph/hooks/*.hook.ts` file exports. This can be an advertised screen route or a known hidden utility route such as a test-user cleanup hook.

### `ceraph_record_run` (~380 tokens)

Replay an already-verified React Native path without model pauses and produce a clean MP4 with an ordered trace of structured snapshots and screenshots. Explore and debug first; call this only after the path works. Each wait-for marks a verified state and must reference the exploratory ceraph_snapshot capture ID with expectedSnapshotId. Use the resulting manifestPath to retrieve only the trace snapshots and screenshots relevant to a reported problem or a user's request; do not inspect every trace entry by default. If the requested screen is outside the recorded flow, navigate to it and use screen_screenshot. Exclude exploratory or debugging detours, loading frames, keyboard appearances, and incidental system UI. For a purely static settled change, use screen_screenshot with ceraph_snapshot instead of manufacturing a recording. Recorded steps share the interactive selector semantics for tap, type, swipe, scroll-to, long-press, press-key, tap-chain, add-media, set-camera-test-media (enabled: true/false), open-url, run-hook, set-orientation, app launch/terminate/activate, and wait-for. Enable camera test media before a camera flow and disable afterward; the setting lasts while connected. Cross-app native accessibility flows are supported; return to the project app before expecting Fiber-backed detail. An add-media step can insert a fixture while a native picker is open; its base64 payload is never persisted in the run manifest. Use snapshot bounds only with the source ceraph_snapshot capture ID; arbitrary screenshot coordinates are intentionally not replayable. The recording is screen-only evidence; it does not capture or verify audio.

Input parameters:

- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `setup` (object)
- `steps` (array, required)
- `title` (string, required)

### `ceraph_report_issue` (~188 tokens)

Prepare a sanitized public Ceraph defect report and check GitHub CLI authentication. Submit only with explicit user approval or a matching account-bound lasting preference. Preview first when consent is absent; never attach source, logs, media, or credentials.

Input parameters:

- `action` (string)
- `actual` (string)
- `code` (string)
- `expected` (string)
- `platform` (string)
- `preference` (string)
- `projectDir` (string): React Native/Expo project directory. Omit when the coding client's workspace identifies one app; supply it to disambiguate projects.
- `summary` (string): Concise Ceraph defect, without app code, private identifiers, logs, URLs, or customer data.
- `tool` (string)
- `userApproved` (boolean): True only when the user explicitly authorized this public submission or lasting reporting preference.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp#diagnostics

## Score history

- 2026-09-26: 60
- 2026-09-25: 60
- 2026-09-24: 33
- 2026-09-23: 59
- 2026-09-22: 58
- 2026-09-21: 58
- 2026-09-20: 57
- 2026-09-19: 42
- 2026-09-18: 54
- 2026-09-17: 54
- 2026-09-16: 54

## Common questions

### What is the Ceraph MCP server?

Ceraph is an MCP server listed in the public MCP registry as dev.ceraph/react-native-mcp. MCP server for agent-driven React Native and Expo development and mobile testing. This page covers its npm package (@ceraph/react-native-mcp).

### Is the Ceraph MCP server safe to use?

Ceraph scores 60 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 26 September 2026. It declares an install script we flagged as high risk. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Ceraph MCP server expose?

Ceraph exposes 50 tools: rn_build_ios, rn_build_android, rn_metro_start, ceraph_start, rn_get_errors, and 45 more. Their descriptions and schemas cost roughly 11,939 tokens of context every time the server is loaded.

### Is the Ceraph MCP server still maintained?

Ceraph is still listed as active in the MCP registry. We last reached this channel on 26 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- npm package: https://www.npmjs.com/package/@ceraph/react-native-mcp
- Socket report: https://socket.dev/npm/package/@ceraph/react-native-mcp
- Website: https://ceraph.dev/
- Changelog RSS feed: https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp.json
- HTML version of this page: https://verifymcp.io/servers/dev-ceraph-react-native-mcp/ceraph-react-native-mcp