[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-105376":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":16,"stars7d":16,"stars30d":16,"stars90d":15,"forks30d":15,"starsTrendScore":17,"compositeScore":18,"rankGlobal":10,"rankLanguage":10,"license":19,"archived":20,"fork":20,"defaultBranch":21,"hasWiki":22,"hasPages":20,"topics":23,"createdAt":10,"pushedAt":10,"updatedAt":38,"readmeContent":39,"aiSummary":10,"trendingCount":15,"starSnapshotCount":15,"syncStatus":40,"lastSyncTime":41,"discoverSource":42},105376,"exoproc","w0ldan\u002Fexoproc","w0ldan","TypeScript toolkit for Windows x64 native systems programming, memory manipulation, and process instrumentation.","exoproc.woldan.me",null,"TypeScript",89,12,1,0,19,57,70.74,"MIT License",false,"main",true,[24,25,26,27,28,29,30,31,32,33,34,35,36,37],"agent-skills","ai-agents","binary-analysis","claude-code","cli","codex","decompiler","developer-tools","dynamic-analysis","llm","mcp","model-context-protocol","reverse-enginnering","static-analysis","2026-11-01 00:15:23","\u003Cdiv align=\"center\">\n\n# Exoproc: Reverse Engineer & Instrument Any Process\n\n### 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.\n\n**Inspect a running process. Intercept functions, redirect threads, modify memory, and compile C to shellcode—without DLL injection.**\n\n[![npm version](https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fv\u002Fexoproc?style=flat-square&color=cb3837)](https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fexoproc)\n[![MCP Catalog](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FMCP-21_tools-5c4ee5?style=flat-square)](server.json)\n[![Bun Requirements](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FBun-%3E%3D1.0-339933?style=flat-square&logo=bun&logoColor=white)](https:\u002F\u002Fbun.sh)\n[![License: MIT](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Flicense-MIT-f4c430?style=flat-square)](LICENSE)\n[![Platform](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Ftarget-Windows_x64-0078d6?style=flat-square&logo=windows&logoColor=white)](#architecture)\n\n[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)\n\n\u003C\u002Fdiv>\n\n```bash\n# Node.js\nnpx -y exoproc\n\n# Bun\nbun x exoproc\n\n# Windows (PowerShell)\npowershell -c \"irm https:\u002F\u002Fexoproc.woldan.me\u002Finstall.ps1|iex\"\n```\n\n> [!IMPORTANT]\n> 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.\n\n---\n\nSee 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?\n\n**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.\n\nAnalysis and instrumentation run locally with **zero DLL injection** and **no `CreateRemoteThread`**.\n\n---\n\n## Quick start\n\n### Installation & Agent Setup\n\nChoose your preferred way to run or configure Exoproc:\n\n#### Option 1: Zero-Install via Node.js (`npx`)\n\nWorks out-of-the-box on machines with Node.js (`>=18.0.0`). Transparently fetches the native Windows x64 AOT engine without requiring Bun:\n\n```bash\n# Interactive setup wizard\nnpx -y exoproc\n\n# Auto-configure all detected AI agents\nnpx -y exoproc setup --yes\n```\n\n#### Option 2: Zero-Install via Bun (`bun x`)\n\nRuns natively with Bun for high performance:\n\n```bash\n# Interactive setup wizard\nbun x exoproc\n\n# Auto-configure all detected AI agents\nbun x exoproc setup --yes\n```\n\n#### Option 3: Windows Automated Installer (PowerShell)\n\nInstalls Bun if missing, sets up the global `exoproc` CLI command in your PATH, and runs the agent setup wizard:\n\n```cmd\npowershell -c \"irm https:\u002F\u002Fexoproc.woldan.me\u002Finstall.ps1|iex\"\n```\n\n#### Option 4: Standalone Windows x64 Native Binary (`exoproc.exe`)\n\nNo Node.js and no Bun required! Download the pre-compiled Ahead-Of-Time (AOT) executable directly from [GitHub Releases](https:\u002F\u002Fgithub.com\u002Fw0ldan\u002Fexoproc\u002Freleases\u002Flatest) and run:\n\n```cmd\nexoproc.exe setup --yes\n```\n\nThe 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.\n\nSetup supports Claude Code, Cursor, Windsurf, Claude Desktop, Antigravity, VS Code Cline, OpenCode, and Zed.\n\n### Ask your agent\n\nOnce configured, ask your AI agent to inspect or automate any running application:\n\n```text\nFind the running Notepad process, inspect its main Edit control, read the text,\ninstall a MinHook detour on its message handler, and take a screenshot.\n```\n\nYour 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`.\n\n### Use the terminal\n\nExoproc provides a unified command-line tool for developers:\n\n```bash\n# List running processes on the system\nexoproc ps\n\n# Enumerate desktop windows and child edit controls\nexoproc windows\n\n# Compile C code directly into standalone x86_64 machine code \u002F shellcode\nexoproc compile -s \"int add(int a, int b) { return a + b; }\"\n\n# Execute C-style Win32 code inside a target process\nexoproc exec \"MessageBoxW(0, L'Hello from Exoproc', L'Exoproc', 0);\" --pid 1234\n\n# Capture a desktop or window screenshot (PNG)\nexoproc screenshot screen.png\n\n# Check system health and configured AI agents\nexoproc doctor\n```\n\nOnce installed globally, the `exoproc` command is immediately available in your PATH. Alternatively, run any command ad-hoc via `npx` or `bun x`:\n\n```bash\n# Node.js\nnpx exoproc ps\nnpx exoproc windows\nnpx exoproc doctor\n\n# Bun\nbun x exoproc ps\nbun x exoproc windows\nbun x exoproc doctor\n```\n\n### Update Exoproc\n\nTo update Exoproc and refresh all agent configurations:\n\n```bash\n# Node.js\nnpx -y exoproc@latest setup --yes\n\n# Bun\nbun x exoproc@latest setup --yes\n\n# PowerShell\npowershell -c \"irm https:\u002F\u002Fexoproc.woldan.me\u002Finstall.ps1|iex\"\n```\n\n---\n\n## How Exoproc works\n\nYour 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:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  AI Agents (Claude Code, Cursor, Antigravity, Windsurf)     │\n└──────────────────────────────┬──────────────────────────────┘\n                               │  stdio (JSON-RPC 2.0)\n┌──────────────────────────────▼──────────────────────────────┐\n│  Exoproc Unified CLI & MCP Server (exoproc)                 │\n├─────────────────────────────────────────────────────────────┤\n│  • Memory Engine (read, write, alloc, scan AOB)             │\n│  • MinHook Detours (5-byte JMP + far relay trampolines)     │\n│  • NThread Engine (thread hijacking via Get\u002FSetThreadCtx)   │\n│  • TinyCC JIT (C source → relocatable x86_64 shellcode)     │\n│  • Win32 C-Style Scripting & Struct Marshalling             │\n│  • Desktop Window Discovery & PNG Capture                   │\n└──────────────────────────────┬──────────────────────────────┘\n                               │  Win32 Debug \u002F Memory APIs\n┌──────────────────────────────▼──────────────────────────────┐\n│  Target Windows x64 Process (zero DLL injection)            │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Core Architecture Highlights\n\n1. **Zero DLL Injection:** Never drops a DLL to disk or forces `LoadLibrary` into target processes.\n2. **No `CreateRemoteThread` Required:** `nthread` executes remote calls by temporarily parking an existing thread at a system sleep stub (`jmp $`), updating `RIP`\u002Fregisters via `SetThreadContext`, and returning safely via a `ret` stub.\n3. **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).\n4. **Embedded TinyCC JIT:** Compiles C snippets directly into raw x86_64 machine code, ready for execution, simulation, or remote process injection.\n5. **Deterministic Simulation:** Emulates x86_64 CPU instructions and NT syscalls completely in memory for offline verification.\n6. **On-Demand Binary Caching & Integrity:** External binaries (`capstone.dll`, ECJ compiler JARs, Tiny-Remapper) are downloaded lazily on first use into `~\u002F.cache\u002Fexoproc\u002Fdeps\u002F` with full SHA-1\u002FSHA-256 cryptographic checksum verification. Published npm packages remain ultra-lightweight (\u003C1MB).\n\n---\n\n## What you can inspect & instrument\n\n| Capability                  | What Exoproc Provides                                                            | Underlying Mechanism                                     |\n| :-------------------------- | :------------------------------------------------------------------------------- | :------------------------------------------------------- |\n| **Live Win32 Processes**    | Discover PIDs, thread counts, command lines, module bases, and architecture      | `CreateToolhelp32Snapshot`, `Process32NextW`             |\n| **Virtual Memory**          | Read, write, allocate, protect, and query memory regions                         | `VirtualAllocEx`, `VirtualProtectEx`, `VirtualQueryEx`   |\n| **AOB Pattern Scanning**    | Fast pattern scanning with wildcards (`?`) across module regions                 | Optimized SIMD-accelerated byte search (`memmem`)        |\n| **Function Detours**        | Intercept Win32 APIs and internal functions with 5-byte relative JMP trampolines | `minhook` with Capstone prologue relocation & far relays |\n| **Thread Hijacking**        | Execute functions inside the target using an existing thread                     | `nthread` via `SuspendThread` + `SetThreadContext`       |\n| **C-to-Shellcode JIT**      | Compile C source into standalone, relocatable x86_64 machine code                | Embedded TinyCC JIT + Capstone disassembly               |\n| **C-Style Win32 Scripting** | Execute code with Win32 `#define` constants, structs, and out-params             | Ambient runner context with AST auto-wrapping            |\n| **Desktop Windows & UI**    | Discover HWNDs, titles, classes, and child `Edit` controls                       | `EnumWindows`, `EnumChildWindows`, `GetWindowTextW`      |\n| **Window Screenshots**      | Capture desktop or specific window rects directly to PNG                         | GDI `BitBlt` capture + lightweight PNG encoding          |\n| **JVM \u002F JNI Analysis**      | Inspect JARs, extract classes, methods, fields, and bytecode                     | Headless JVM reflection and class-model inspector        |\n| **Deterministic Emulation** | Simulate x86_64 machine code execution and track register\u002Fmemory state           | In-memory Win64 CPU machine and syscall emulator         |\n\n---\n\n## Showcases\n\n### Showcase 1: Live Notepad Keystroke Hooking (MinHook Detour)\n\nIntercept 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:\n\n```typescript\n\u002F\u002F AI Agent installs detour via minhook_install\nawait minhook_install({\n  session: 'notepad.exe',\n  target: 'user32.dll!SetWindowTextW',\n  detourMachineCode: shellcodeHex,\n});\n```\n\n- Target function remains valid and fully callable via the generated trampoline.\n- Automatic 14-byte far relay allocated if the detour sits >2GB away.\n- Hot-swappable and reversible with `minhook_remove`.\n\n### Showcase 2: Thread Context Hijacking Without DLL Injection (`nthread`)\n\nExecute arbitrary Win32 API calls inside a remote process without spawning a remote thread:\n\n```typescript\n\u002F\u002F nthread suspends a thread, parks it at a jmp $ stub, sets RIP\u002FRCX\u002FRDX,\n\u002F\u002F resumes it, and captures RAX upon return:\nconst res = await nthread_call({\n  session: 'target.exe',\n  function: 'kernel32.dll!GetCurrentProcessId',\n  args: [],\n});\nconsole.log('Remote PID:', res.returnValue);\n```\n\n### Showcase 3: On-the-Fly C-to-Shellcode JIT Compilation\n\nCompile C code to relocatable x86_64 machine code and disassemble it:\n\n```bash\nexoproc compile -s \"int add(int a, int b) { return a + b; }\"\n```\n\nOutput:\n\n```\nSuccessfully compiled x86_64 machine code (18 bytes):\nHex: 554889e54881ec20000000e8d6ffffffc9c3\n\nDisassembly:\n  0x1000: push      rbp\n  0x1001: mov       rbp, rsp\n  0x1004: sub       rsp, 0x20\n  0x100b: call      0xfe6\n  0x1010: leave\n  0x1011: ret\n```\n\n### Showcase 4: Live C-Style Win32 Scripting with Automatic Marshalling\n\nExecute Win32 scripts with standard C structs, string buffers, and out-parameters:\n\n```typescript\n\u002F\u002F AI Agent executes directly in target process via execute_code\nawait execute_code({\n  session: 'notepad.exe',\n  code: `\n    RECT rc;\n    GetWindowRect(HWND, &rc);\n    print(\"Window bounds: \" + rc.left + \", \" + rc.top + \" - \" + rc.right + \", \" + rc.bottom);\n\n    StringBuffer buf(256);\n    GetWindowTextW(HWND, buf, 256);\n    print(\"Current Title: \" + buf.toString());\n  `,\n});\n```\n\n---\n\n## MCP tool catalog\n\nExoproc exposes **21 high-performance tools** over standard Model Context Protocol (stdio):\n\n| Category                | Tool                 | Description                                                        |\n| :---------------------- | :------------------- | :----------------------------------------------------------------- |\n| **Process Discovery**   | `list_processes`     | Discover running processes with PIDs, names, and thread counts     |\n|                         | `spawn_process`      | Spawn a target process de-elevated with arguments                  |\n|                         | `execute_command`    | Execute shell commands and capture stdout\u002Fstderr                   |\n| **Session Lifecycle**   | `open_accessor`      | Attach to a target process via PID or image name                   |\n|                         | `close_accessor`     | Detach and clean up allocated remote buffers                       |\n| **Memory Manipulation** | `read_memory`        | Read memory as hex, raw bytes, UTF-8\u002FUTF-16 strings, or numbers    |\n|                         | `write_memory`       | Write raw bytes, strings, or numbers into target memory            |\n|                         | `scan_pattern`       | Search memory for byte patterns with wildcards (`48 8B ? ? 48 85`) |\n|                         | `allocate_memory`    | Allocate executable, read\u002Fwrite, or protected virtual memory       |\n| **Function Detours**    | `minhook_install`    | Install a 5-byte relative JMP detour with trampoline and far relay |\n|                         | `minhook_remove`     | Restore original bytes and clean up detour trampolines             |\n|                         | `list_hooks`         | Enumerate all active detours and trampolines                       |\n| **Thread Hijacking**    | `nthread_call`       | Invoke a remote function via live thread context redirection       |\n| **C JIT & Compilation** | `compile_c`          | JIT-compile C code into standalone x86_64 shellcode via TinyCC     |\n|                         | `compile_shellcode`  | Alias for `compile_c` with automatic remote target injection       |\n|                         | `disassemble`        | Disassemble hex bytes into x86_64 assembly via Capstone            |\n| **Win32 Execution**     | `execute_code`       | Execute C-style Win32 code inside the remote target process        |\n|                         | `execute_local_code` | Execute Win32 code in the local runner process                     |\n| **Desktop Inspection**  | `list_windows`       | Enumerate desktop windows, HWNDs, titles, and child edit controls  |\n|                         | `take_screenshot`    | Capture desktop or window rect directly to PNG                     |\n| **JVM Analysis**        | `jvm_inspect_jar`    | Inspect JAR contents, classes, methods, and bytecode signatures    |\n\n---\n\n## Supported AI agents\n\n`exoproc setup` automatically detects, backs up, and registers with:\n\n| Agent \u002F IDE              | Configuration Target                       | Installed Skills & Rules                                               | Transport |\n| :----------------------- | :----------------------------------------- | :--------------------------------------------------------------------- | :-------- |\n| **Claude Code**          | `~\u002F.claude.json`                           | `~\u002F.claude\u002Fskills\u002Fexoproc\u002FSKILL.md`\u003Cbr>`~\u002F.claude\u002Fcommands\u002Fexoproc.md` | Stdio     |\n| **Cursor**               | `~\u002F.cursor\u002Fmcp.json`\u003Cbr>`.cursor\u002Fmcp.json` | `~\u002F.cursor\u002Frules\u002Fexoproc.mdc`                                          | Stdio     |\n| **Windsurf**             | `~\u002F.codeium\u002Fwindsurf\u002Fmcp_config.json`      | Global Tool Discovery                                                  | Stdio     |\n| **Claude Desktop**       | `claude_desktop_config.json`               | Native Stdio MCP Server                                                | Stdio     |\n| **Antigravity \u002F Gemini** | `~\u002F.gemini\u002Fantigravity\u002Fmcp_config.json`    | `~\u002F.gemini\u002Fantigravity\u002Fskills\u002Fexoproc\u002FSKILL.md`                        | Stdio     |\n| **VS Code Cline**        | `cline_mcp_settings.json`                  | Native MCP Configuration                                               | Stdio     |\n| **OpenCode**             | `~\u002F.config\u002Fopencode\u002Fopencode.json`         | Global Tool Integration                                                | Stdio     |\n| **Zed**                  | `~\u002F.config\u002Fzed\u002Fsettings.json`              | `context_servers.exoproc`                                              | Stdio     |\n\n---\n\n## CLI reference\n\n```\nUsage:\n  exoproc \u003Ccommand> [options]\n\nCore Commands:\n  setup              Configure AI agents with Exoproc MCP server & skills\n  mcp                Run the Model Context Protocol (MCP) server over stdio\n  doctor, status     Inspect host environment, AI agents, and binary SHA checksums\n\nDiagnostics & Tools:\n  ps                 List active processes on target system\n  windows            List visible desktop windows & child edit controls\n  screenshot [path]  Capture desktop or window screenshot (PNG)\n  compile \u003Ccode|file> Compile C source to x86_64 machine code \u002F shellcode\n  exec \u003Ccode>        Execute C-style Win32 code snippet (--pid \u003Cpid> for remote)\n  run \u003Cscript.ts>    Execute automation or diagnostics script\n\nGlobal Options:\n  --help, -h         Show help message\n  --version, -v      Show Exoproc version\n  --yes, -y          Automatically approve prompts (for setup)\n  --dry-run          Preview changes without writing to disk\n```\n\n---\n\n## FAQ\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>Which AI agents can use Exoproc?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\nAny 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.\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>Do I need to inject a DLL into the target process?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\nNo. 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.\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>What happens if a detour target is further than 2GB away?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\nA 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]; \u003Cabsolute 64-bit address>`) near the target and points the 5-byte JMP at the relay. Near detours still receive direct, low-latency relative JMPs.\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>How does `nthread` execute calls without CreateRemoteThread?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\n`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.\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>Can I compile C code directly to shellcode?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\nYes. 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.\n\n\u003C\u002Fdetails>\n\n\u003Cdetails>\n\u003Csummary>\u003Cstrong>Does Exoproc work offline without an internet connection?\u003C\u002Fstrong>\u003C\u002Fsummary>\n\nYes. Exoproc runs 100% locally on your machine. No telemetry, no external servers, and no background daemon ports.\n\n\u003C\u002Fdetails>\n\n---\n\n## Architecture\n\nExoproc is structured as a modular TypeScript monorepo targeting Windows x64:\n\n```\npackages\u002F\n├── xffi\u002F                # Low-level Win64 FFI, C-ABI types, memory accessors, TinyCC JIT\n├── win32\u002F\n│   ├── api\u002F             # Typed Win32 wrappers (Process, Window, Module, Hook base)\n│   └── abi\u002F             # Win32 C constants, struct definitions, ABI offsets\n├── nthread\u002F             # Thread context hijacking without CreateRemoteThread\n├── minhook\u002F             # 5-byte JMP trampoline detours with far relays & Capstone\n├── nshm\u002F                # Shared memory transport and de-elevated process spawning\n├── accessors\u002F           # Composite accessors: memcmp-read, memset-write, process-cache\n├── capstone\u002F\n│   ├── core\u002F            # Capstone 4.0.2 disassembler with on-demand binary caching\n│   └── abi\u002F             # Capstone C-ABI types and instruction definitions\n├── java\u002F\n│   ├── njava\u002F           # JVM reverse engineering, JNI reflection, Java.type dynamic proxies\n│   ├── jjit\u002F            # Java 8\u002F17+ in-memory compiler (ECJ) and Tiny-Remapper obfuscator\n│   ├── agent\u002F           # In-process Java bytecode injection agent (Exoproc.java)\n│   ├── mappings\u002F        # Obfuscation mapping pool resolver (Tiny v1, MCP, Mojang, SRG)\n│   ├── runtime\u002F         # Modular runtime execution context, Nashorn compatibility shims\n│   └── nashorn\u002F         # Dynamic Nashorn engine compatibility shims\n├── simulate\u002F            # Deterministic in-memory x86_64 CPU and Win32 syscall emulator\n├── runner\u002F              # Ambient execution context for C-style Win32 scripts\n├── utils\u002F               # Shared logging, cache, on-demand dependency downloader & SHA verification\n├── exoproc-mcp\u002F         # 21-tool Model Context Protocol server (pure stdio transport)\n└── exoproc\u002F             # Unified CLI, setup wizard, doctor diagnostics, and distribution\n```\n\n---\n\n## Contributing & Monorepo Development\n\n```bash\n# Clone and install dependencies\ngit clone https:\u002F\u002Fgithub.com\u002Fw0ldan\u002Fexoproc.git\ncd exoproc\nbun install\n\n# Verify\u002Fdownload binary dependencies into persistent cache (~\u002F.cache\u002Fexoproc\u002Fdeps)\nbun run deps\n\n# Compile all 23 packages and generate declaration files\nbun run build\n\n# Multi-core TypeScript type check (340+ files across 23 projects)\nbun run typecheck\n\n# Run test suites\nbun test\n\n# Independent version bump for changed packages\nbun run bump:changed\n```\n\n---\n\n## Disclaimer\n\nSee [DISCLAIMER.md](DISCLAIMER.md) for responsible-use guidance.\n\nExoproc is designed for lawful research, debugging, reverse engineering, software preservation, and interoperability analysis of applications you own or are authorized to examine.\n\n---\n\n## License\n\n[MIT](LICENSE) © Serkan\n",2,"2026-10-31 04:26:35","CREATED_QUERY"]