Skip to main content
Glama

@jshookmcp/jshook

License: AGPLv3 Node.js 22.22.2+ TypeScript MCP pnpm

A search-first, profile-aware reverse-engineering workspace for AI agents.

Hook the page, capture the network, deobfuscate the bundle, disassemble the WASM, instrument the process — and let one MCP server keep the whole attack surface in reach without drowning the model in schemas.

English · 中文


What makes jshook different

Most MCP servers for JS analysis expose a handful of hand-rolled tools or wrap a single browser engine. jshook is closer to an operating system for front-end reverse engineering — 36 self-discovered domains, a search-first meta-tool that keeps token cost under control, and runtime recovery that survives broken pages and dropped sessions:

  • Search-first, profile-aware. The search profile loads about 3K tokens of tool metadata; the full profile exposes all 736 tools at around 109K tokens (measured 2026-10-10 — this figure scales with the tool count, so re-measure it when the catalog grows). Agents move between them as the task grows — search → workflow → full — instead of drowning in schemas from the first turn.

  • Runtime recovery and session isolation. Streamable HTTP sessions restore activated domains, browser attach state, and coverage state after reconnects; per-client browser-side state stays isolated so two agents cannot trample each other's CDP sessions.

  • Full-stack browser automation. Chromium and Camoufox via CDP with anti-detection, an explicit-input CAPTCHA solver (no built-in page/feature probing), a self-signed HTTPS interception CA on demand, and HTTP/2 frame building.

  • Real reverse engineering, not string searches. WASM disassembly via wabt (wasm2wat / wasm-decompile / wasm-objdump), Frida/Ghidra/IDA bridges, native FFI scanning, hardware breakpoints, PE introspection, GraphQL/Burp Suite proxy bridges, and AST transforms — not a single regex call wrapped as a tool.

  • Dynamic extensibility. Hot-reload plugins, declarative workflows, and auto-discovery keep the server growing without a redeploy.


Related MCP server: JS Reverse Strong MCP

Capability overview

A scan of what's in the box. Each row links to the detailed Capability overview below.

Area

Highlights

Tool profiles

search (~3K tokens, BM25 + hybrid vector ranking) · workflow (composite scripts) · full (all 736 tools)

Browser automation

Chromium and Camoufox · CDP attach to existing targets · anti-detection presets · explicit-input CAPTCHA solver · popup, download, permission, and protocol interceptors

Network interception

HTTP/1.1 + HTTP/2 frame building · MITM proxy with auto-generated CA · WebSocket capture · GraphQL introspection helpers · Burp Suite bridge

JS hooks and analysis

LLM-powered deobfuscation · crypto routine detection · AST comprehension · source-map reconstruction · script/scriptlet extraction and replay

WASM reverse engineering

wabt disassembly / C transpilation (wasm2wat / wasm-decompile / wasm-objdump / wasm2c) · Binaryen wasm-opt · pure-TS section parser · import/export listing · section-grouped string extraction with name-section recovery · function-level binary diff · obfuscation detection · function- and basic-block-level instrumentation

Process and memory forensics

Native FFI scanning · cross-reference graphs · hardware breakpoints · PE introspection · live process attach · memory read/write with region guards

Binary instrumentation

Frida bridge · Ghidra and IDA bridges · syscall hooking · TLS keylog and session tooling · Mojo IPC analysis

Android and APK analysis

APK static triage · manifest dump and query · apktool decode / build · jadx decompilation and code search · DEX scanning · native library listing · APK signing · unidbg emulation · runtime DEX dump

Native runtime

Native emulator for foreign-architecture samples · platform introspection · Mojo IPC · Dart Inspector · ADB bridge for on-device traffic

Encoding and transform

URL/Base64/Hex/JWT/Protobuf encoders · AST transforms · streaming decode pipelines

Coordination

Background task queue with progress, cancellation, and async modes · multi-agent coordination · coverage reports

Schema-first meta tools

describe_tool · call_tool with argument validation · coverage_report · search_tools

Pluggable extension registry

Hot-reload plugins · declarative workflows · auto-discovered domains


Use cases

Scenario

What you do

Domains involved

Skim a minified bundle

search_tools → deobfuscate → search_in_scripts → understand_code

core

Reverse a CAPTCHA challenge

Drive a Camoufox page → screenshot → solve with explicit input → replay

browser, canvas

Capture and replay an OAuth flow

proxy_start (auto CA) → network_get_requests → graphql_introspect → graphql_replay

proxy, network, graphql

Reverse a WASM crypto routine

wasm_dump → wasm_disassemble → generate_hooks → memory_breakpoint

wasm, binary-instrument, memory

Triage a suspicious APK

apk_static_triage → apk_manifest_dump → jadx_decompile → dex_scan_file

binary-instrument

Recover a dropped browser session

Reconnect Streamable HTTP → restore activated domains and browser state

browser, coordination

Audit a Node process for credentials

process_list → memory_scan_filtered → binary_strings_extract

process, memory, binary-instrument

Build a custom workflow

list_extension_workflows → run_extension_workflow

workflow, extension-registry

Hook a function in a live process

frida_spawn → frida_attach_interceptor → frida_run_script → frida_enumerate_functions

binary-instrument


Quick start

No global install needed — add to your MCP client config and you're ready.

Claude Desktop / Cursor (claude_desktop_config.json):

{
  "mcpServers": {
    "jshook": {
      "command": "npx",
      "args": ["-y", "@jshookmcp/jshook@latest"],
      "env": {
        "MCP_TOOL_PROFILE": "search",
        "npm_config_omit": "optional"
      }
    }
  }
}

(Windows: use npx.cmd absolute path if npx is not found.)

This lightweight configuration skips optional ONNX, Z3, Binaryen, Camoufox, and Playwright packages. Remove npm_config_omit when those full-profile runtimes are required.

Share one daemon across multiple agents

The default stdio configuration starts one full jshook process per MCP host. To share the embedding model, browser runtime, and caches, start one local Streamable HTTP daemon:

pnpm build
pnpm daemon

Vector search is on by default on every transport — a lightweight static model whose catalog embeddings persist to disk, loaded lazily and released when idle. Set SEARCH_VECTOR_ENABLED=false when lexical search is sufficient.

Then point every MCP client at http://127.0.0.1:3000/mcp using its HTTP/URL server configuration. Each client receives its own MCP session and response route while heavyweight runtime resources remain in one process. Keep the default loopback bind; set MCP_AUTH_TOKEN before exposing the endpoint beyond localhost.

Promote a profile as the task grows

{
  "env": {
    "MCP_TOOL_PROFILE": "search"     // start here, ~3K tokens of metadata
  }
}

Switch MCP_TOOL_PROFILE to workflow once you start chaining composite scripts, or to full when you need every tool. coverage_report shows the active set on demand.


Highlights

  • Profile ladder. Start in search (~3K tokens of metadata); promote to workflow when chaining composite scripts; escalate to full only when every tool is actually needed. coverage_report shows what's active on demand.

  • Meta tools. describe_tool returns the JSON Schema; call_tool validates arguments before invocation; every tool ships with readOnlyHint / destructiveHint / idempotentHint / openWorldHint.

  • Browser automation. Chromium and Camoufox via CDP, attach to existing targets, anti-detection presets, popup/download/permission interceptors, explicit-input CAPTCHA solver, JS/CSS injection at three document phases, persisted coverage across reconnects.

  • Network interception. Auto-generated HTTPS interception CA, HTTP/1.1 + HTTP/2 frame building, WebSocket capture, GraphQL helpers, Burp Suite bridge — all on the same MCP tool surface.

  • Reverse engineering. wabt WASM disassembly (wasm2wat / wasm-decompile / wasm-objdump) and Binaryen wasm-opt, Frida/Ghidra/IDA bridges, hardware breakpoints, native FFI scanning, PE introspection, syscall hooking, AST transforms, source-map reconstruction.

  • Session recovery. Streamable HTTP transport restores activated domains, browser attach state, and coverage state after reconnects; browser-side state is isolated per client.

  • Plugins and workflows. Drop a directory, get a domain. Write a YAML pipeline, run it as one tool. The registry self-discovers.


Transport and deployment

The server supports two transports out of the box.

Transport

When to use

Notes

stdio

Default for Claude Desktop, Cursor, and other single-host clients

One full process per MCP host; lightweight profile recommended

Streamable HTTP

Multiple agents sharing the embedding model, browser runtime, and caches

Loopback bind by default; set MCP_AUTH_TOKEN before exposing externally

Both transports expose the same tool surface. coverage_report shows which domains are activated in each session — long-running sessions restore browser attach state, coverage state, and tool activations across reconnects.

For production deployments see the Security and Production guide.


Recent runtime notes

  • HTTP transport now multiplexes independent MCP sessions and restores runtime state after reconnects.

  • proxy_start auto-generates a local HTTPS interception CA when needed.

  • Browser CAPTCHA solving is now explicit-input driven: pass taskKind, siteKey, imageBase64, callbackName, and responseSelector as needed. Built-in widget/page signature probing is intentionally not used.


Registry snapshot

The built-in surface below is generated from the runtime registry and checked in CI.

  • Package version: 0.4.6

  • Built-in tools: 736

  • Domains: adb-bridge, binary-instrument, browser, canvas, coordination, core, cross-domain, dart-inspector, debugger, encoding, exploit-dev, extension-registry, graphql, instrumentation, maintenance, memory, mojo-ipc, native-bridge, native-emulator, network, platform, process, protocol-analysis, proxy, session, sourcemap, streaming, syscall-hook, tasks, tls-inspector, trace, transform, v8-inspector, wasm, webgpu, workflow

  • Note: this snapshot is generated from the runtime registry; do not edit the counts by hand.

View the complete Tool Reference ↗


Architecture

  • Runtime registry — domains auto-discovered via manifest.ts; add a domain by creating one file.

  • Lazy initialization — handlers instantiated on first call, not at startup.

  • BM25 + vector search — search_tools meta-tool with hybrid ranking and adaptive weights.

  • MCP ToolAnnotations — every tool carries readOnlyHint / destructiveHint / idempotentHint / openWorldHint.

  • Profile ladder — search (~3K tokens) → workflow (composite scripts) → full (all 736 tools).

  • Transport symmetry — stdio and Streamable HTTP expose the same surface; sessions are isolated per client.

See the Architecture guide and Configuration reference for the canonical details.


Build from source

Requirements: Node.js 22.22.2+, pnpm 10.x.

pnpm install
pnpm build
pnpm start           # run the built server from dist/
pnpm dev             # run from source under tsx watch
pnpm check           # drift guards (metadata + openapi + domain + event contracts) + lint + format check + typecheck + unit tests
pnpm test            # Vitest unit suites
pnpm test:e2e        # end-to-end browser/tooling suites
pnpm daemon          # run the Streamable HTTP daemon after build

Native helpers are bundled via pnpm build; on first run the server may download optional runtimes (ONNX, Z3, Binaryen, Camoufox, Playwright) depending on the profile.


Project stats

Activity


License

AGPLv3.

Available Tools

8 tools
activate_domainA

Register every tool in a single domain at once. Use this when a task needs a whole capability area; prefer search_tools or activate_tools when you only need a few specific tools, because activating a domain costs far more context. Domains: . Activated tools appear in the tool list immediately; if your client does not refresh its tool list, invoke them with call_tool. Activation draws on the session context budget: when the budget is full, least-recently-used tools are evicted to make room, and the response reports what was activated and what was evicted. Pass precheck: true to preview wouldActivate / wouldEvict without changing anything. Activated tools auto-deactivate after ttlMinutes (default 30; pass 0 for no expiry). Use reload_extensions first to include external plugin/workflow domains.

Inputs: domain (required), precheck, ttlMinutes.

activate_toolsA

Dynamically register specific tools by name, regardless of current base tier. Use after search_tools to enable exactly the tools you need. In search-tier sessions this is usually enough; use activate_domain when you need every tool in a domain. Activated tools appear in the tool list immediately. If tools do not appear after activation, use call_tool to invoke them directly.

Inputs: names (required), precheck.

call_toolA

Execute an already-active tool by name. Use this when activate_tools/activate_domain registered a tool but your client did not refresh its tool list. Does not auto-activate inactive tools.

Inputs: name (required), args, arguments, parameters.

coverage_reportA

Report which tools have been called in the current runtime and which known tools remain uncalled. Loads all domains first so the uncalled list reflects the full tool catalog, not just currently active tools.

Inputs: no named parameters.

deactivate_toolsA

Remove previously activated tools to free context. Only affects dynamically activated tools (added via activate_tools, activate_domain, or extension activation), not base profile tools.

Inputs: names (required).

describe_toolA

Get detailed information about a specific tool, including its input schema. Use this to see the exact parameters a tool expects before calling it.

Inputs: name (required).

route_toolA

One-stop tool router: accepts a natural language task description, returns recommended tools and next actions. Automatically detects workflow patterns, recommends activation order, and provides example arguments. Use this instead of search_tools when you want guided tool discovery with actionable next steps.

Inputs: task (required), context.

search_toolsA

Search 736 tools across 36 capability domains. This includes built-in tools plus any loaded plugin/workflow tools (0 currently loaded). In search-tier sessions, call this before assuming a capability is unavailable. Use activate_tools for exact matches, activate_domain for an entire domain. Domains: browser (85) | memory (75) | native-emulator (57) | binary-instrument (46) | network (38) | process (29) | tls-inspector (29) | adb-bridge (26) | core (25) | debugger (21) | exploit-dev (21) | v8-inspector (21) | protocol-analysis (20) | platform (18) | maintenance (17) | streaming (17) | wasm (17) | dart-inspector (16) | syscall-hook (15) | instrumentation (13) | workflow (13) | coordination (12) | canvas (11) | proxy (11) | trace (10) | webgpu (10) | cross-domain (8) | mojo-ipc (8) | transform (8) | extension-registry (7) | graphql (7) | sourcemap (7) | native-bridge (6) | encoding (5) | tasks (4) | session (3). Query tip: before searching, distill your intent into key concepts (action verb + target + domain). The engine combines token matching, fuzzy names, profile context, and optional static embeddings.

Inputs: query (required), top_k, auto_activate.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 8 tools

    Disambiguation4/5

    Most tools have clearly distinct roles: discovery (search_tools, route_tool, describe_tool), activation lifecycle (activate_tools, activate_domain, deactivate_tools), execution (call_tool), and reporting (coverage_report). The only mild overlaps are search_tools vs route_tool (both discovery) and activate_tools vs activate_domain, but the descriptions explicitly differentiate them by intent and cost.

    Naming Consistency4/5

    Nearly all names follow a consistent verb_noun snake_case pattern (search_tools, activate_tools, call_tool, describe_tool). The main deviation is coverage_report, which is a noun phrase rather than an action, but it remains readable and predictable.

    Tool Count5/5

    Eight tools is well-scoped for a meta-server that manages 736 tools across 36 domains. Each tool covers a distinct phase of the discovery-activation-execution lifecycle and none feels redundant or filler.

    Completeness3/5

    The surface covers discovery, activation, deactivation, execution, and coverage reporting, but there is no dedicated tool to list currently active tools or enumerate domains, and activate_domain's domain list is empty. The descriptions also reference reload_extensions, which is not present in the tool set, creating a dead end for plugin/workflow domain loading.

    Maintenance

    ActivityActive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers