camoufox-versatile-mcp
Provides tools for automatically detecting and solving Cloudflare captcha challenges (Turnstile and Interstitial) during browser navigation.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@camoufox-versatile-mcp Open https://challenging-site.com and auto-solve the captcha"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
camoufox-versatile-mcp
基于反指纹浏览器(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-mcpAI 会自动完成以下全部步骤:
git clone或pip install克隆安装项目读取
pyproject.toml确认依赖配置 Cursor 的
mcpServers(自动写入settings.json)启动 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"]
}
}
}启动参数
参数 | 说明 |
| 无头模式运行 |
| 代理服务器,如 |
| 启用 GeoIP 推理(根据代理 IP 自动设置地理位置) |
| 启用拟人化鼠标移动 |
| OS 指纹: |
| 浏览器语言,如 |
Related MCP server: crypto-reverse-mcp
工具一览(共 45 个)
浏览器控制(11 个)
工具 | 说明 |
| 启动 Camoufox 反指纹浏览器(含 i_know_what_im_doing + disable_coop + forceScopeAccess 默认三件套) |
| 关闭浏览器 |
| 导航到指定 URL(支持 |
| 刷新页面 |
| 截图 |
| 获取页面无障碍树 |
| 点击元素 / 输入文本 |
| 等待元素出现或 URL 匹配 |
| 获取当前页面信息 |
| 滚动页面 |
| 前进 / 后退 |
通用 Captcha 挑战自动通过(2 个)⭐
工具 | 说明 |
| 检测当前页面是否有 captcha 挑战(不点击) |
| 自动检测 + 通过 captcha 挑战( |
支持
cloudflare的 Turnstile 和 Interstitial 两种模式,captcha_type参数预留扩展位(hcaptcha、recaptcha 等)。注意:非标准 Cloudflare 挑战(如自定义 WAF checkbox)需要额外定制化处理。
JS 执行与调试(1 个)
工具 | 说明 |
| 在页面上下文执行任意 JS 表达式 |
脚本分析(2 个)
工具 | 说明 |
| 脚本管理: |
| 搜索关键词 |
Hook 与追踪(4 个)
工具 | 说明 |
| Hook 或追踪函数 |
| 注入预置 Hook(xhr / fetch / crypto / websocket / debugger_bypass / cookie / runtime_probe) |
| 移除所有 Hook |
| 注入自定义 JS Hook |
网络分析(5 个)
工具 | 说明 |
| 网络捕获控制 |
| 列出已捕获的请求 |
| 获取请求完整详情 |
| 获取请求发起的 JS 调用栈 |
| 拦截请求 |
JSVMP 逆向分析(5 个)
工具 | 说明 |
| JSVMP 运行时探针 |
| 源码级插桩 |
| 浏览器环境指纹收集 |
| 检测页面使用了哪种 VMP 保护(obfuscated / string_eval / vm_dispatch / wasm) |
| 签名安全 Tap:追踪 VMP 读取了哪些 fingerprint 属性 |
Cookie 与存储(4 个)
工具 | 说明 |
| Cookie 管理 |
| 获取 localStorage / sessionStorage |
| 导出 / 导入浏览器状态 |
验证(1 个)
工具 | 说明 |
| 验证指纹是否满足目标网站要求 |
环境感知(1 个)
工具 | 说明 |
| 获取当前浏览器环境信息(OS、UA、屏幕、语言等) |
JSVMP 离线重放管线(8 个)🆕
工具 | 说明 |
| 读取 trace_vmp_for_sign 记录的 Tap 日志 |
| 将 WASM 字节码反汇编为 WAT + 导入/导出函数列表 + 入口函数猜测 |
| 劫持 |
| 劫持 |
| 根据失败日志 + trace_log 推荐缺失的 fingerprint prop |
| 在 Node 沙箱中离线重放 VMP 代码(增强版:支持 |
| 签名安全 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 toolsauto_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:
Every property the VMP read in the browser (from trace_vmp_for_sign)
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
Scored across 45 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for ScanMalware.com URL scanning, malware detection, and analysis.
Web scraping MCP server — scrape, extract structured data, screenshot any site with anti-bot bypass.
Cloudflare Workers MCP server: domain-intel
Related MCP Servers
- AlicenseCqualityDmaintenanceAn 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.3531 npm1,054Apache 2.0
- AlicenseAqualityDmaintenanceA Model Context Protocol (MCP) server that detects cryptographic algorithms, identifies obfuscation, reconstructs standalone implementations, generates SDKs, and bypasses anti-debugging.61MIT
- AlicenseNot gradedqualityDmaintenanceAn AI-native JavaScript reverse engineering MCP server for debugging, locating, saving, and replaying web page JavaScript behavior. Includes anti-detection mechanisms to handle strong anti-bot sites.Apache 2.0
- AlicenseCqualityBmaintenanceMCP server for agent-piloted browser automation that clears Cloudflare, providing multi-session parallel Chromes, persistent profiles, stealth features, credential vault, and vision-first clicking.8990 PyPI9Apache 2.0