Skip to main content
Glama
camoufox-versatile-mcp

camoufox-versatile-mcp

camoufox-versatile-mcp

中文 | English

基于反指纹浏览器(Camoufox)的 MCP Server,支持 通用 captcha 挑战自动通过 + JSVMP 签名还原管线。

Fork 自 camoufox-reverse-mcp,新增:

  • 内置 captcha 通用检测 + 自动通过(基于 camoufox_captcha)

  • 全新 JSVMP 离线复现管线:WASM 反汇编 / Worker 源码捕获 / WS 流量抓取 / 离线重放 + 自动 diff


快速开始

安装

方式一:AI 对话框直接安装(推荐)

在你常用的 AI 编码工具(Cursor / Claude Code / Windsurf / Coze 等)的对话框中输入:

帮我安装下这个 MCP 工具:camoufox-versatile-mcp
项目地址:https://github.com/usernamexiaozhang/camoufox-versatile-mcp

AI 会自动完成以下全部步骤:

  1. git clone 或 pip install 克隆安装项目

  2. 读取 pyproject.toml 确认依赖

  3. 配置 Cursor 的 mcpServers(自动写入 settings.json)

  4. 启动 MCP Server 并验证连接

为什么推荐这种方式? AI 了解你的操作系统、Python 环境、Cursor 版本,它可以处理 Windows/macOS/Linux 的路径差异,自动选择合适的安装命令,并在安装完成后告诉你是否成功。

方式二:手动安装

git clone https://github.com/usernamexiaozhang/camoufox-versatile-mcp
cd camoufox-versatile-mcp
pip install -e .

客户端配置(Cursor)

{
  "mcpServers": {
    "camoufox-versatile": {
      "command": "python",
      "args": ["-m", "camoufox_versatile_mcp"]
    }
  }
}

启动参数

参数

说明

--headless

无头模式运行

--proxy

代理服务器,如 --proxy http://127.0.0.1:7890

--geoip

启用 GeoIP 推理(根据代理 IP 自动设置地理位置)

--humanize

启用拟人化鼠标移动

--os

OS 指纹:auto / windows / macos / linux

--locale

浏览器语言,如 zh-CN


Related MCP server: crypto-reverse-mcp

工具一览(共 45 个)

浏览器控制(11 个)

工具

说明

launch_browser

启动 Camoufox 反指纹浏览器(含 i_know_what_im_doing + disable_coop + forceScopeAccess 默认三件套)

close_browser

关闭浏览器

navigate

导航到指定 URL(支持 auto_solve_challenge 参数)

reload

刷新页面

take_screenshot

截图

take_snapshot

获取页面无障碍树

click / type_text

点击元素 / 输入文本

wait_for

等待元素出现或 URL 匹配

get_page_info

获取当前页面信息

scroll

滚动页面

go_back / go_forward

前进 / 后退

通用 Captcha 挑战自动通过(2 个)⭐

工具

说明

detect_captcha

检测当前页面是否有 captcha 挑战(不点击)

auto_solve_captcha

自动检测 + 通过 captcha 挑战(captcha_type / challenge_type)

支持 cloudflare 的 Turnstile 和 Interstitial 两种模式,captcha_type 参数预留扩展位(hcaptcha、recaptcha 等)。

注意:非标准 Cloudflare 挑战(如自定义 WAF checkbox)需要额外定制化处理。

JS 执行与调试(1 个)

工具

说明

evaluate_js

在页面上下文执行任意 JS 表达式

脚本分析(2 个)

工具

说明

scripts(action)

脚本管理:list / get / save

search_code

搜索关键词

Hook 与追踪(4 个)

工具

说明

hook_function

Hook 或追踪函数

inject_hook_preset

注入预置 Hook(xhr / fetch / crypto / websocket / debugger_bypass / cookie / runtime_probe)

remove_hooks

移除所有 Hook

inject_hook

注入自定义 JS Hook

网络分析(5 个)

工具

说明

network_capture(action)

网络捕获控制

list_network_requests

列出已捕获的请求

get_network_request

获取请求完整详情

get_request_initiator

获取请求发起的 JS 调用栈

intercept_request

拦截请求

JSVMP 逆向分析(5 个)

工具

说明

hook_jsvmp_interpreter

JSVMP 运行时探针

instrumentation(action)

源码级插桩

compare_env

浏览器环境指纹收集

detect_vmp

检测页面使用了哪种 VMP 保护(obfuscated / string_eval / vm_dispatch / wasm)

trace_vmp_for_sign

签名安全 Tap:追踪 VMP 读取了哪些 fingerprint 属性

工具

说明

cookies(action)

Cookie 管理

get_storage

获取 localStorage / sessionStorage

export_state / import_state

导出 / 导入浏览器状态

验证(1 个)

工具

说明

verify_fingerprint

验证指纹是否满足目标网站要求

环境感知(1 个)

工具

说明

get_env_info

获取当前浏览器环境信息(OS、UA、屏幕、语言等)

JSVMP 离线重放管线(8 个)🆕

工具

说明

get_tap_log

读取 trace_vmp_for_sign 记录的 Tap 日志

disassemble_wasm

将 WASM 字节码反汇编为 WAT + 导入/导出函数列表 + 入口函数猜测

capture_worker_js

劫持 new Worker(),捕获 blob: URL 源码(JSVMP 字节码的直接来源)

capture_ws_payloads

劫持 new WebSocket(),记录所有 send/recv 流量

auto_suggest_missing_props

根据失败日志 + trace_log 推荐缺失的 fingerprint prop

replay_vmp_offline

在 Node 沙箱中离线重放 VMP 代码(增强版:支持 supplied_env / expected_sign / auto_diff)

trace_vmp_for_sign

签名安全 Tap:追踪 VMP 读取了哪些 fingerprint 属性


JS 引擎 Trace + HTTP 包 Trace(3 个)🆕

|| 工具 | 说明 | ||------|------| || js_engine_trace | JS 引擎 tracing(三层独立方案,零编译,零 patch) | || http_packet_trace | HTTP 包 trace(捕获完整请求/响应 + 发起者 JS 调用栈) | || trace_js_and_http | 组合模式:同时开启 JS trace + HTTP trace,持续 N 秒后自动停止 |

基于 RuyiTrace 的 HttpPacketTrace 思路,用 Playwright 路由拦截实现,无需 RuyiTrace 的 C++ 插桩。

Captcha 挑战自动通过使用示例

方式一:导航时自动过挑战(推荐)

navigate(
    url="https://target-site-with-captcha.com/",
    auto_solve_challenge=True,        # 开启自动过挑战
    challenge_type="auto",             # auto 检测 turnstile/interstitial
    challenge_ready_delay=5.0,         # 等待 iframe 加载
    expected_content_selector="#main"  # 成功后等待主内容出现
)

方式二:手动调用工具

# 1. 先检测
result = detect_captcha()
# 返回: {"url": "...", "detected": {"turnstile": True, "interstitial": False}, "challenge_present": True}

# 2. 再解决
result = auto_solve_captcha(
    captcha_type="cloudflare",   # 当前支持 cloudflare
    challenge_type="auto",       # auto / interstitial / turnstile
    ready_delay=5.0,
    solve_attempts=3,
    verify=True
)
# 返回: {"solved": True, "verified": True, "challenge_type_used": "turnstile", ...}

JSVMP 离线重放管线(典型流程)

┌─────────────────────────────────────────────────────────┐
│  ① 浏览器端:trace_vmp_for_sign()                       │
│     → 追踪 VMP 读取了哪些 fingerprint 属性               │
│     → 输出 prop → value 列表                            │
│                                                         │
│  ② WASM 反汇编:disassemble_wasm()                       │
│     → 传入 b64/hex/wasm-url                            │
│     → 输出 WAT + imports/exports + 入口函数猜测          │
│                                                         │
│  ③ Worker 源码捕获:capture_worker_js()                  │
│     → 劫持 new Worker(blob:...)                        │
│     → 获取 VMP 字节码源码                               │
│                                                         │
│  ④ WS 流量抓取:capture_ws_payloads()                   │
│     → 劫持 new WebSocket()                              │
│     → 记录 VMP 获取字节码的请求/响应                    │
│                                                         │
│  ⑤ 离线重放:replay_vmp_offline()                       │
│     → Node 沙箱执行 VMP 代码                             │
│     → supplied_env 注入缺失的 fingerprint                │
│     → auto_diff 对比签名是否匹配                         │
│                                                         │
│  ⑥ 缺失属性建议:auto_suggest_missing_props()           │
│     → 结合 trace_log + 失败日志推荐 props                │
│     → 输出可直接复制到 supplied_env                      │
└─────────────────────────────────────────────────────────┘

完整示例

# Step 1: 在浏览器中追踪 VMP 读取的属性
props = trace_vmp_for_sign(
    trigger_js="sign({order_id: 12345})",
    wait_ms=500,
)

# Step 2: 反汇编 WASM(如果 VMP 使用了 WebAssembly)
wasm_info = disassemble_wasm(wasm_b64, source_kind="base64", generate_wat=True)
print(wasm_info["exports"])   # e.g. ["enc", "dec"]
print(wasm_info["entry_candidates"])

# Step 3: 离线重放(第一次可能 diff 不匹配)
result = replay_vmp_offline(
    vmp_code=vmp_code,
    entry="sign",
    input={"order_id": 12345},
    expected_sign="target_sign_value",
    auto_diff=True,
)
if not result["diff"]["match"]:
    # Step 4: 获取建议的缺失 prop
    suggestions = auto_suggest_missing_props(
        failed_replay_error=result["diff"]["replayed_preview"],
        supplied_env={},
    )
    print(suggestions["suggestions"])

    # Step 5: 重新重放(带上建议的 env)
    result = replay_vmp_offline(
        vmp_code=vmp_code,
        entry="sign",
        input={"order_id": 12345},
        expected_sign="target_sign_value",
        auto_diff=True,
        supplied_env={"navigator": {"userAgent": "..."}},
    )
    assert result["diff"]["match"]

JS 引擎 Trace + HTTP 包 Trace 使用示例

方式一:组合模式(最简单)

# 同时开启 JS trace + HTTP trace,持续 5 秒后自动停止
result = trace_js_and_http(
    duration=5,
    trace_js=True,
    trace_http=True,
    trace_values=True,           # 捕获函数参数值
    trace_dom_events=True,       # 捕获 DOM 事件
    capture_http_body=False,    # 不捕获响应体(省空间)
)
# result["js_trace_summary"]   → JS 函数调用热图
# result["http_trace"]         → HTTP 请求摘要

方式二:分步控制

# Layer 1: 安装 JS 源码级 tracer(无需特殊浏览器)
js_engine_trace(action="install_js", max_depth=20, trace_values=True)

# 导航到目标页面,触发 JS
navigate("https://target-site.com/api/sign")

# 读取 trace 结果
result = js_engine_trace(action="read", session_id="abc12345")
# → hot_functions, depth_histogram, sample_events

# Layer 2: HTTP 包 trace
http_packet_trace(action="start", capture_body=True)

# 触发目标请求
await page.evaluate("fetch('/api/sign', {method:'POST', body: JSON.stringify({a:1})})")

# 读取 HTTP trace
http_result = http_packet_trace(action="read")
# → api_requests, javascript_requests, slow_requests

方式三:CDP DevTools 原生 tracer(需要 remote_debugging_port)

# 启动带 remote debugging 的浏览器
launch_browser(remote_debugging_port=9222)

# 启动 CDP 原生 tracer(Firefox 内置的 JS ExecutionTracer)
js_engine_trace(
    action="start_cdp",
    trace_values=True,
    trace_dom_events=True,
    trace_dom_mutations=False,
    max_records=50000,
    cdp_port=9222,
)

技术架构

┌─────────────────────────────────────────────────┐
│           AI 编码助手 (Cursor / Claude)          │
│                    ↕ MCP (stdio)                  │
├─────────────────────────────────────────────────┤
│           camoufox-versatile-mcp                 │
│  ┌──────────┬──────────┬──────────┬──────────┐  │
│  │Navigation│ Script   │Debugging │ Hooking  │  │
│  ├──────────┼──────────┼──────────┼──────────┤  │
│  │ Network  │ JSVMP    │  Cookie  │  Verify  │  │
│  ├──────────┼──────────┼──────────┼──────────┤  │
│  │ ★ Captcha Auto-Solve (cloudflare)           │  │
│  │ ★ JSVMP Pipeline (WASM/Worker/WS/Replay)    │  │
│  └──────────┴──────────┴──────────┴──────────┘  │
│                    ↕ Playwright API              │
├─────────────────────────────────────────────────┤
│      Camoufox (反指纹 Firefox, Juggler 协议)     │
└─────────────────────────────────────────────────┘

许可证

MIT

Available Tools

45 tools
auto_solve_captchaA

Auto-detect and solve a captcha challenge on the current page.

Wraps camoufox_captcha.solve_captcha (same library as project test.py). Probes the page for captcha indicators, clicks through the challenge, and verifies the protected content actually loaded.

Args: captcha_type: Captcha provider, e.g. "cloudflare". The library is future-proof; new providers (hcaptcha, recaptcha, ...) will be supported as camoufox_captcha adds them — pass the new name here. challenge_type: "auto" (recommended), "interstitial", or "turnstile". "auto" probes both variants and solves whichever is detected. ready_delay: Seconds to wait for the captcha iframe to mount before attempting to click. expected_content_selector: Optional CSS selector to wait for after solving. solve_attempts: Maximum solve attempts (passed to solver). solve_click_delay: Seconds to wait after clicking so the provider can validate the click. wait_checkbox_attempts: Maximum polls to wait for the checkbox to appear. wait_checkbox_delay: Seconds between checkbox-wait polls. checkbox_click_attempts: Maximum click attempts on the checkbox itself. attempt_delay: Seconds between top-level solve attempts. verify: Re-read page.content() after solving and confirm the provider's challenge marker is gone. Strongly recommended.

Returns: dict with detected, challenge_type_used, solved, attempts, verified, final_url, error (if any).

Inputs: verify, ready_delay, captcha_type, attempt_delay, +7 more.

auto_suggest_missing_propsA

Given a trace log (or just an error string), guess which props a Node-side VMP replay is missing.

This combines two signals:

  1. Every property the VMP read in the browser (from trace_vmp_for_sign)

  2. A curated set of high-frequency fingerprint properties that VMPs commonly read but that our default Node sandbox doesn't supply

Args: trace_log: the entries returned by trace_vmp_for_sign/get_tap_log (optional). If absent, only the curated list is returned. failed_replay_error: the error string from a previous failed replay_vmp_offline call (e.g. "ReferenceError: navigator is not defined"). Used to extract additional hints. supplied_env: dict of props you've already fed to replay. We won't suggest these.

Returns: dict with suggestions (list of {prop, type, default, hint}) and a sandbox_template you can paste into your VMP replay code to cover the missing props.

Inputs: trace_log, supplied_env, failed_replay_error.

capture_worker_jsA

Patch the page's Worker constructor and record every Worker created.

Use this when VMP bytecode is delivered via a Web Worker (e.g. the page does new Worker(blob:...) containing the VMP, then postMessage inputs and gets signs back). After the patch is installed, leave the page alone for duration_ms so VMP can spin up its workers.

Returns: dict with workers[] (id, url, source_preview if blob:), events[].

Inputs: clear, max_events, duration_ms.

capture_ws_payloadsA

Patch the page's WebSocket constructor and record every connection's send/recv.

Use this when VMP fetches its bytecode over WebSocket (e.g. an onmessage pushes an opaque blob that is then assembled into a Worker or eval'd).

Args: duration_ms: how long to keep the patch alive after install. url_filter: if set, only record connections whose URL contains this string. max_events: ring buffer cap.

Returns: dict with connections[] (url, sent[], received[]), events[].

Inputs: clear, max_events, url_filter, duration_ms.

check_environmentB

One-stop self-check of MCP environment, dependencies, and browser state.

Inputs: no named parameters.

clickC

Click on a page element.

Inputs: selector (required).

close_browserA

Close the Camoufox browser and release all resources.

Inputs: no named parameters.

compare_envC

Collect browser environment fingerprint data for comparison with Node.js/jsdom.

Inputs: properties.

cookiesD

Cookie management.

Inputs: action (required), name, domain, cookies_list. Returns: result

detect_captchaA

Detect whether a captcha challenge is currently shown.

Lightweight probe: returns detection flags without attempting to solve anything. Useful when you want to decide whether to call auto_solve_captcha.

Args: captcha_type: Captcha provider to probe, e.g. "cloudflare".

Returns: dict with provider-specific detection flags and the current URL. For "cloudflare" today: {turnstile: bool, interstitial: bool}. Other providers will report under their own keys.

Inputs: captcha_type.

detect_vmpA

Detect what kind of JavaScript VM Protection the page is running.

Returns a structured report with vmp_type in: - none: no VMP signals found - obfuscated: identifier rename + control-flow flattening + string arrays - string_eval: heavy use of eval / new Function to generate code - vm_dispatch: large object literal / opcode table / switch dispatch - wasm: WebAssembly / .wasm references

This is purely read-only: no hooks are installed, no scripts are rewritten.

Inputs: no named parameters.

disassemble_wasmA

Disassemble a WebAssembly binary to text (wat) + summarize imports/exports.

Args: wasm_source: - if source_kind=='base64': base64-encoded wasm bytes - if source_kind=='hex': hex-encoded wasm bytes - if source_kind=='url': a URL to fetch the wasm from (uses the active page so cookies / headers apply) source_kind: see above. generate_wat: if True, run wabt to produce WAT. Falls back to exports + imports only when wabt is unavailable. auto_install_wabt: if True and wabt is missing, attempt npm i -g wabt.

Returns: dict with imports, exports, optional wat text, and entry-function candidates (for replay_vmp_offline).

Inputs: wasm_source (required), source_kind, generate_wat, auto_install_wabt.

evaluate_jsC

Execute an arbitrary JavaScript expression in the page context and return the result.

Inputs: expression (required), await_promise.

export_stateC

Export the complete browser state to a JSON file.

Inputs: save_path (required).

get_console_logsC

Get console output collected from the page.

Inputs: clear, level, keyword. Returns: result

get_network_requestC

Get full details of a specific captured network request.

Inputs: request_id (required), include_body, max_body_size, include_headers.

get_page_infoA

Get current page URL, title, and viewport size.

Inputs: no named parameters.

get_request_initiatorC

Get the JS call stack that initiated a network request.

Inputs: request_id (required).

get_storageC

Get the contents of localStorage or sessionStorage.

Inputs: storage_type.

get_tap_logC

Read what was recorded by trace_vmp_for_sign.

Inputs: clear, limit.

hook_functionD

Hook or trace a function.

Inputs: function_path (required), mode, log_args, position, +6 more.

hook_jsvmp_interpreterC

Install a JSVMP runtime probe.

Inputs: mode, persistent, script_url, max_entries, +4 more.

import_stateC

Import browser state from a JSON file by creating a new context.

Inputs: state_path (required).

inject_hook_presetC

Inject a pre-built hook template for common reverse engineering tasks.

Inputs: preset (required), persistent.

instrumentationD

Inputs: action (required), tag, mode, clear, +16 more.

intercept_requestD

Intercept network requests matching a pattern.

Inputs: url_pattern (required), action, modify_body, mock_response, +1 more.

launch_browserA

Launch the Camoufox anti-detection browser.

The trio of i_know_what_im_doing=True + disable_coop=True + force_scope_access=True is critical for Cloudflare-style challenges: without them, Camoufox runs in a sandbox iframe and CF hands out a hard challenge with no solvable iframe. These match what the project's test.py smoke test uses.

Inputs: geoip, proxy, locale, os_type, +8 more.

list_network_requestsC

List captured network requests with optional filters.

Inputs: method, url_filter, status_code, resource_type, +1 more. Returns: result

list_trace_filesC

List all trace files on disk.

Inputs: limit.

network_captureD

Unified network capture control.

Inputs: action (required), url_pattern, capture_body.

query_trace_fileC

Query a specific historical trace file.

Inputs: file_path (required), mode, limit, bucket_ms, +2 more.

reloadA

Reload the current page, preserving any init scripts.

Inputs: wait_until.

remove_hooksC

Remove installed hooks and restore original objects.

Inputs: keep_persistent.

replay_vmp_offlineA

Run captured VMP code in headless Node and call the entry function.

Useful for verifying you've correctly extracted the signing algorithm: call the VMP's signing function with the inputs a real request would use, and check that the output matches what the browser actually sent.

Args: vmp_code: The JavaScript source that defines the VMP / sign function. entry: The name of the function exported on global that we should call. input: A dict to pass to the entry function. Will be JSON-serialized and re-parsed inside the Node sandbox. timeout_ms: VM timeout. JS that runs longer triggers a V8 timeout error. expected_sign: optional reference sign captured from the browser. When set and auto_diff is True, the response includes a structured diff (match / common_prefix_len / first_diff_idx). auto_diff: if True and expected_sign is set, compute a structured diff. supplied_env: optional dict merged into the sandbox before the VMP code runs. Use this to feed navigator.userAgent, screen.width, Date.now(), document.cookie etc. (see auto_suggest_missing_props).

Returns: dict with status, output, elapsed_ms, optional diff, and optional suggestion hint when outputs don't match.

Inputs: entry (required), input (required), vmp_code (required), auto_diff, +3 more.

reset_browser_stateC

Reset MCP-side browser residual state without closing the browser.

Inputs: clear_cookies, clear_storage, clear_active_routes, clear_network_capture, +1 more.

scriptsD

Script inspection.

Inputs: action (required), url, save_path. Returns: result

search_codeC

Search keyword in loaded scripts.

Inputs: keyword (required), script_url, max_results, context_chars, +1 more.

take_screenshotC

Take a screenshot of the current page or a specific element.

Inputs: selector, full_page.

take_snapshotB

Get the accessibility tree of the current page (token-efficient).

Inputs: no named parameters.

trace_property_accessC

Engine-level DOM property access tracing (JSVMP-undetectable).

Inputs: mode, limit, duration, bucket_ms, +3 more.

trace_vmp_for_signA

Install a signature-safe tap and record what the VMP reads.

Args: properties: list of property names to watch on navigator/screen/history/ location prototypes. If empty, uses a default high-signal set. trigger_js: optional JS expression to evaluate AFTER the tap is installed, to actually invoke the VMP (e.g. "sign(payload)"). max_entries: cap on the recorded log. track_calls: also instrument Date.now / etc. clear_log: clear any previous tap log first. wait_ms: extra delay after trigger_js before reading the log.

Returns: dict with the tap summary, count of recorded reads, and a condensed view of the VMP's reads (prop -> latest value preview).

Inputs: wait_ms, clear_log, properties, trigger_js, +2 more.

type_textC

Type text into an input field with realistic keystroke delays.

Inputs: text (required), selector (required), delay.

verify_signer_offlineA

Verify a signing function against known samples (offline, no browser needed).

Args: signer_code: JavaScript code that exports a signing function. Must be a function expression or arrow function: e.g. "(s) => mySign(s)" samples: List of samples, each with expected request/response pairs: [{"id": "r1", "input": {...}, "expected": {"X-Bogus": "..."}}]

Returns: dict with overall passed/failed, per-sample results, and first mismatch.

Inputs: samples (required), signer_code (required).

wait_forC

Wait for an element to appear or a network request matching a URL pattern.

Inputs: timeout, selector, url_pattern.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    C2.6/5.0

    Scored across 45 tools

    Disambiguation3/5

    Several tools overlap in purpose (e.g., multiple tracing/hooking tools like trace_vmp_for_sign, capture_worker_js, hook_function, hook_jsvmp_interpreter, trace_property_access). Navigate also duplicates captcha solving logic. Descriptions help differentiate but some boundaries remain unclear.

    Naming Consistency4/5

    Most tools follow a clear verb_noun pattern (e.g., launch_browser, auto_solve_captcha, trace_vmp_for_sign). A few single-word tools (cookies, scripts) and an empty-name tool (instrumentation) slightly break consistency, but overall naming is predictable.

    Tool Count3/5

    45 tools is high for a single server. While the scope is broad (browser automation, captcha solving, VMP analysis, state management), many tools are granular and could be consolidated (e.g., multiple trace/capture tools). The number feels slightly excessive for the purpose.

    Completeness4/5

    The server covers a comprehensive workflow for analyzing JS VM protection: detection, tracing, capture, replay, offine verification. It also includes browser state management, network interception, and screenshots. Minor gaps exist (e.g., no DOM manipulation beyond click/type), but overall coverage is strong.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      D
      maintenance
      An MCP server for JavaScript reverse engineering that enables AI to perform browser debugging, script analysis, and automated hook injection. It streamlines complex workflows like deobfuscation, network tracing, and risk assessment through direct browser integration.
      35
      31 npm
      1,054
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      A Model Context Protocol (MCP) server that detects cryptographic algorithms, identifies obfuscation, reconstructs standalone implementations, generates SDKs, and bypasses anti-debugging.
      6
      1
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      MCP server for agent-piloted browser automation that clears Cloudflare, providing multi-session parallel Chromes, persistent profiles, stealth features, credential vault, and vision-first clicking.
      89
      90 PyPI
      9
      Apache 2.0