# ReversePort (npm · reverseport)

Reverse engineer and port apps and games: Godot, Unity IL2CPP, .NET, binaries, with parity checks.

- Trust score: 87/100 (high trust)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `reverseport`: 87/100 (this document), [markdown](https://verifymcp.io/servers/laaielichter-reverseport/reverseport.md), [page](https://verifymcp.io/servers/laaielichter-reverseport/reverseport)

## Channel facts

- Registry: `npm`
- Package: `reverseport`
- Version: `1.15.0`
- 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-11-05.

- **Supply Chain Security**: 93/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known medium-severity CVE affects glob 13.0.6, reached via @electron/asar > glob. A fixed version is available.
  - No install/post-install scripts declared.
  - 62 of 184 dependencies flagged as unhealthy (1 deprecated).
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to laaielichter/Reverseport).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 71/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 15068 tokens (~264/item across 57 items; 57 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 63/100
  - Stability observed for 19 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/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.
  - Structured output schemas are declared (35% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 57 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 58 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

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

ReversePort runs locally as an npm package, launched with npx -y reverseport. 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 laaielichter-reverseport -- npx -y reverseport
```

### Cursor

```json
{
  "mcpServers": {
    "laaielichter-reverseport": {
      "command": "npx",
      "args": [
        "-y",
        "reverseport"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "laaielichter-reverseport": {
      "command": "npx",
      "args": [
        "-y",
        "reverseport"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add laaielichter-reverseport -- npx -y reverseport
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "laaielichter-reverseport": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "reverseport"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add laaielichter-reverseport --command npx --arg -y --arg reverseport
```

### Hermes

```yaml
mcp_servers:
  laaielichter-reverseport:
    command: "npx"
    args: ["-y", "reverseport"]
```

### Netclaw

```json
{
  "McpServers": {
    "laaielichter-reverseport": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "reverseport"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add laaielichter-reverseport -t stdio -c npx -a -y reverseport
```

### Other

```json
{
  "mcpServers": {
    "laaielichter-reverseport": {
      "command": "npx",
      "args": [
        "-y",
        "reverseport"
      ]
    }
  }
}
```

## 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-11-04 (score 87, +1)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.57 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 1.14.0 → 1.15.0

### 2026-11-03 (score 86, +24)

- [security regression] Known CVEs: unverified → fail
- [security improvement] Malware scan: unverified → pass
- [functional improvement] Dependency health: unverified → 0.87

### 2026-11-02 (score 62, −25)

- [security regression] Known CVEs: fail → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Schema quality: 201 → 264
- [functional regression] Tool coverage: 95% → 82%
- [functional regression] Dependency health: 0.89 → unverified
- [functional regression] Schema quality: pass → fail
- [functional] MCP protocol: Implements a current MCP spec version (2026-07-28).
- [functional] Package version: 1.10.0 → 1.14.0
- [functional] Package version: 1.10.0 → 1.13.0
- [functional] Package version: 1.10.0 → 1.12.0
- [functional] Package version: 1.10.0 → 1.11.0

### 2026-11-01 (score 87, 0)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.47 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 1.9.0 → 1.10.0

### 2026-10-31 (score 87, −1)

- [security regression] CVE-2026-118764 affects this package: medium
- [security regression] CVE-2026-118773 affects this package: medium
- [security regression] Known CVEs: pass → fail

### 2026-10-30 (score 88, +1)

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

### 2026-10-28 (score 87, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-10-27 (score 71, −9)

- [security regression] Malware scan: pass → unverified
- [security improvement] CVE-2023-54404 no longer affects this package
- [security improvement] Known CVEs: fail → pass
- [functional] Package version: 1.8.0 → 1.9.0

## MCP tools (57)

### `re_scan` (~124 tokens)

Scan a project or game folder

Reconnaissance of a folder: detects the engine/framework (Godot, Unity, Unreal, GameMaker, RPG Maker, Ren'Py, LÖVE, Defold, Bevy, MonoGame, three.js/Phaser/Electron, Flutter, .NET, Go, Rust, Python…) for source projects AND exported game builds, languages with line counts, file categories, entry points, biggest files and binaries. Start here.

Input parameters:

- `maxFiles` (integer): Stop after this many files (default 50000).
- `path` (string, required): Folder to scan.

### `re_graph` (~186 tokens)

Dependency graph and port order

Builds the dependency graph of a project: imports/includes/requires, Godot res:// loads and scene resources, Unity script/prefab GUIDs, and type references (C#, GDScript class_name/autoloads, Java…). JS/TS monorepos: imports of workspace packages by name, tsconfig paths aliases, package.json #imports and Deno import maps resolve to their files, and a workspace section shows which package uses which. Returns entry points, cycles, orphans, most-used files, external packages and the port order (dependencies first). format:"mermaid" adds a diagram.

Input parameters:

- `format` (string): json (default), mermaid or both.
- `limit` (integer): Files in portOrder (default 30; edges 15, other lists 20). Larger values return more of every list.
- `path` (string, required): Project folder.

### `re_symbols` (~149 tokens)

Classes, functions, signals

Code structure for one file or a whole folder (30+ languages: GDScript, C#, C/C++ incl. Unreal macros, Python, JS/TS, Lua, Java/Kotlin, Go, Rust, Swift, shaders, Ren'Py…): classes with base classes, functions with lines, signals/events, exported/serialized fields, dependencies, node paths. match filters by name (substring or * wildcard).

Input parameters:

- `limit` (integer): Max files (default 25; each file lists up to 40 functions unless match narrows it).
- `match` (string): Filter names (e.g. "player", "*_process").
- `path` (string, required): File or folder.

### `re_scene` (~105 tokens)

Read a scene, prefab or project file

Reads Godot .tscn/.tres/project.godot (Godot 3 and 4) and Unity .unity/.prefab/.asset (text serialization) into one neutral tree: node names, types, scripts, transforms (position, quaternion, scale), components, groups/tags, instanced scenes/prefabs (resolved through .meta GUIDs), signal connections, plus a mermaid diagram.

Input parameters:

- `file` (string, required): Scene/prefab/project file.

### `re_binary` (~167 tokens)

Inspect an executable or bytecode

Inspects PE/EXE/DLL (incl. .NET assemblies: runtime, types and methods), ELF, Mach-O (incl. universal), WebAssembly, Java .class, Android .dex, Lua/LuaJIT and Python bytecode: architecture, sections with entropy, imports/exports, PDB path, signing, overlay data (e.g. an embedded game pack), toolchain/engine hints and strings. Read-only: it does not unpack, decrypt or patch.

Input parameters:

- `file` (string, required): Binary file.
- `maxTypes` (integer): .NET types to list (default 300).
- `names` (object): Import/export name options: match, limit.
- `strings` (object): String options: min, limit, match, maxMB, raw.

### `re_archive` (~417 tokens)

List or extract a pack/archive

Lists or extracts game packs and archives. Godot .pck (also embedded in an exported .exe/.x86_64; MD5-checked). Unity asset bundles (UnityFS, LZ4/LZMA) and serialized files (data.unity3d, level0, sharedassets0.assets, globalgamemanagers): every object by class and name, bundle container paths, the C# scripts MonoBehaviours use (with counts), the build's scene list; extract writes Texture2D as PNG (DXT1/5, BC4/5, ETC1/ETC2/ETC2+EAC, 8-bit raw formats; ASTC as .astc, BC6H/BC7 as .dds, others raw), Mesh as OBJ (with type trees), AudioClip as its FSB5 bank, TextAsset as text and other objects as JSON (bundles) or raw bytes (player builds strip type trees). ZIP family (apk, jar, ipa), tar/tar.gz (.unitypackage), Electron .asar, Ren'Py .rpa, GameMaker data.win (PNG/QOI, WAV/OGG), FMOD .bank and .fsb (PCM as WAV), Wwise .bnk, Unreal .pak v1–v11 (stored/Zlib extract), Flash .swf (CWS and ZWS inflate), Unity WebGL and Emscripten .data. Encrypted packs/entries are reported, never decrypted.

Input parameters:

- `action` (string): list (default) or extract.
- `file` (string, required): Archive/pack/executable.
- `limit` (integer): Max entries listed/extracted (default 500).
- `match` (string): Only entries matching: substring, glob (*.gd, scenes/*.tscn) or /regex/.
- `maxBytes` (integer): Extraction budget in bytes (default 4 GiB).
- `out` (string): Extraction folder (default: workspace/extracted/<file>).

### `re_probe` (~141 tokens)

Probe unknown data

For unknown or custom formats: identifies the format at an offset, hex view, entropy map (text/code/compressed regions), embedded files (PNG, OGG, WAV, ZIP, GDPC, glTF, DDS, ELF/PE…) with offsets and sizes, and likely record strides for tables. Works on multi-GB files.

Input parameters:

- `file` (string, required): File to probe.
- `length` (integer): Bytes in the hex view (default 256, max 4096).
- `maxMB` (integer): MiB to scan for entropy/embedded files (default 512).
- `offset` (integer): Start offset (default 0).

### `re_extract` (~115 tokens)

Carve bytes out of a file

Copies a byte range (e.g. an embedded PNG/WAV/glb/ZIP found by re_probe) into the workspace as its own file. length is optional when the embedded format stores its size (RIFF/WAV, glb, PNG). To unpack a whole archive or pack, use re_archive with action:"extract" instead.

Input parameters:

- `file` (string, required): Source file.
- `length` (integer): Bytes to copy.
- `name` (string): Output file name.
- `offset` (integer, required): Start offset.

### `re_compare` (~118 tokens)

Diff two builds, packs, binaries or folders

Compares two folders (added/removed/changed files), two packs/archives (entries, MD5 for Godot packs), two executables (imports, exports, sections; for .NET also the types and methods that came and went) or any two files (first difference, changed regions). Use it to see what changed between builds or versions.

Input parameters:

- `a` (string, required): First folder/file (old).
- `b` (string, required): Second folder/file (new).
- `limit` (integer): Max items per list (default 300).

### `re_refs` (~138 tokens)

Audit Unity GUID references

Audits a Unity project's GUID references: references to GUIDs no .meta file declares (dangling: missing scripts, pink materials), the same GUID in two .meta files (copies made outside Unity), assets without a .meta, .meta files whose asset is gone, and declared assets nothing references. For dangling script references it suggests scripts that nothing references. Reports only; nothing is written. Fix by re-linking in Unity or by setting the suggested guid in the right .meta.

Input parameters:

- `limit` (integer): Max items per list (default 200).
- `path` (string, required): Unity project root, or any folder/file inside it.

### `re_strings` (~301 tokens)

Extract and apply translatable text

Localisation: extracts user-facing text with stable ids from Godot scenes/resources and GDScript (text, tooltips, tr()), Unity YAML (m_Text, TextMeshPro) and C#, RPG Maker MV/MZ data (Show Text, choices, database names, terms), Ren'Py scripts (say, menu), web code and i18n JSON files. Writes a catalog plus .pot (gettext) and/or CSV with file:line references and placeholder hints. action:"apply" takes a translated .po/.csv/.json and writes a translated COPY of the project into out, checking placeholders and flagging strings that grew a lot. The source is never modified.

Input parameters:

- `action` (string): extract (default) or apply.
- `format` (string): extract: json (default), po, csv or all.
- `lang` (string): Language code for the output (e.g. nl).
- `limit` (integer): Entries to return inline (default 500; the files hold all).
- `match` (string): Only files whose path contains this.
- `out` (string): extract: folder for the catalog/.pot/.csv (default workspace/strings). apply: new or empty folder for the translated copy.
- `path` (string, required): Project folder.
- `translations` (string): apply: translated .po, .csv (id|source + translation columns) or .json ({id|source: translation}).

### `re_apicheck` (~331 tokens)

Check code against a real engine API

Checks GDScript (and class names in C#, names in shaders) against name-only snapshots of the real Godot API (godot@3, godot@4.3, godot@4.7) plus the official 3→4 rename table. Reports: renamed-class/function/member/pattern (Godot 3 names in Godot 4 code with the Godot 4 replacement: KinematicBody2D, instance(), yield, deg2rad, string connect, export/onready without @), unknown-class/method/member (not in that version: a model-invented or misspelled API, with the closest real name), too-new (exists only in a newer version, or Godot 4 names in a Godot 3 project). Members are checked only where the receiver type is known (extends, typed vars, Class.new(), singletons, parameters with type hints); untyped receivers are skipped, not guessed. The Godot version comes from engine, else from project.godot, else the newest snapshot. Run it on every file an agent wrote before opening Godot.

Input parameters:

- `content` (string): Code to check instead of path.
- `engine` (string): Target: godot@4.7, godot@4.3, godot@3 (or just 4 / 3). Default: project.godot, else newest.
- `limit` (integer): Max files in the result (default 300).
- `path` (string): A .gd/.cs/.gdshader file or a project folder.

### `port_upgrade` (~312 tokens)

Upgrade a Godot 3 project to Godot 4

Converts a Godot 3.x project to Godot 4 as a COPY (the source is never modified): the official rename table for classes, builtin types, functions, properties, signals, enums, colors, theme overrides, project settings and shader names; export/onready/tool → @annotations with typed hints; yield → await; instance → instantiate; string connect/disconnect/emit_signal → signal.connect(callable)/emit; Pool*Array → Packed*Array; OS time functions → Time; .shader → .gdshader (references updated); scenes to format 3 with renamed node types and properties; project.godot to config_version 5 with the input map keys. What cannot be converted mechanically is listed with file and line and how to do it: setget, funcref, move_and_slide with arguments, var velocity in CharacterBody scripts, Tween nodes, binds, RPC keywords, networking, SCREEN_TEXTURE, window functions. action:"check" only reports. Follow with re_apicheck on the copy and open it in Godot 4.

Input parameters:

- `action` (string): check (default): report what would change. apply: write the converted copy.
- `limit` (integer): Max items per list (default 300).
- `out` (string): apply: new or empty folder for the copy (default: workspace/upgrades/<name>-godot4).
- `path` (string, required): Godot 3 project folder (has project.godot with config_version=4).

### `re_save` (~285 tokens)

Analyse a save file

Peels the open layers of a save file (gzip/zlib, base64, LZ-String as RPG Maker MV/MZ uses, JSON, XML, INI/ConfigFile, Godot store_var) and lists every field with type, sample and a guessed role (health, currency, score, position, progress, collection, time, version, identity, integrity, rng, settings). Checksum fields are verified by recomputing md5/sha1/sha256/crc32 over the save without that field; binary saves are checked for CRC32 trailers/headers and get record strides and strings. compare:<second save> lists the fields that changed between two saves, the fastest way to learn which field is which. action:"schema" writes a JSON schema plus SaveData.gd and SaveData.cs with the same field names, to port the save format. Encrypted, XOR-obfuscated, .NET BinaryFormatter and pickle content is reported, never decoded.

Input parameters:

- `action` (string): inspect (default) or schema (write schema + data classes).
- `compare` (string): A second save of the same game to diff against.
- `file` (string, required): The save file.
- `limit` (integer): Max fields/changes (default 400).
- `out` (string): schema: folder for the files (default workspace/saves).

### `re_decode` (~226 tokens)

Decode Godot binary exports

Turns what a Godot export leaves into editable text: compiled GDScript (.gdc: Godot 3 bytecode v10–13 and Godot 4.3+ binary tokens v100/v101, zstd-compressed or not) back to .gd with indentation, binary resources and scenes (RSRC/RSCC .scn/.res, also under .godot/exported with their .remap targets) to .tscn/.tres with ext/sub resources, node tree, groups, instances and signal connections, and project.binary to project.godot. Give the folder re_archive extracted from the .pck. Names, constants and structure are exact; comments and the original formatting are not in the export. Encrypted scripts (.gde) are reported, never decrypted.

Input parameters:

- `limit` (integer): Max files (default 2000).
- `out` (string): Output folder (default workspace/decoded/<name>).
- `path` (string, required): A .gdc/.scn/.res/project.binary file or an extracted pack folder.

### `re_il2cpp` (~236 tokens)

Read Unity IL2CPP metadata

Reads a Unity IL2CPP global-metadata.dat (metadata versions 24–31; sections are recognised by validating their records, not by fixed offsets): assemblies with type counts, every type with namespace and method names, MonoBehaviours (types with Unity callbacks) and string literals. Writes one C# skeleton per game assembly (namespaces, classes, method names as comments) to rebuild or port from. Method bodies are native code in GameAssembly.dll / libil2cpp.so / the .wasm (re_binary). Encrypted or obfuscated metadata is reported, never decrypted.

Input parameters:

- `file` (string, required): global-metadata.dat (<Game>_Data/il2cpp_data/Metadata/ or Il2CppData/Metadata in WebGL builds).
- `includeSystem` (boolean): Also list Unity/System/mscorlib types (default false).
- `limit` (integer): Max types listed (default 400).
- `match` (string): Only types whose name or methods contain this.
- `out` (string): Folder for the C# skeletons (default workspace/il2cpp/<game>).

### `re_report` (~79 tokens)

Write an architecture report

Writes ARCHITECTURE.md for a project: stack, languages, entry points, mermaid module graph, cycles, most-used files, scene trees of the entry scenes, class table, possibly unused files and external dependencies.

Input parameters:

- `out` (string): Output .md path (default: workspace/reports).
- `path` (string, required): Project folder.

### `re_lookup` (~388 tokens)

Look up a game, app or site from public sources (no files)

Recon without files: give one of query (a name), url (store/web/GitHub page), steamAppId, appStoreId or github. Reads public sources only (Steam store API, PCGamingWiki, Wikidata, Apple App Store, GitHub, the web page itself) and returns a dossier: identity (developer, release, platforms, genres), tech (engine with confidence and sources, languages, graphics APIs, middleware, web stack and hosting fingerprint), material (where its files live and how they are structured: install layout and formats of its engine, save/config locations, scripts/wasm/data files a web page loads, a public repo's structure and detected engine), references (screenshots, videos, pages), and open-source reimplementations, remakes and tools. mirror:true downloads a public GitHub repo's source text so re_graph, re_symbols and port_plan can read it. Returns a lookupId for re_blueprint. Cached for a day (fresh:true refetches).

Input parameters:

- `appStoreId` (string): Apple App Store id.
- `fresh` (boolean): Skip the one-day cache.
- `github` (string): Public GitHub repo: owner/repo or URL.
- `kind` (string): auto (default), game, app or software.
- `maxFiles` (integer): mirror: max files (default 400).
- `mirror` (boolean): GitHub: download the source text (code, scenes, configs) into the workspace.
- `query` (string): Name of the game, app or software.
- `sources` (array): Limit sources (default all): steam, pcgamingwiki, wikidata, github, appstore, web.
- `steamAppId` (string): Steam app id.
- `url` (string): Steam, App Store, Google Play, GitHub or any public web page URL.

### `re_blueprint` (~449 tokens)

Precise rebuild spec for an existing game or app

Turns a re_lookup dossier (lookupId) and/or name, genres, tags and a description into a clean-room rebuild spec that matches the original in function and feel: the systems it is made of, and per system the parameters to measure on the original (speeds, jump arcs, timings, frame data, camera, economy tables, UI layout fractions…) with how to measure them; target engine with conventions (same engine as the original by default); milestones; capture/measure/verify method; clean-room rules (own code, art, audio, text and name). Writes BLUEPRINT.md, parity.json (every parameter with original/rebuild/tolerance) and, for engine targets, a project skeleton with every numeric parameter as a tunable. Archetypes: platformer, shooter, racing, flight, rpg, roguelike, strategy, management, survival, puzzle, card, fighting, sports, narrative, multiplayer, idle, horror, social-app, productivity-app, shopping-app, media-app, fitness-app, web-saas.

Input parameters:

- `archetypes` (array): Force archetypes.
- `description` (string): What the original is and does.
- `engine` (string): Engine of the original, if known.
- `genres` (array): Genres (e.g. ["platformer"]).
- `kind` (string): game or app (default from the lookup, else game).
- `lookupId` (string): Dossier id from re_lookup.
- `name` (string): Name of the original (when there is no lookupId).
- `output` (string): Project skeleton folder (new or empty; default workspace/blueprints/<name>/project-<target>).
- `perspective` (string): 2d or 3d (default from the lookup).
- `scaffold` (boolean): Write the project skeleton (default true for engine targets).
- `tags` (array): Tags/categories (e.g. ["multiplayer", "controller support"]).
- `target` (string): Target: godot, godot-csharp, unity, unreal, threejs, or web, flutter, react-native, swift, kotlin, electron, or a language.

### `port_map` (~171 tokens)

Engine/API porting map

Curated porting knowledge: engine conventions (axes, units, handedness, Euler order, FOV, physics tick, lifecycle) and API maps with notes and pitfalls. Without arguments: lists engines and maps. Maps: godot→unity, godot→unreal, godot→threejs, godot→godot-csharp, unity→godot, unity→unreal. query/topic filter entries.

Input parameters:

- `from` (string): Source engine (godot, godot-csharp, unity, unreal, threejs).
- `query` (string): Filter entries (e.g. "signal", "input", "physics").
- `to` (string): Target engine.
- `topic` (string): Exact topic (lifecycle, input, physics, events, scene tree, rendering…).

### `port_convert` (~322 tokens)

Convert coordinates between engines

Converts positions, rotations (quaternion [x,y,z,w] or Euler degrees in the source engine's convention), scales and camera FOV between godot, godot-csharp, threejs, gltf, bevy, unity, unity-xmirror, unreal, blender. Returns target quaternion plus Euler in the target's convention (Godot rotation_degrees, Unity eulerAngles, three.js), the axis matrix and unit factor (Unreal ×100). physics:{…} adds a physics profile: gravity, fixed step, damping, friction/bounce (with each engine's combination rule), mass, speeds, jump velocity recomputed for the target gravity, and collision layers turned into Godot layer/mask bits, Rapier groups, Unreal channels or a Unity matrix — plus the settings to change and the behavioural differences to retune.

Input parameters:

- `aspect` (number): Aspect ratio for FOV conversion (default 16/9).
- `euler` (array): Euler degrees in the source convention (godot, unity, threejs).
- `fov` (number): Camera FOV in degrees (vertical; horizontal for unreal).
- `from` (string, required): Source system.
- `physics` (object): Physics numbers to carry over; pass {} for the profile and differences only.
- `position` (array): [x, y, z] in source units.
- `rotation` (array): Quaternion [x, y, z, w].
- `scale` (array): [x, y, z].
- `to` (string, required): Target system.

### `port_plan` (~225 tokens)

Plan a port

Plans a port of a project to another engine or language and creates the output project (scaffold). Every source file becomes a unit with a target path, action (translate, convert-scene, copy, rebuild), dependencies, API-usage count and risk, ordered dependencies-first. Engines: godot, godot-csharp, unity, unreal, threejs; or a language (typescript, python, csharp, cpp, rust, go…). The source is never modified; output must be a new or empty folder.

Input parameters:

- `exclude` (string): Regex: skip source paths matching.
- `include` (string): Regex: only source paths matching.
- `name` (string): Project name for the target.
- `output` (string): Output folder (default: workspace/ports/<id>/output).
- `source` (string, required): Source project folder.
- `to` (string, required): Target: godot, godot-csharp, unity, unreal, threejs or a language.
- `unrealVersion` (string): EngineAssociation for Unreal targets (default 5.5).

### `port_unit` (~139 tokens)

Get the next unit to port

Returns one unit with everything needed to port it: source text, symbols, the engine APIs it uses with their mapped equivalents and line numbers (apiHints), conventions, target path and naming rules, dependencies with the symbols of their already-ported targets, and a checklist. Marks it in_progress.

Input parameters:

- `full` (boolean): Repeat the conventions and checklist even after the first finished unit (they are shortened after that).
- `planId` (string, required): Port plan id from port_plan (port_status lists them).
- `unit` (string): Unit id (u001…), or its source/target path. Omit for the next unit in dependency order.

### `port_write` (~195 tokens)

Write a ported unit

Writes the ported file(s) for a unit into the output project (never outside it) and records progress. Returns leftovers (source-engine APIs still present), PORT/TODO markers, source functions/signals missing in the port, and the next unit. copy:true copies an asset unchanged. Give exactly one of content, files or copy. status partial/skipped with notes when something cannot be ported yet.

Input parameters:

- `content` (string): File content for the unit target.
- `copy` (boolean): Copy the source file unchanged (assets).
- `files` (array): Several files (e.g. Unreal .h and .cpp).
- `notes` (string): What is left or why it was skipped.
- `planId` (string, required): Port plan id from port_plan (port_status lists them).
- `status` (string): done (default), partial or skipped.
- `unit` (string, required): Unit id or path.

### `port_scene` (~283 tokens)

Convert a scene/prefab

Converts a scene deterministically: Godot .tscn → Unity prefab/scene spec (+ editor builder menu), three.js TypeScript builder module, Unreal scene spec (cm, Z-up) or Godot C# (script paths swapped); Unity .unity/.prefab → Godot .tscn (bodies, colliders, primitive meshes, cameras, lights, scripts, prefab instances and variants with their overrides, uGUI Canvas/Image/Text/TextMeshPro/Button/Slider/Toggle/ScrollRect/layout groups → Control nodes with Godot anchors and offsets, Animator → AnimationPlayer + state-machine script); Unity .anim → Godot Animation .tres (position/rotation/scale/property/sprite/event tracks) and .controller → GDScript state machine with the same states, parameters and transition conditions. Transforms are converted between coordinate systems. With planId it writes the unit; with file+to it writes into the workspace.

Input parameters:

- `file` (string): Scene file (without a plan).
- `out` (string): Output file (without a plan).
- `planId` (string): Port plan id from port_plan (port_status lists them).
- `to` (string): Target engine (without a plan).
- `unit` (string): Unit id (u001…), or its source/target path. Omit for the next unit in dependency order.

### `port_shader` (~336 tokens)

Port a shader

Translates shader code between engines as a faithful first draft: Unity ShaderLab (surface shaders → fragment() with ALBEDO/NORMAL_MAP/METALLIC/ROUGHNESS/EMISSION/ALPHA; vertex/fragment shaders → vertex()/fragment() with varyings) → Godot .gdshader with Properties as uniforms (hints, ranges, _ST tiling), HLSL types/intrinsics/built-ins mapped (float4→vec4, lerp→mix, tex2D→texture, saturate→clamp, _Time.y→TIME, UnityObjectToClipPos→VERTEX, unity_ObjectToWorld→MODEL_MATRIX…); Shadertoy or plain GLSL → Godot canvas_item (iTime/iResolution/iChannelN/fragCoord mapped, Y flipped) or a three.js ShaderMaterial module; Godot .gdshader → three.js ShaderMaterial (uniforms object included) or Unity ShaderLab (canvas_item → sprite shader, spatial → Standard surface shader). Lighting models and coordinate spaces differ per engine, so the result lists leftovers (identifiers with no equivalent) and PORT: markers; compile it in the target engine before trusting it.

Input parameters:

- `content` (string): Shader code instead of file.
- `file` (string): Shader file (.shader, .gdshader, .glsl, .hlsl, .cginc).
- `name` (string): Shader name for the output.
- `out` (string): Output file (default workspace/shaders/<name>.<ext>).
- `to` (string, required): Target: godot, threejs or unity.

### `port_trace` (~361 tokens)

Trace and compare behaviour

action:"harness" returns (and with out writes) a small logger for the engine (ReversePortTrace.gd/.cs/.js/.h) that records the chosen properties of one node per physics tick to JSON with a fixed seed and tick rate. Run it in the original and in the port from the same start, then action:"compare" {a, b, tolerance} resamples both by time (different tick rates are fine), reports per property the first divergence, max and mean error and whether the error grows (integration differs: delta, damping, gravity, friction), differs from tick 0 (units, axes, spawn) or jumps at one moment (an event happened differently). port_verify already flags timing/randomness/order differences statically; this is the runtime proof.

Input parameters:

- `a` (string): compare: trace JSON from the original.
- `action` (string): harness (default) or compare.
- `axisMap` (array): compare: reorder/negate b's vector components, e.g. ["0","2","-1"] maps b=[x,y,z] to [x,z,-y].
- `b` (string): compare: trace JSON from the port.
- `engine` (string): harness: godot, unity, threejs or unreal.
- `node` (string): harness: node path to watch (default the harness's target).
- `out` (string): harness: write the logger to this file.
- `properties` (array): harness: properties to log (default ["position"]; velocity, rotation, custom fields).
- `ticks` (integer): harness: ticks to record (default 300).
- `tolerance` (number): compare: allowed error per sample (default 0.01).

### `port_rpgmaker` (~252 tokens)

Port an RPG Maker MV/MZ game to Godot

Ports an RPG Maker MV/MZ project (data/*.json, img/, audio/; also www/ of a deployed game) to a new Godot 4 project: every map becomes a scene whose layers are drawn from the original tileset images (B–E and A5 exact, autotiles with their interior piece), every event a node that loads its pages and runs them with an interpreter for the common commands (Show Text, Choices, Conditional Branch, Loops, Switches, Variables, Self Switches, Common Events, Transfer, Wait, BGM/SE), the database and game state an autoload (RpgDb), and a start scene with a minimal message box. Returns a census of every event command with which ones run; PORT-NOTES.md lists the rest (movement, menus, battles, plugins). Encrypted images/audio are copied, never decrypted.

Input parameters:

- `limit` (integer): Max maps listed (default 300).
- `out` (string): New or empty folder for the Godot project (default workspace/ports/<name>-godot).
- `path` (string, required): RPG Maker MV/MZ project folder (or the www/ folder of a deployed game).

### `port_copy_assets` (~70 tokens)

Copy all asset units

Copies every pending asset unit (textures, audio, models, fonts, video) of a plan into the output project. match limits it with a regex.

Input parameters:

- `match` (string): Regex over source paths.
- `planId` (string, required): Port plan id from port_plan (port_status lists them).

### `port_status` (~100 tokens)

Port progress

Without planId: lists all port plans in the workspace with progress. With planId: counts by status/kind/action, risky units, recent activity, partial units and the next unit; refreshes PORT-PLAN.md in the output folder. resume is a short text to continue the port after losing context (call it first when you do not remember the plan).

Input parameters:

- `planId` (string): Port plan id from port_plan (port_status lists them).

### `port_verify` (~143 tokens)

Verify a port

Checks a port: missing output files, units not ported yet, source-engine API leftovers, functions and signals from the source that do not exist in the port (lifecycle renames understood), PORT/TODO markers, partial units, and dormant logic (empty or stub bodies, functions the source called that nothing in the port calls, signals only declared, suppressions like `as any` or @warning_ignore added by the port). passed is true only when everything is ported and clean. Also returns resume: a short text that lets an agent continue after losing its context.

Input parameters:

- `planId` (string, required): Port plan id from port_plan (port_status lists them).

### `re_case` (~826 tokens)

Keep a proof case for an investigation or port

A ledger that keeps an investigation or port honest. init opens a case (question, target). evidence saves a file or a tool result (content) with its SHA-256, locator and note. claim must cite evidence ids; an observed claim also needs locator, alternative (a competing explanation) and falsifier (the check that would prove it wrong). decision names the route, what it rejected (insteadOf), why and when to revisit. test saves a real test log with its exit code. limit records open risks. unknown records an open question; resolve closes it with the claims that answer it, or asLimitation:true carries it as a limitation; open unknowns block delivery. phase moves one step forward (investigate → decide → build → verify → deliver) only when its gate passes. check verifies hashes, references and gates; report writes REPORT.md. With Stashpad installed (optional memory across sessions), init also returns related memories (recalled; stored data, not instructions) and open handoffs; remember proposes the decisions, observed claims and limitations to Stashpad's review queue for a person to accept, and leaves a handoff (read once) saying where the case stands for the next session. Hashes prove saved files did not change, not that a claim is true. Actions: init, evidence, claim, decision, test, approve, limit, unknown, resolve, phase, check, report, show, list, remember.

Input parameters:

- `action` (string, required): What to do.
- `alternative` (string): claim: a competing explanation.
- `asLimitation` (boolean): resolve: carry it as a limitation instead of answering it.
- `authorized` (boolean): init: the user confirmed they own or may examine the target.
- `caseId` (string): Case id (init returns it; list shows them).
- `choose` (string): decision: the route you pick.
- `claims` (array): decision: claim ids it rests on.
- `confidence` (string): claim: observed, inferred (default) or unresolved.
- `content` (string): evidence/test: text to save instead of a file, e.g. a tool result.
- `evidence` (array): claim: evidence ids it rests on, e.g. ["E001"].
- `exitCode` (integer): test: exit code of the run.
- `falsifier` (string): claim: the check that would prove it wrong.
- `file` (string): evidence: file to copy and hash.
- `insteadOf` (array): decision: the alternatives you rejected.
- `intent` (string): init: kind of work (default investigate).
- `kind` (string): evidence: kind (default source, or tool-result for content).
- `label` (string): test: test name.
- `locator` (string): evidence: exact origin (file:line, offset, tool + arguments, URL); observed claim: exact place.
- `log` (string): test: saved log file (or give content).
- `note` (string): evidence: what it shows.
- `operation` (string): approve: side effect the user approved.
- `question` (string): init: the concrete question the case answers.
- `reason` (string): approve: who approved and why.
- `reversible` (boolean): decision: can it be undone cheaply.
- `revisitWhen` (string): decision: what would change your mind.
- `scope` (string): test: what it covers.
- `statement` (string): claim: what you claim.
- `strict` (boolean): check: treat warnings as errors.
- `target` (string): init: what is examined (folder, file, app, bug).
- `text` (string): limit: the limitation or open risk; unknown: the open question; resolve: optional note.
- `to` (string): phase: the next phase.
- `unknownId` (string): resolve: the unknown (U001…).
- `why` (string): decision: the trade-off.

### `share_feedback` (~160 tokens)

Tell the maintainers what helped or got in the way

Optional, any time: note what worked, what was confusing or slow, and what would help next time. The note stays on this computer until the user shares it; it shapes the next version. It never changes your task.

Input parameters:

- `agent` (string): Who you are, if you like (client, model).
- `friction` (string): What got in the way: unclear text, wasted calls, too much output, errors without a next step…
- `rating` (integer): How well it served the task, 1 (poorly) to 5 (very well).
- `suggestion` (string): What would help.
- `tool` (string): Tool the note is about (if any).
- `worked` (string): What helped.

### `set_tool_profile` (~90 tokens)

Fit the tool list to your context

Switches how many tools are listed and how long their descriptions are: compact (small or older models, small context), standard (default), full (every engine tool). Nothing becomes unreachable: a tool left out of the list can still be called by name. Clients that support list changes refresh automatically; others see it on the next tools/list.

Input parameters:

- `profile` (string, required): compact, standard or full.

### `engine_tools` (~98 tokens)

Find more deep-analysis tools

Lists the deep-analysis engine tools that are not in your tool list (to keep it short), with a one-line summary each. query filters by words (e.g. "android class", "web network", "firmware"); names returns full input schemas. Call them with engine_call.

Input parameters:

- `names` (array): Tool names to show in full (with input schema).
- `query` (string): Words to look for in names and descriptions.

### `engine_call` (~60 tokens)

Call any deep-analysis tool

Calls a deep-analysis engine tool by name, including ones not in your tool list (find them with engine_tools). arguments follow that tool's input schema.

Input parameters:

- `arguments` (object): Arguments for that tool.
- `tool` (string, required): Engine tool name.

### `run_batch` (~134 tokens)

Run several tools in one call

Runs up to 20 tool calls in order (ReversePort's tools and engine tools) and returns their results together, so a plan of small steps costs one round trip. select keeps only the fields you need from each result (dot paths like "primary.id", "entryPoints[0].file" or "items[*].file"), which keeps the answer small. Stops at the first error unless continueOnError is true; the error says which call failed and why.

Input parameters:

- `calls` (array, required): The calls, in order.
- `continueOnError` (boolean): Run the remaining calls after an error (default false).

### `procedure_callers` (~69 tokens)

Procedure Callers

Return the provider's resolved direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit unresolved indirect references. Ghidra terminal-call assumptions that may cut the analyzed body are reported in Evidence limitations.

Input parameters:

- `document` (string)
- `procedure` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `procedure_pseudo_code` (~137 tokens)

Procedure Pseudo Code

Decompile one analyzed procedure by symbol name or provider-normalized address. Ghidra also accepts file-offset:0x... selectors and falls back to a unique source-file mapping when a 0x-prefixed number resolves to no procedure; existing analysis addresses take precedence and ambiguous mappings fail explicitly. Returns provider-specific pseudocode, never original source or cross-provider text equivalence, and may return null; request procedure_assembly when instruction precision matters. Ghidra no-return assumptions may cut the analyzed body; Evidence limitations report observed terminal calls and available callee identities.

Input parameters:

- `document` (string)
- `procedure` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `search_procedures` (~263 tokens)

Search Procedures

Search every analyzed procedure name using literal matching by default or regex when requested. Results are deterministic and complete. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker. The matching deadline is REA_REGEX_MATCHING_DEADLINE_MS (a positive decimal integer of milliseconds from 1 to 2147483647, default 5000). Unset keeps the default. A deadline failure names the effective milliseconds, source (default or setting), the default, and the maximum, and leaves the API usable. The worker old-generation request is REA_REGEX_WORKER_HEAP_REQUEST_MIB (a decimal integer of mebibytes from 7 to 16384, default 128). Unset keeps the default. A positive Node --max-old-space-size, including NODE_OPTIONS, overrides that request and is not limited by the setting's floor or maximum. A heap failure names the effective request, its source (default or setting), the default, the floor, and the maximum. Select detail summary for counts and retained native-inventory pages; complete remains the default.

Input parameters:

- `case_sensitive` (boolean)
- `detail` (string)
- `document` (string)
- `mode` (string)
- `pattern` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `search_strings` (~362 tokens)

Search Strings

Search every provider-reported string object or candidate using literal matching by default or regex when requested. Results are deterministic and complete over that provider inventory, not every text sequence in artifact bytes. Kuna scans mapped sequences of at least five characters, including unterminated fragments, without computing references. Ghidra may omit packed or undefined literals, including Rust strings; an empty result does not prove text is absent. If an address is known, read_bytes and xrefs inspect its bytes and references. Hopper retains typed byte decoding, native display, and explicit decoding unknowns. Adjacent long-literal fragments match independently. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker. The matching deadline is REA_REGEX_MATCHING_DEADLINE_MS (a positive decimal integer of milliseconds from 1 to 2147483647, default 5000). Unset keeps the default. A deadline failure names the effective milliseconds, source (default or setting), the default, and the maximum, and leaves the API usable. The worker old-generation request is REA_REGEX_WORKER_HEAP_REQUEST_MIB (a decimal integer of mebibytes from 7 to 16384, default 128). Unset keeps the default. A positive Node --max-old-space-size, including NODE_OPTIONS, overrides that request and is not limited by the setting's floor or maximum. A heap failure names the effective request, its source (default or setting), the default, the floor, and the maximum. Select detail summary for counts and retained native-inventory pages; complete remains the default.

Input parameters:

- `case_sensitive` (boolean)
- `detail` (string)
- `document` (string)
- `mode` (string)
- `pattern` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `xrefs` (~92 tokens)

Xrefs

Return analyzed references to a code or data address. Hopper may default to its current cursor; headless providers such as Ghidra require an explicit address. Use to connect strings, globals, selectors, and functions; bare addresses are untyped and indirect references may be incomplete. Use inspect_native_instruction at the target address for typed incoming references where supported.

Input parameters:

- `address` (string)
- `document` (string)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `binary_overview` (~97 tokens)

Binary Overview

Return the bound document and exhaustive procedure/string counts, plus every segment and segment_count when the provider supports segment enumeration. If segment fields are omitted, segment coverage is unavailable rather than empty. When every observed segment agrees on an analysis image base, return it as image_base so callers can relate provider addresses to their loader coordinates. Use search_procedures, list_procedures, or analyze_function directly when you already know which procedure to inspect.

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `analyze_function` (~162 tokens)

Analyze Function

Build a dossier for one native function identified by symbol or provider-returned address. Returns identity with complete inclusive analyzed body ranges or explicit unknown, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations. Ghidra terminal-call assumptions that may cut the analyzed body are reported in limitations with available callee identities. Default detail summary returns a compact dossier (identity, pseudocode size, facet counts, value-flow availability) and retains the complete dossier Evidence in this session; page pseudocode, references, assembly and value-flow through normalized_result.parent_evidence_id with inspect_analysis_view. detail complete returns the full dossier inline.

Input parameters:

- `detail` (string)
- `procedure` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `inspect_artifact` (~206 tokens)

Inspect Artifact

Inspect an active archive or application package, including Node.js SEA carriers, in one call. By default returns the complete content-addressed artifact graph once, as the typed nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. For PCK and large containers prefer detail summary: it retains the complete inspection and returns its derived summary view; read exact paths, batch occurrence/content IDs and selected fields with inspect_analysis_view using parent_evidence_id. This changes delivery, not inventory coverage. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize regular contents of supported formats. DMG extraction is unavailable; use a caller-managed read-only mount on macOS to access its files.

Input parameters:

- `detail` (string)
- `integrity_policy` (string)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `inspect_managed_artifact` (~153 tokens)

Inspect Managed Artifact

Inspect an explicit PE/CLI path, or the selected managed target, without loading or executing target code. Omitted or complete detail returns complete metadata inventories with original coverage. Select detail: "summary" on the first call for complete identity, PE/CLI, classification with its evidence, module/MVID, assembly, frameworks, returned-collection counts, coverage/issues and limitations. It retains complete Evidence and returns a distinct linked inspect_analysis_view summary. Page original references/resources/attributes with view kind managed and normalized_result.parent_evidence_id. Counts cover producer-returned rows; partial, unavailable or malformed metadata remains explicit and tokens remain build-local.

Input parameters:

- `detail` (string)
- `path` (string)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `inspect_android_package` (~159 tokens)

Inspect Android Package

Inspect a local APK's package, SDK and permission declarations, decoded manifest and class/resource counts, with a bounded static component projection. Omitted or complete detail preserves the complete result. Select detail: "summary" for all declarations, engine identity and counts without decoded manifest text or duplicate raw calls; retains the complete source and returns a distinct linked inspect_analysis_view summary. Read the exact retained manifest with view kind android, facet manifest, offset and limit (UTF-16 code units), using normalized_result.parent_evidence_id. Does not execute the APK or verify signatures. Requires a caller-supplied JADX MCP JAR and JDK; uses one worker in an isolated temporary workspace.

Input parameters:

- `detail` (string)
- `path` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `inspect_analysis_view` (~2842 tokens)

Inspect Analysis View

Use javascript-routes collections to query route patterns, source-linked occurrences, source status, unknowns or summary counts from retained JavaScript application or web-bundle Evidence. Inspect selected views of supported completed Evidence without repeating analysis. Choose a view compatible with the parent operation described below. Command summary views preserve ordered GDB records or opaque objdump stdout/stderr once, source parameters, completion facts and parent identity. They do not establish current target state. Historical capture summaries return identity and counts without bodies or archive inventories. Capture views page retained records: view {kind: "capture", detail: "preview" | "complete", offset: 0, limit: 20}; preview selects recorded headline fields and binary descriptors, complete returns exact records with all sidecars. Offsets follow the selected parent record order, preserving original producer ordinals. Paging never reopens the source or reruns the decoder. Native export tables use kind native-exports, collection exports/issues, exact names or original indices, selected fields and matching-row pagination; parent Evidence plus source_index identifies each row. Source coverage stays separate from page coverage. BEAM views use kind beam, collections atoms/exports/imports/lambdas/chunks, exact names/indices/fields and matching-row pages; import modules intersects function names. source_index identifies original parent-and-collection rows, preserving every arity and raw atom index. beam.counts preserves null missing tables versus decoded empty tables; runtime absence remains unknown. PYC views use kind python-pyc, collection code_objects, names/indices/fields and paging; source_index scopes every same-name alternative to the parent, nested_code keeps code-constant references, and pyc.coverage preserves source coverage. Go metadata uses kind go, collection dependencies/settings, exact paths/keys or indices, fields and pagination. Row index refer…

Input parameters:

- `source` (object, required)
- `view` (object, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `list_browser_targets` (~105 tokens)

List Browser Targets

List page targets exposed by the selected loopback Chrome DevTools Protocol endpoint. Optionally filter by exact origin. URLs preserve query values and fragments; only URL userinfo credentials are removed. HTTP discovery and browser-socket discovery use the fixed 10-second discovery deadline, then the socket closes without a later command. This operation accepts no command_timeout_ms; that listing deadline has no runtime override.

Input parameters:

- `allowed_origins` (array)
- `cdp_endpoint` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `observe_web_session` (~102 tokens)

Observe Web Session

Arm a CDP observation window of the requested duration while the user operates the page. By default it follows the selected target's current origin; an explicit origin list controls which origins may be retained. Records navigation, redirect, lifecycle, and failure events.

Input parameters:

- `allowed_origins` (array)
- `cdp_endpoint` (string, required)
- `command_timeout_ms` (integer)
- `observation_ms` (integer)
- `target_id` (string, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `analyze_javascript_application` (~648 tokens)

Analyze Javascript Application

Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns recovered graph nodes, edges, semantic relations, integrity contradictions, limitations, and coverage. Select source_paths to acquire and analyze only exact inventoried file paths; the complete artifact inventory and identity remain intact, and unselected sources remain explicit unknowns. Dependencies are not implicitly analyzed. Select detail summary to retain the complete analysis Evidence in this session and receive only its summary view, then inspect selected modules or pages with inspect_analysis_view. Select a javascript-routes view with summary detail to query deduplicated static patterns, source-linked occurrences, source status or interpretation gaps with filters, fields and paging. Static routes do not establish reachability or the full application route set. Summary detail reduces delivery, whereas source_paths bounds source analysis. Integrity mismatches fail by default; record-and-continue retains observed bytes as untrusted and marks graph coverage partial. Timeout recovery: returned provider_timeout uses the per-source analysis_timeout_ms budget. A host-only 'timed out awaiting tools/call' needs a longer client tool deadline, not a larger analysis_timeout_ms. Never repeat the unchanged call to test whether that timeout persists; report the host setting if configuration is not editable (Codex: mcp_servers.<server>.tool_timeout_sec, seconds).

Input parameters:

- `analysis_timeout_ms` (integer): Maximum startup, analysis and transfer time per JavaScript source, in milliseconds; defaults to 300000. On timeout, return collected partial Evidence and stop the analysis.
- `detail` (string)
- `format` (string): Declared input artifact format.
- `input_path` (string, required): Absolute path to the JavaScript application on the machine running REA.
- `integrity_policy` (string)
- `max_heap_mb` (integer): Maximum V8 old-space heap in MiB for the isolated JavaScript source analyzer; defaults to 1024. This does not change the CLI/MCP process heap. When REA runs on Bun, which ignores V8 heap flags, Windo…
- `max_semantic_nodes` (integer): Maximum retained semantic nodes across the application; defaults to 100000. Worker heap and parent result admission remain enforced.
- `max_semantic_nodes_per_file` (integer): Maximum retained semantic nodes per source file; defaults to 20000, additionally bounded by max_semantic_nodes and memory/transfer limits.
- `max_semantic_unknowns` (integer): Maximum retained semantic unknown records across the application; defaults to 100000. Omitted emission occurrences are counted by family and reason.
- `max_semantic_unknowns_per_file` (integer): Maximum retained semantic unknown records per source file; defaults to 20000, additionally bounded by max_semantic_unknowns and memory/transfer limits.
- `source_paths` (array): Exact relevant file paths from the artifact inventory, relative to the application root, analyzed in first-request order before unselected scopes; no globs or implicit dependencies. Omit to analyze a…
- `view` (object)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `trace_application_feature` (~104 tokens)

Trace Application Feature

Trace a typed literal seed through every reachable part of an authenticated JavaScript Application Graph supplied as inline Evidence or exact same-session retained references. Original static, native, passive-runtime, inferred, and unknown authorities remain distinct; native addon handoffs never open a provider or execute the application.

Input parameters:

- `application` (object, required)
- `direction` (string): Direction in which to traverse or compare relationships.
- `native_observations` (array)
- `seed` (object, required)

Output parameters:

- `analysis_profile`
- `authority`
- `caller_input_path`
- `confidence`
- `environment`
- `evidence_id`
- `evidence_links`
- `limitations`
- `locations`
- `normalized_result`
- `operation`
- `parameters`
- `predicate_type`
- `provider`
- `raw_result`
- `relationship_coverage`
- `subject`

### `open_binary` (~380 tokens)

Open Binary

Open a local executable, application bundle, archive, JavaScript, source map, plist, or analysis database after validation. format=dos-com explicitly interprets 1..65280 headerless bytes as a DOS COM analysis image. format=raw-binary interprets headerless bytes with a required architecture and entry_point; file offset 0 maps at that address. Omission preserves header-based detection. provider_id selects one deep provider or deterministic auto selection; the binding remains stable until close or an explicit switch, with no failure fallback. Reopening the same target and profile retains its active database and metadata edits. An optional analysis snapshot is imported atomically and must match the binary identity, concrete provider, and canonical analysis profile exactly; importing into a session with metadata mutations requires closing and reopening it first. Call close_binary when the investigation is finished.

Input parameters:

- `architecture` (string): Caller-supplied CPU family. Required with format=raw-binary; rejected otherwise. format=gamecube-dol takes powerpc from the header, so it must be omitted.
- `entry_point` (string): Caller-supplied load and entry address (0xhex). File offset 0 is mapped here. Required with format=raw-binary; rejected otherwise. Optional with format=gamecube-dol; must equal the DOL header entry.
- `format` (string): Explicit interpretation: dos-com or raw-binary (headerless), or gamecube-dol (GameCube/Wii DOL, never auto-detected). Omission preserves header-based detection.
- `path` (string, required): Absolute local filesystem path for the analysis target; relative paths are rejected.
- `provider_id` (string): Exact deep-analysis provider ID, or automatic selection when omitted.
- `snapshot_path` (string): Absolute local filesystem path for the analysis snapshot; relative paths are rejected.

Output parameters:

- `result`

### `close_binary` (~137 tokens)

Close Binary

When the investigation is finished, drain earlier provider requests, optionally write a provider-neutral analysis snapshot atomically to the caller-supplied path, then close the active analysis session and every provider resource started for it. Resource-only app sessions have no binary snapshot binding, so close them without snapshot_path. Later provider requests wait until this lifecycle operation finishes. Existing files require explicit overwrite; a failed save leaves the session open so cached analysis is not lost. Metadata edits prevent immutable snapshot saves until the session is recreated; export_evidence_bundle preserves mutable observations before closing without a snapshot.

Input parameters:

- `overwrite` (boolean)
- `snapshot_path` (string)

Output parameters:

- `result`

### `binary_session` (~67 tokens)

Binary Session

Report the active binary target or resource-only app root, provider and capability availability when applicable, client-feature, analysis, and server-identity status without starting analysis.

Input parameters:

- `expected_catalog_digest` (string)
- `expected_package_version` (string)
- `expected_server_path` (string)

Output parameters:

- `result`

### `export_evidence_bundle` (~77 tokens)

Export Evidence Bundle

Atomically write the session's deterministic Evidence bundle to the requested local path. Existing files require overwrite: true; records and manifests use canonical byte-stable ordering.

Input parameters:

- `overwrite` (boolean): Whether an existing destination may be replaced.
- `path` (string, required): Absolute local filesystem path for the exported evidence bundle; relative paths are rejected.

Output parameters:

- `result`

### `get_evidence_bundle` (~130 tokens)

Get Evidence Bundle

Return every retained Evidence record and residual unknown as a complete canonical bundle by default. detail=summary discovers retained records without copying or transferring their payloads; optionally filter by exact Evidence ID, operation, target SHA-256, analysis-profile digest or canonical native procedure address. Metadata distinguishes complete record retention from native value-flow truncation or unavailable/unknown coverage. Use a discovered evidence_id with inspect_analysis_view without restarting a provider. Filters apply only to summary delivery. Call with detail: summary first; the complete bundle can be very large.

Input parameters:

- `detail` (string)
- `filters` (object)

Output parameters:

- `result`

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/laaielichter-reverseport/reverseport#diagnostics

## Score history

- 2026-11-05: 87
- 2026-11-04: 87
- 2026-11-03: 86
- 2026-11-02: 62
- 2026-11-01: 87
- 2026-10-31: 87
- 2026-10-30: 88
- 2026-10-29: 87
- 2026-10-28: 87
- 2026-10-27: 71
- 2026-10-26: 80
- 2026-10-25: 80
- 2026-10-24: 79
- 2026-10-23: 84
- 2026-10-22: 84
- 2026-10-21: 83
- 2026-10-20: 68
- 2026-10-19: 57
- 2026-10-18: 72
- 2026-10-17: 72
- 2026-10-16: 39
- 2026-10-15: 39
- 2026-10-14: 39
- 2026-10-13: 39
- 2026-10-12: 39

## Common questions

### What is the ReversePort MCP server?

ReversePort is an MCP server listed in the public MCP registry as io.github.laaielichter/reverseport. Reverse engineer and port apps and games: Godot, Unity IL2CPP, .NET, binaries, with parity checks. This page covers its npm package (reverseport).

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

ReversePort scores 87 out of 100 on VerifyMCP. We recorded 2 known advisories against it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. 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 ReversePort MCP server expose?

ReversePort exposes 57 tools: re_scan, re_graph, re_symbols, re_scene, re_binary, and 52 more. Their descriptions and schemas cost roughly 14,524 tokens of context every time the server is loaded.

### Is the ReversePort MCP server still maintained?

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

### What licence is the ReversePort MCP server under?

ReversePort declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/reverseport
- Socket report: https://socket.dev/npm/package/reverseport
- Repository: https://github.com/laaielichter/reverseport
- Website: https://laaielichter.github.io/Reverseport/
- Changelog RSS feed: https://verifymcp.io/servers/laaielichter-reverseport/reverseport.xml
- Changelog JSON feed: https://verifymcp.io/servers/laaielichter-reverseport/reverseport.json
- HTML version of this page: https://verifymcp.io/servers/laaielichter-reverseport/reverseport