nexora-engine
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Introduction
NEXORA ENGINE helps developers inspect source code and executable artifacts, connect analysis evidence, and investigate software architecture. Choose the small offline CLI for local reports or build the provider-backed CLI/MCP engine for deeper workflows.
Development source. No official npm package, prebuilt release or hosted service is offered. Findings distinguish observations, static candidates and unknowns; a graph is not proof of runtime behavior.
Related MCP server: Jukeyman Unleashed
First run
First analysis in three commands, with Git and Node.js 24.22.1 available:
git clone https://github.com/NADER-CY/nexora-engine.git
cd nexora-engine
node nexora/bin/nexora.mjs analyze-project examples/tutorial/cycleThis dependency-free command needs no installation or build. The included two-file sample returns JSON with this actual selected result:
{"architecture":{"schema":"nexora-architecture/v1","cycles":[{"members":["a.js","b.js"]}]}}The full report also includes hashes, import evidence, coverage and limitations. Understand the output · Captured demonstrations.
Capabilities
Workflow | Available scope | Important limit |
Source | Lexical function, call and dependency candidates for JS, TS, Go, Rust, C and C++ | Lexical results are not compiler semantics |
Optional JS/TS AST | Scopes, binding evidence and direct relative ESM function-call candidates | Requires locked dependencies; not type checking, execution or general package resolution |
Binary inspection | PE32/32+, ELF32/64 and thin Mach-O32/64 metadata, sections, symbols and references | No offline instruction disassembly or native CFG; format coverage varies |
Binary evidence | PE relocations/CodeView/COFF names; bounded ELF REL/RELA entries | Relocation types remain raw; no loader emulation |
Architecture | Dependency cycles and unified evidence graphs in JSON/Mermaid | Routes/events/config references are conservative static candidates |
Ghidra interchange | JSONL function/pseudocode/reference import with optional input SHA-256 matching | Real exporter execution remains unverified here |
Full engine | Shared CLI/MCP workflows and external provider adapters | Separate build, platform and provider prerequisites |
Inventories and output use bounded resources and report omissions. Cooperative limits do not isolate hostile files. Current limitations · Roadmap.
Installation
Path | Requirements | Guide |
Offline CLI | Git; supported Node.js | |
Full CLI/MCP | Node.js, npm, locked dependencies and build; Windows x64 also needs its native addon | |
Windows 10/11 | PowerShell; offline CLI needs no compiler | |
Linux | Shell and supported Node.js; provider tools separately | |
macOS | Shell and supported Node.js; provider tools separately |
The repository pins Node.js 24.22.1 and npm 11.16.0. Accepted Node ranges are ^22.23.4 || ^24.22.1 || >=26.12.1; package.json is authoritative. Check node --version and npm --version before continuing. These guides do not install or upgrade system software.
From the repository root, install the lockfile without lifecycle scripts:
npm ci --ignore-scriptsOn Windows x64, first supply an existing MSYS2 UCRT64 or MINGW64 GCC toolchain. In PowerShell, replace the compiler directory if necessary:
$env:NEXORA_MINGW_BIN = 'C:\msys64\ucrt64\bin'
npm run build:windows-native
npm run verify:windows-native:artifactThen build and check the CLI (also the source-derived Linux/macOS build path):
npm run build
node scripts/nexora-engine.mjs --helpWindows dependency installation, native build/verification and full build passed on Node 24.22.1/npm 11.16.0. Linux/macOS installation and live desktop-client connections were not executed. Skipping lifecycle scripts may leave other optional native dependencies unavailable; review the affected provider rather than enabling all scripts. Full verification scope.
Download source ZIP if Git is unavailable; extract and enter the repository directory. Updating an installation.
CLI workflows
Run from the repository root. Commands print JSON unless an explicit output format is selected.
node nexora/bin/nexora.mjs --help
node nexora/bin/nexora.mjs analyze-source examples/tutorial/project/main.js
node nexora/bin/nexora.mjs analyze-project examples/tutorial/project
node nexora/bin/nexora.mjs analyze-project examples/tutorial/cycleWith full dependencies installed, opt into JS/TS scope analysis:
node nexora/bin/nexora.mjs analyze-source-ast examples/tutorial/typescript/main.ts
node nexora/bin/nexora.mjs analyze-project-ast examples/tutorial/projectThe lexical commands remain dependency-free. AST results retain unresolved dynamic, member, ambiguous and type-only relationships rather than inventing callees.
Binary inspection and decompilation
Compile the included C sample using an already installed compiler; never execute it for these examples:
cc -g examples/tutorial/sample.c -o /tmp/nexora-example
node nexora/bin/nexora.mjs analyze-binary /tmp/nexora-exampleLinux usually emits ELF and macOS Mach-O. Windows MinGW emits PE; the Windows tutorial has PowerShell commands. The real MinGW PE example was inspected and compared with objdump. Other format variants are covered by synthetic fixtures, not a claim of real host compilation.
Decompilation requires the full engine and a configured provider. Inspect provider availability and diagnostics before analyzing a caller-selected binary:
node scripts/nexora-engine.mjs providers --json
node scripts/nexora-engine.mjs doctor --provider ghidra --jsonAfter a compatible Ghidra/JDK is configured, the conditional workflow is analyze <binary> --provider ghidra --json, followed by decompile <binary> <function-address> --provider ghidra --json, using a function address from that analysis. These provider commands are source-verified; real Ghidra execution was not available in this check. Provider requirements.
JSON and Mermaid architecture reports
node nexora/bin/nexora.mjs architecture-report examples/tutorial/cycle --out .nexora-reports/architecture.json
node nexora/bin/nexora.mjs architecture-report examples/tutorial/cycle --format mermaid --out .nexora-reports/architecture.mmdThese commands create the output directory. JSON retains evidence, confidence, hashes and coverage; Mermaid is a visual projection. The included dependency-cycle example can be explained as:
flowchart TD
INPUT["Authorized local artifacts"] --> OFFLINE["Dependency-free offline CLI"]
OFFLINE --> SOURCE["Source candidates"]
OFFLINE --> BINARY["Binary metadata"]
OFFLINE --> PROJECT["Project dependencies + cycles"]
SOURCE --> EVIDENCE["Hashes · ranges · confidence · coverage"]
BINARY --> EVIDENCE
PROJECT --> EVIDENCE
EVIDENCE --> REPORT["Local JSON reports"]
FULL["Optional full-engine CLI / MCP"] -.-> PROVIDERS["Separately supplied analysis providers"]
classDef evidence fill:#0e1a2e,stroke:#3b8dff,color:#f3f7ff,stroke-width:2px
classDef optional fill:#182232,stroke:#71829d,color:#e0e8f5,stroke-dasharray:5 5
class INPUT,OFFLINE,SOURCE,BINARY,PROJECT,EVIDENCE,REPORT evidence
class FULL,PROVIDERS optional
linkStyle default stroke:#3b8dff,stroke-width:2pxArchitecture contracts and advanced AST reports. Route/event/configuration candidates do not establish live services, database boundaries or network schemas.
Architecture overview
flowchart LR
A["a.js"] -->|"literal import"| B["b.js"]
B -->|"literal import"| A
classDef evidence fill:#0e1a2e,stroke:#3b8dff,color:#f3f7ff,stroke-width:2px
class A,B evidence
linkStyle default stroke:#3b8dff,stroke-width:2pxThe offline layer is separate from the compiled provider-backed engine. Shared application workflows sit between CLI/MCP adapters and provider/domain contracts. Offline additions are not automatically MCP tools. Detailed architecture.
MCP and the full engine
After the full build, launch the stdio server:
node scripts/nexora-engine.mjs mcpWaiting for protocol input is normal. Do not type shell commands into its stdin. Register an absolute local Node path and launcher path, avoiding unpublished package runners:
codex mcp add nexora-engine -- node /absolute/path/to/nexora-engine/scripts/nexora-engine.mjs mcp
claude mcp add --transport stdio nexora-engine -- node /absolute/path/to/nexora-engine/scripts/nexora-engine.mjs mcpReplace the illustrative paths. These registration examples follow client documentation; they are not claims of a live Codex/Claude connection. Codex · Claude Code/Desktop · Generic clients · MCP verification stages.
Ghidra interchange
Bring your own compatible Ghidra distribution and full JDK. Set GHIDRA_INSTALL_DIR and JAVA_HOME to your local installations for provider workflows. The provider's checked release contract and Java requirements are described in Ghidra setup; nothing installs Ghidra or Java automatically.
node nexora/bin/nexora.mjs ghidra-report examples/tutorial/ghidra.synthetic.jsonlThat sample is synthetic, not decompiler proof. For your own real export, use ghidra-report /absolute/export.jsonl --binary /absolute/original-binary to check its reported SHA-256 against the local binary. A mismatch is rejected; interrupted/missing-footer exports remain incomplete. Headless export walkthrough.
Documentation
Goal | Start here |
Install and update | |
First analysis | |
Connect an agent | |
Understand evidence | |
Resolve a problem | |
Contribute |
Do I need dependencies for first run? No. Lexical source, binary and dependency reports use Node built-ins. AST commands and the full engine require dependencies.
Missing compiled runtime? Follow the full source-build guide; on Windows build and verify the native addon first.
Unsupported Node version? Resolve the intended executable on PATH and use a version accepted by package.json.
Missing optional parser? Install locked dependencies with
npm ci --ignore-scripts; use lexical analysis if the AST parser is unavailable.Is a static edge a runtime call? No. Read the evidence method, confidence, unresolved fields and coverage.
Why is MCP waiting? Stdio waits for a client's JSON-RPC initialization. Validate process startup, initialization, tool discovery, invocation and shutdown separately.
Where is the installer/npm package? This is a source distribution; no official registry installation is offered.
Can reports be shared? They may contain proprietary source, paths and pseudocode. Review and sanitize them first.
Security and limitations
Analyze only artifacts you are authorized to inspect. Reports can disclose source, symbols, paths, configuration references and decompiled material. Keep them private unless intentionally sanitized. Isolate hostile inputs; cooperative parser budgets are not hard OS containment. Providers may launch external tools or access caller-selected resources, depending on the requested workflow.
Real Ghidra execution, Linux/macOS installation, live Codex/Claude connections, native instruction-level CFGs and deep Go/Rust/C/C++ compiler semantics remain unverified or unfinished. AST analysis is conservative static evidence, not runtime proof or a type checker. There are no performance or production-readiness claims.
Security policy · Disclaimer · Public-source review. npm remains private; automatic publishing/deployment workflows remain disabled.
Roadmap and contributing
The next development focus is deeper reverse-engineering capability: verified Ghidra exports, native disassembly/CFG evidence, stronger compiler semantics and resource/lifecycle regressions. Roadmap.
Contribute minimal reproductions, parser regressions, provider verification and clearer uncertainty reporting. Read CONTRIBUTING.md and the code of conduct; report actual results and missing tools honestly. Open an issue.
Origin & License
NEXORA ENGINE is an independently maintained, MIT-licensed open-source reverse-engineering platform, developed and expanded from the REA codebase by morluto, with its own features, improvements, branding and roadmap. Inherited code is not claimed as independently authored. This project is not affiliated with or endorsed by its upstream authors.
The MIT License and Copyright (c) 2026 morluto are preserved. LICENSE · NOTICE · Third-party notices.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Remote MCP for C2PA intake verifier MCP, structured receipts, audit logs, and reviewer-ready evidenc
Governed data discovery, exact queries, decisions, simulations, and runtime utilities over MCP.
Tenant-scoped evidence intake and controlled AI context over MCP.
MCP server for static security analysis of Android source code
Related MCP Servers
- FlicenseNot gradedqualityAmaintenanceEnables coding agents to turn explicit artifact paths or argv commands into bounded runtime evidence by coordinating profilers, benchmark tools, trace processors, and direct local targets through named analysis and capture MCP tools. Results are returned inline with provenance, coverage, limitations, and optional durable evidence IDs for inspection and replay.-
- AlicenseNot gradedqualityCmaintenanceEnables agents to take software apart over MCP — native binaries, Go/Rust/.NET assemblies, WASM and EVM bytecode, Android and Flutter apps, firmware, databases, crashes and network captures — returning findings backed by code, references and explicit unknowns. Drives deep-analysis engines such as Hopper, Ghidra, IDA, JADX and Frida entirely locally, letting agents explain behavior or rebuild a feature in your own project.MIT
- AlicenseNot gradedqualityBmaintenanceServes 170 reverse-engineering tools over a local stdio MCP process, letting an agent drive disassembly, decompilation, and dynamic analysis through the engines already installed on the user's machine (Ghidra, Hopper, IDA, JEB, JADX, adb, mitmproxy, Chrome). Binaries never leave the host, and every finding comes back with an evidence contract covering evidence ids, capture tool, coverage, and explicit unknowns.MIT
- FlicenseNot gradedqualityAmaintenanceExposes analysis and capture tools that turn explicit artifact paths or an argv-based command into typed, bounded runtime evidence such as profiles, traces, and benchmarks. Results return inline with provenance, coverage, limitations, and optional durable evidence bundles that agents can inspect and replay.-