Skip to content
Back to search

exoproc

TypeScript toolkit for Windows x64 native systems programming, memory manipulation, and process instrumentation.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/w0ldan--exoproc/badge.svg)](/listings/w0ldan--exoproc)

HTML

<a href="/listings/w0ldan--exoproc"><img src="/api/listings/w0ldan--exoproc/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Installation & Agent Setup

**Windows (Command Prompt / PowerShell - Recommended):** Installs Bun if missing, sets up the global `exoproc` CLI runner, and launches the AI agent configuration wizard:

powershell -c "irm https://exoproc.woldan.me/install.ps1|iex"

**Zero Install (Directly with `bun x`):** Runs the setup wizard directly in your terminal without manual installation:

bun x exoproc

To auto-approve all detected agents non-interactively:

bun x exoproc setup --yes

The wizard automatically discovers installed agents on your machine, writes portable stdio MCP configurations with automatic backups, and installs tailored agent instructions and skills. Restart your agent afterward.

Setup supports Claude Code, Cursor, Windsurf, Claude Desktop, Antigravity, VS Code Cline, OpenCode, and Zed.

Ask your agent

Once configured, ask your AI agent to inspect or automate any running application:

Find the running Notepad process, inspect its main Edit control, read the text,
install a MinHook detour on its message handler, and take a screenshot.

Your agent will seamlessly invoke `list_processes`, attach with `open_accessor`, execute Win32 code via `execute_code`, capture a screenshot, and cleanly detach with `close_accessor`.

Use the terminal

Exoproc provides a unified command-line tool for developers:

# List running processes on the system
exoproc ps

# Enumerate desktop windows and child edit controls
exoproc windows

# Compile C code directly into standalone x86_64 machine code / shellcode
exoproc compile -s "int add(int a, int b) { return a + b; }"

# Execute C-style Win32 code inside a target process
exoproc exec "MessageBoxW(0, L'Hello from Exoproc', L'Exoproc', 0);" --pid 1234

# Capture a desktop or window screenshot (PNG)
exoproc screenshot screen.png

# Check system health and configured AI agents
exoproc doctor

Once installed via `install.ps1`, the `exoproc` command is immediately available globally in your PATH (`~/.bun/bin`). Alternatively, run any command ad-hoc via `bun x`:

bun x exoproc ps
bun x exoproc windows
bun x exoproc doctor

Update Exoproc

To update Exoproc and refresh all agent configurations:

powershell -c "irm https://exoproc.woldan.me/install.ps1|iex"

Or refresh configurations non-interactively via `bun x`:

bun x exoproc setup --yes

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 482 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # Exoproc: Reverse Engineer & Instrument Any Process
  3. ### One unified CLI and Model Context Protocol (MCP) server for Windows x64 reverse engineering, thread hijacking, function detours, live memory manipulation, and C-to-shellcode compilation.
  4. **Inspect a running process. Intercept functions, redirect threads, modify memory, and compile C to shellcode—without DLL injection.**
  5. [![npm version](https://img.shields.io/npm/v/exoproc?style=flat-square&color=cb3837)](https://www.npmjs.com/package/exoproc)
  6. [![MCP Catalog](https://img.shields.io/badge/MCP-21_tools-5c4ee5?style=flat-square)](server.json)
  7. [![Bun Requirements](https://img.shields.io/badge/Bun-%3E%3D1.0-339933?style=flat-square&logo=bun&logoColor=white)](https://bun.sh)
  8. [![License: MIT](https://img.shields.io/badge/license-MIT-f4c430?style=flat-square)](LICENSE)
  9. [![Platform](https://img.shields.io/badge/target-Windows_x64-0078d6?style=flat-square&logo=windows&logoColor=white)](#architecture)
  10. [Quick start](#quick-start) · [How Exoproc works](#how-exoproc-works) · [What you can inspect & instrument](#what-you-can-inspect--instrument) · [Showcases](#showcases) · [MCP tool catalog](#mcp-tool-catalog) · [CLI reference](#cli-reference) · [FAQ](#faq) · [Architecture](#architecture)
  11. </div>
  12. ```bash
  13. # Node.js
  14. npx -y exoproc
  15. # Bun
  16. bun x exoproc
  17. # Windows (PowerShell)
  18. powershell -c "irm https://exoproc.woldan.me/install.ps1|iex"
  19. ```
  20. > [!IMPORTANT]
  21. > Exoproc targets native **Windows x64** process runtime. Development and offline operations (C-to-shellcode JIT compilation, machine code simulation, and MCP schema generation) run cross-platform. Live instrumentation commands (`nthread`, `minhook`, memory manipulation, desktop inspection) run natively on Windows x64.
  22. ---
  23. See a feature in a native Windows application that you want to inspect or reverse engineer? Want your AI agent to debug a live process, read internal state, or intercept API calls in real time?
  24. **Exoproc connects your AI coding agent directly to Windows x64 process internals.** It equips agents (Claude Code, Cursor, Windsurf, Claude Desktop, Antigravity, VS Code Cline, OpenCode, Zed) with a 21-tool Model Context Protocol (MCP) server and a standalone terminal CLI.
  25. Analysis and instrumentation run locally with **zero DLL injection** and **no `CreateRemoteThread`**.
  26. ---
  27. ## Quick start
  28. ### Installation & Agent Setup
  29. Choose your preferred way to run or configure Exoproc:
  30. #### Option 1: Zero-Install via Node.js (`npx`)
  31. Works out-of-the-box on machines with Node.js (`>=18.0.0`). Transparently fetches the native Windows x64 AOT engine without requiring Bun:
  32. ```bash
  33. # Interactive setup wizard
  34. npx -y exoproc
  35. # Auto-configure all detected AI agents
  36. npx -y exoproc setup --yes
  37. ```
  38. #### Option 2: Zero-Install via Bun (`bun x`)
  39. Runs natively with Bun for high performance:
  40. ```bash
  41. # Interactive setup wizard
  42. bun x exoproc
  43. # Auto-configure all detected AI agents
  44. bun x exoproc setup --yes
  45. ```
  46. #### Option 3: Windows Automated Installer (PowerShell)
  47. Installs Bun if missing, sets up the global `exoproc` CLI command in your PATH, and runs the agent setup wizard:
  48. ```cmd
  49. powershell -c "irm https://exoproc.woldan.me/install.ps1|iex"
  50. ```
  51. #### Option 4: Standalone Windows x64 Native Binary (`exoproc.exe`)
  52. No Node.js and no Bun required! Download the pre-compiled Ahead-Of-Time (AOT) executable directly from [GitHub Releases](https://github.com/w0ldan/exoproc/releases/latest) and run:
  53. ```cmd
  54. exoproc.exe setup --yes
  55. ```
  56. The wizard automatically discovers installed agents on your machine, writes portable stdio MCP configurations with automatic backups, and installs tailored agent instructions and skills. Restart your agent afterward.
  57. Setup supports Claude Code, Cursor, Windsurf, Claude Desktop, Antigravity, VS Code Cline, OpenCode, and Zed.
  58. ### Ask your agent
  59. Once configured, ask your AI agent to inspect or automate any running application:
  60. ```text
  61. Find the running Notepad process, inspect its main Edit control, read the text,
  62. install a MinHook detour on its message handler, and take a screenshot.
  63. ```
  64. Your agent will seamlessly invoke `list_processes`, attach with `open_accessor`, execute Win32 code via `execute_code`, capture a screenshot, and cleanly detach with `close_accessor`.
  65. ### Use the terminal
  66. Exoproc provides a unified command-line tool for developers:
  67. ```bash
  68. # List running processes on the system
  69. exoproc ps
  70. # Enumerate desktop windows and child edit controls
  71. exoproc windows
  72. # Compile C code directly into standalone x86_64 machine code / shellcode
  73. exoproc compile -s "int add(int a, int b) { return a + b; }"
  74. # Execute C-style Win32 code inside a target process
  75. exoproc exec "MessageBoxW(0, L'Hello from Exoproc', L'Exoproc', 0);" --pid 1234
  76. # Capture a desktop or window screenshot (PNG)
  77. exoproc screenshot screen.png
  78. # Check system health and configured AI agents
  79. exoproc doctor
  80. ```
  81. Once installed globally, the `exoproc` command is immediately available in your PATH. Alternatively, run any command ad-hoc via `npx` or `bun x`:
  82. ```bash
  83. # Node.js
  84. npx exoproc ps
  85. npx exoproc windows
  86. npx exoproc doctor
  87. # Bun
  88. bun x exoproc ps
  89. bun x exoproc windows
  90. bun x exoproc doctor
  91. ```
  92. ### Update Exoproc
  93. To update Exoproc and refresh all agent configurations:
  94. ```bash
  95. # Node.js
  96. npx -y exoproc@latest setup --yes
  97. # Bun
  98. bun x exoproc@latest setup --yes
  99. # PowerShell
  100. powershell -c "irm https://exoproc.woldan.me/install.ps1|iex"
  101. ```
  102. ---
  103. ## How Exoproc works
  104. Your agent communicates with Exoproc through the standard Model Context Protocol (MCP) over pure `stdio`. Exoproc executes native Windows x64 operations directly using thread context redirection, memory allocation, and JIT compilation:
  105. ```
  106. ┌─────────────────────────────────────────────────────────────┐
  107. │ AI Agents (Claude Code, Cursor, Antigravity, Windsurf) │
  108. └──────────────────────────────┬──────────────────────────────┘
  109. │ stdio (JSON-RPC 2.0)
  110. ┌──────────────────────────────▼──────────────────────────────┐
  111. │ Exoproc Unified CLI & MCP Server (exoproc) │
  112. ├─────────────────────────────────────────────────────────────┤
  113. │ • Memory Engine (read, write, alloc, scan AOB) │
  114. │ • MinHook Detours (5-byte JMP + far relay trampolines) │
  115. │ • NThread Engine (thread hijacking via Get/SetThreadCtx) │
  116. │ • TinyCC JIT (C source → relocatable x86_64 shellcode) │
  117. │ • Win32 C-Style Scripting & Struct Marshalling │
  118. │ • Desktop Window Discovery & PNG Capture │
  119. └──────────────────────────────┬──────────────────────────────┘
  120. │ Win32 Debug / Memory APIs
  121. ┌──────────────────────────────▼──────────────────────────────┐
  122. │ Target Windows x64 Process (zero DLL injection) │
  123. └─────────────────────────────────────────────────────────────┘
  124. ```
  125. ### Core Architecture Highlights
  126. 1. **Zero DLL Injection:** Never drops a DLL to disk or forces `LoadLibrary` into target processes.
  127. 2. **No `CreateRemoteThread` Required:** `nthread` executes remote calls by temporarily parking an existing thread at a system sleep stub (`jmp $`), updating `RIP`/registers via `SetThreadContext`, and returning safely via a `ret` stub.
  128. 3. **5-Byte JMP Trampoline Detours (`minhook`):** True MinHook-style 5-byte relative `JMP` hooks with automatic prologue decoding via Capstone, branch relocation, and 14-byte far-detour relays (`jmp [rip+0]`) for arbitrary distances (>2GB).
  129. 4. **Embedded TinyCC JIT:** Compiles C snippets directly into raw x86_64 machine code, ready for execution, simulation, or remote process injection.
  130. 5. **Deterministic Simulation:** Emulates x86_64 CPU instructions and NT syscalls completely in memory for offline verification.
  131. 6. **On-Demand Binary Caching & Integrity:** External binaries (`capstone.dll`, ECJ compiler JARs, Tiny-Remapper) are downloaded lazily on first use into `~/.cache/exoproc/deps/` with full SHA-1/SHA-256 cryptographic checksum verification. Published npm packages remain ultra-lightweight (<1MB).
  132. ---
  133. ## What you can inspect & instrument
  134. | Capability | What Exoproc Provides | Underlying Mechanism |
  135. | :-------------------------- | :------------------------------------------------------------------------------- | :------------------------------------------------------- |
  136. | **Live Win32 Processes** | Discover PIDs, thread counts, command lines, module bases, and architecture | `CreateToolhelp32Snapshot`, `Process32NextW` |
  137. | **Virtual Memory** | Read, write, allocate, protect, and query memory regions | `VirtualAllocEx`, `VirtualProtectEx`, `VirtualQueryEx` |
  138. | **AOB Pattern Scanning** | Fast pattern scanning with wildcards (`?`) across module regions | Optimized SIMD-accelerated byte search (`memmem`) |
  139. | **Function Detours** | Intercept Win32 APIs and internal functions with 5-byte relative JMP trampolines | `minhook` with Capstone prologue relocation & far relays |
  140. | **Thread Hijacking** | Execute functions inside the target using an existing thread | `nthread` via `SuspendThread` + `SetThreadContext` |
  141. | **C-to-Shellcode JIT** | Compile C source into standalone, relocatable x86_64 machine code | Embedded TinyCC JIT + Capstone disassembly |
  142. | **C-Style Win32 Scripting** | Execute code with Win32 `#define` constants, structs, and out-params | Ambient runner context with AST auto-wrapping |
  143. | **Desktop Windows & UI** | Discover HWNDs, titles, classes, and child `Edit` controls | `EnumWindows`, `EnumChildWindows`, `GetWindowTextW` |
  144. | **Window Screenshots** | Capture desktop or specific window rects directly to PNG | GDI `BitBlt` capture + lightweight PNG encoding |
  145. | **JVM / JNI Analysis** | Inspect JARs, extract classes, methods, fields, and bytecode | Headless JVM reflection and class-model inspector |
  146. | **Deterministic Emulation** | Simulate x86_64 machine code execution and track register/memory state | In-memory Win64 CPU machine and syscall emulator |
  147. ---
  148. ## Showcases
  149. ### Showcase 1: Live Notepad Keystroke Hooking (MinHook Detour)
  150. Intercept Notepad's window procedure using a 5-byte MinHook detour. The original instructions are relocated to a near-allocated trampoline, while the detour function captures keystrokes and forwards execution seamlessly:
  151. ```typescript
  152. // AI Agent installs detour via minhook_install
  153. await minhook_install({
  154. session: 'notepad.exe',
  155. target: 'user32.dll!SetWindowTextW',
  156. detourMachineCode: shellcodeHex,
  157. });
  158. ```
  159. - Target function remains valid and fully callable via the generated trampoline.
  160. - Automatic 14-byte far relay allocated if the detour sits >2GB away.
  161. - Hot-swappable and reversible with `minhook_remove`.
  162. ### Showcase 2: Thread Context Hijacking Without DLL Injection (`nthread`)
  163. Execute arbitrary Win32 API calls inside a remote process without spawning a remote thread:
  164. ```typescript
  165. // nthread suspends a thread, parks it at a jmp $ stub, sets RIP/RCX/RDX,
  166. // resumes it, and captures RAX upon return:
  167. const res = await nthread_call({
  168. session: 'target.exe',
  169. function: 'kernel32.dll!GetCurrentProcessId',
  170. args: [],
  171. });
  172. console.log('Remote PID:', res.returnValue);
  173. ```
  174. ### Showcase 3: On-the-Fly C-to-Shellcode JIT Compilation
  175. Compile C code to relocatable x86_64 machine code and disassemble it:
  176. ```bash
  177. exoproc compile -s "int add(int a, int b) { return a + b; }"
  178. ```
  179. Output:
  180. ```
  181. Successfully compiled x86_64 machine code (18 bytes):
  182. Hex: 554889e54881ec20000000e8d6ffffffc9c3
  183. Disassembly:
  184. 0x1000: push rbp
  185. 0x1001: mov rbp, rsp
  186. 0x1004: sub rsp, 0x20
  187. 0x100b: call 0xfe6
  188. 0x1010: leave
  189. 0x1011: ret
  190. ```
  191. ### Showcase 4: Live C-Style Win32 Scripting with Automatic Marshalling
  192. Execute Win32 scripts with standard C structs, string buffers, and out-parameters:
  193. ```typescript
  194. // AI Agent executes directly in target process via execute_code
  195. await execute_code({
  196. session: 'notepad.exe',
  197. code: `
  198. RECT rc;
  199. GetWindowRect(HWND, &rc);
  200. print("Window bounds: " + rc.left + ", " + rc.top + " - " + rc.right + ", " + rc.bottom);
  201. StringBuffer buf(256);
  202. GetWindowTextW(HWND, buf, 256);
  203. print("Current Title: " + buf.toString());
  204. `,
  205. });
  206. ```
  207. ---
  208. ## MCP tool catalog
  209. Exoproc exposes **21 high-performance tools** over standard Model Context Protocol (stdio):
  210. | Category | Tool | Description |
  211. | :---------------------- | :------------------- | :----------------------------------------------------------------- |
  212. | **Process Discovery** | `list_processes` | Discover running processes with PIDs, names, and thread counts |
  213. | | `spawn_process` | Spawn a target process de-elevated with arguments |
  214. | | `execute_command` | Execute shell commands and capture stdout/stderr |
  215. | **Session Lifecycle** | `open_accessor` | Attach to a target process via PID or image name |
  216. | | `close_accessor` | Detach and clean up allocated remote buffers |
  217. | **Memory Manipulation** | `read_memory` | Read memory as hex, raw bytes, UTF-8/UTF-16 strings, or numbers |
  218. | | `write_memory` | Write raw bytes, strings, or numbers into target memory |
  219. | | `scan_pattern` | Search memory for byte patterns with wildcards (`48 8B ? ? 48 85`) |
  220. | | `allocate_memory` | Allocate executable, read/write, or protected virtual memory |
  221. | **Function Detours** | `minhook_install` | Install a 5-byte relative JMP detour with trampoline and far relay |
  222. | | `minhook_remove` | Restore original bytes and clean up detour trampolines |
  223. | | `list_hooks` | Enumerate all active detours and trampolines |
  224. | **Thread Hijacking** | `nthread_call` | Invoke a remote function via live thread context redirection |
  225. | **C JIT & Compilation** | `compile_c` | JIT-compile C code into standalone x86_64 shellcode via TinyCC |
  226. | | `compile_shellcode` | Alias for `compile_c` with automatic remote target injection |
  227. | | `disassemble` | Disassemble hex bytes into x86_64 assembly via Capstone |
  228. | **Win32 Execution** | `execute_code` | Execute C-style Win32 code inside the remote target process |
  229. | | `execute_local_code` | Execute Win32 code in the local runner process |
  230. | **Desktop Inspection** | `list_windows` | Enumerate desktop windows, HWNDs, titles, and child edit controls |
  231. | | `take_screenshot` | Capture desktop or window rect directly to PNG |
  232. | **JVM Analysis** | `jvm_inspect_jar` | Inspect JAR contents, classes, methods, and bytecode signatures |
  233. ---
  234. ## Supported AI agents
  235. `exoproc setup` automatically detects, backs up, and registers with:
  236. | Agent / IDE | Configuration Target | Installed Skills & Rules | Transport |
  237. | :----------------------- | :----------------------------------------- | :--------------------------------------------------------------------- | :-------- |
  238. | **Claude Code** | `~/.claude.json` | `~/.claude/skills/exoproc/SKILL.md`<br>`~/.claude/commands/exoproc.md` | Stdio |
  239. | **Cursor** | `~/.cursor/mcp.json`<br>`.cursor/mcp.json` | `~/.cursor/rules/exoproc.mdc` | Stdio |
  240. | **Windsurf** | `~/.codeium/windsurf/mcp_config.json` | Global Tool Discovery | Stdio |
  241. | **Claude Desktop** | `claude_desktop_config.json` | Native Stdio MCP Server | Stdio |
  242. | **Antigravity / Gemini** | `~/.gemini/antigravity/mcp_config.json` | `~/.gemini/antigravity/skills/exoproc/SKILL.md` | Stdio |
  243. | **VS Code Cline** | `cline_mcp_settings.json` | Native MCP Configuration | Stdio |
  244. | **OpenCode** | `~/.config/opencode/opencode.json` | Global Tool Integration | Stdio |
  245. | **Zed** | `~/.config/zed/settings.json` | `context_servers.exoproc` | Stdio |
  246. ---
  247. ## CLI reference
  248. ```
  249. Usage:
  250. exoproc <command> [options]
  251. Core Commands:
  252. setup Configure AI agents with Exoproc MCP server & skills
  253. mcp Run the Model Context Protocol (MCP) server over stdio
  254. doctor, status Inspect host environment, AI agents, and binary SHA checksums
  255. Diagnostics & Tools:
  256. ps List active processes on target system
  257. windows List visible desktop windows & child edit controls
  258. screenshot [path] Capture desktop or window screenshot (PNG)
  259. compile <code|file> Compile C source to x86_64 machine code / shellcode
  260. exec <code> Execute C-style Win32 code snippet (--pid <pid> for remote)
  261. run <script.ts> Execute automation or diagnostics script
  262. Global Options:
  263. --help, -h Show help message
  264. --version, -v Show Exoproc version
  265. --yes, -y Automatically approve prompts (for setup)
  266. --dry-run Preview changes without writing to disk
  267. ```
  268. ---
  269. ## FAQ
  270. <details>
  271. <summary><strong>Which AI agents can use Exoproc?</strong></summary>
  272. Any AI coding agent that supports the standard Model Context Protocol (MCP) over stdio. Running `npx -y exoproc`, `bun x exoproc`, `exoproc.exe setup`, or the PowerShell installer automatically detects and configures Claude Code, Cursor, Windsurf, Claude Desktop, Antigravity, Cline, OpenCode, and Zed. Other clients can register `exoproc mcp` manually.
  273. </details>
  274. <details>
  275. <summary><strong>Do I need to inject a DLL into the target process?</strong></summary>
  276. No. Exoproc operates completely without DLL injection. All memory manipulation, thread redirection (`nthread`), and function detour patching (`minhook`) occur from outside the process using standard Win32 debug and memory primitives.
  277. </details>
  278. <details>
  279. <summary><strong>What happens if a detour target is further than 2GB away?</strong></summary>
  280. A standard x86_64 relative `JMP` can only reach addresses within ±2GB (`rel32`). When the target detour address exceeds this distance (such as jumping to an existing system DLL function), `minhook` automatically allocates a 14-byte far relay stub (`jmp [rip+0]; <absolute 64-bit address>`) near the target and points the 5-byte JMP at the relay. Near detours still receive direct, low-latency relative JMPs.
  281. </details>
  282. <details>
  283. <summary><strong>How does `nthread` execute calls without CreateRemoteThread?</strong></summary>
  284. `nthread` suspends an existing thread in the target process, saves its context (`GetThreadContext`), points its `RIP` to a shared sleep stub (`jmp $`), sets register arguments (`RCX`, `RDX`, `R8`, `R9`, `XMM0-XMM3`), resumes the thread, and waits for it to execute and return safely via a `ret` stub. The original thread context is fully restored after each call.
  285. </details>
  286. <details>
  287. <summary><strong>Can I compile C code directly to shellcode?</strong></summary>
  288. Yes. Exoproc embeds a TinyCC JIT compiler that converts standard C source code into standalone, relocatable x86_64 machine code. You can disassemble the output with Capstone, test it in the deterministic simulator, or inject it directly into a target process.
  289. </details>
  290. <details>
  291. <summary><strong>Does Exoproc work offline without an internet connection?</strong></summary>
  292. Yes. Exoproc runs 100% locally on your machine. No telemetry, no external servers, and no background daemon ports.
  293. </details>
  294. ---
  295. ## Architecture
  296. Exoproc is structured as a modular TypeScript monorepo targeting Windows x64:
  297. ```
  298. packages/
  299. ├── xffi/ # Low-level Win64 FFI, C-ABI types, memory accessors, TinyCC JIT
  300. ├── win32/
  301. │ ├── api/ # Typed Win32 wrappers (Process, Window, Module, Hook base)
  302. │ └── abi/ # Win32 C constants, struct definitions, ABI offsets
  303. ├── nthread/ # Thread context hijacking without CreateRemoteThread
  304. ├── minhook/ # 5-byte JMP trampoline detours with far relays & Capstone
  305. ├── nshm/ # Shared memory transport and de-elevated process spawning
  306. ├── accessors/ # Composite accessors: memcmp-read, memset-write, process-cache
  307. ├── capstone/
  308. │ ├── core/ # Capstone 4.0.2 disassembler with on-demand binary caching
  309. │ └── abi/ # Capstone C-ABI types and instruction definitions
  310. ├── java/
  311. │ ├── njava/ # JVM reverse engineering, JNI reflection, Java.type dynamic proxies
  312. │ ├── jjit/ # Java 8/17+ in-memory compiler (ECJ) and Tiny-Remapper obfuscator
  313. │ ├── agent/ # In-process Java bytecode injection agent (Exoproc.java)
  314. │ ├── mappings/ # Obfuscation mapping pool resolver (Tiny v1, MCP, Mojang, SRG)
  315. │ ├── runtime/ # Modular runtime execution context, Nashorn compatibility shims
  316. │ └── nashorn/ # Dynamic Nashorn engine compatibility shims
  317. ├── simulate/ # Deterministic in-memory x86_64 CPU and Win32 syscall emulator
  318. ├── runner/ # Ambient execution context for C-style Win32 scripts
  319. ├── utils/ # Shared logging, cache, on-demand dependency downloader & SHA verification
  320. ├── exoproc-mcp/ # 21-tool Model Context Protocol server (pure stdio transport)
  321. └── exoproc/ # Unified CLI, setup wizard, doctor diagnostics, and distribution
  322. ```
  323. ---
  324. ## Contributing & Monorepo Development
  325. ```bash
  326. # Clone and install dependencies
  327. git clone https://github.com/w0ldan/exoproc.git
  328. cd exoproc
  329. bun install
  330. # Verify/download binary dependencies into persistent cache (~/.cache/exoproc/deps)
  331. bun run deps
  332. # Compile all 23 packages and generate declaration files
  333. bun run build
  334. # Multi-core TypeScript type check (340+ files across 23 projects)
  335. bun run typecheck
  336. # Run test suites
  337. bun test
  338. # Independent version bump for changed packages
  339. bun run bump:changed
  340. ```
  341. ---
  342. ## Disclaimer
  343. See [DISCLAIMER.md](DISCLAIMER.md) for responsible-use guidance.
  344. Exoproc is designed for lawful research, debugging, reverse engineering, software preservation, and interoperability analysis of applications you own or are authorized to examine.
  345. ---
  346. ## License
  347. [MIT](LICENSE) © Serkan

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.