js-reverse-mcp
MCP ServerFree为 AI Agent 设计的 JS 逆向 MCP Server,内置反检测,基于 chrome-devtools-mcp 重构 | JS reverse engineering MCP server with agent-first tool design and built-in anti-detection. Rebuilt from chrome-devtools-mcp.
Capabilities12 decomposed
browser automation via chrome devtools protocol with anti-detection
Medium confidenceExecutes JavaScript code in a real Chrome/Chromium browser context through the Chrome DevTools Protocol (CDP), with built-in anti-detection mechanisms to evade bot-detection scripts. Implements stealth headers, user-agent spoofing, and WebDriver property masking to appear as legitimate browser traffic rather than automated tooling. Rebuilt from chrome-devtools-mcp architecture to optimize for AI agent workflows.
Integrates anti-detection evasion directly into MCP server layer (stealth headers, WebDriver masking, user-agent rotation) rather than requiring separate proxy/VPN setup, enabling AI agents to handle detection-aware scraping natively without external infrastructure
Differs from Puppeteer/Playwright by bundling anti-detection as first-class concern in MCP protocol, vs requiring manual stealth plugin configuration; more agent-friendly than raw CDP clients because it abstracts detection complexity into tool definitions
mcp-native tool schema generation for browser operations
Medium confidenceAutomatically generates Model Context Protocol (MCP) tool definitions from browser capabilities, exposing Chrome DevTools operations as callable functions with strict JSON schemas. Handles parameter validation, return type serialization, and error mapping to MCP protocol standards. Enables AI agents to discover and invoke browser operations through standard MCP tool-calling interface without manual schema authoring.
Generates MCP tool schemas specifically optimized for agent workflows (with clear intent descriptions, parameter constraints, and error handling) rather than generic CDP method exposure, making browser operations first-class agent capabilities
More agent-native than raw CDP clients or Puppeteer because it abstracts browser operations into MCP tool protocol, enabling multi-step agent reasoning about browser tasks vs imperative script execution
error handling and recovery with automatic retry logic
Medium confidenceImplements automatic retry logic for transient failures (network timeouts, element not found, navigation failures) with exponential backoff. Provides detailed error context (error type, stack trace, recovery action) for agent decision-making. Supports custom retry predicates for domain-specific failure handling. Distinguishes between recoverable and fatal errors.
Provides agent-native error handling with automatic retry and exponential backoff, vs raw CDP which fails immediately on transient errors requiring agents to implement retry logic
More resilient than Puppeteer's default error handling because it automatically retries transient failures with configurable backoff; enables agents to focus on logic vs error recovery
performance monitoring and resource usage tracking
Medium confidenceTracks browser performance metrics (page load time, JavaScript execution time, network latency) and resource usage (memory, CPU, network bandwidth). Provides performance data in structured format for agent analysis. Enables agents to make performance-aware decisions (skip slow pages, optimize workflows). Supports performance budgets and alerts.
Provides agent-native performance monitoring with structured metrics and budget tracking, enabling agents to optimize workflows based on performance data; vs raw CDP which requires agents to manually collect and analyze performance metrics
More agent-friendly than manual CDP performance API calls because it aggregates metrics and provides structured output; enables performance-aware agent decisions vs blind optimization
javascript code execution in browser context with result serialization
Medium confidenceExecutes arbitrary JavaScript code within a real browser's JavaScript engine (V8 via Chrome), capturing return values, console output, and errors, then serializes results back to JSON for agent consumption. Handles async/await execution, Promise resolution, and complex object serialization. Provides execution timeout and memory limits to prevent runaway scripts from blocking the MCP server.
Executes code in real V8 engine (Chrome) rather than Node.js, capturing browser-specific APIs (DOM, fetch, localStorage) and rendering context; includes automatic serialization of results to JSON with timeout/memory guardrails for safe agent execution
More faithful to real browser behavior than Node.js eval() because it uses actual Chrome V8 with DOM APIs; safer than raw eval() because it enforces execution timeouts and memory limits preventing agent-induced DoS
dom querying and element interaction with css selectors
Medium confidenceProvides high-level DOM query operations (select, find, filter) using CSS selectors, with built-in element interaction methods (click, type, scroll, hover). Abstracts low-level CDP commands into agent-friendly operations that return structured element metadata (text, attributes, position). Handles dynamic element waiting and stale element recovery.
Wraps CDP element interaction commands into agent-native tool definitions with automatic element waiting and stale element recovery, vs raw CDP which requires agents to handle timing and retry logic manually
More agent-friendly than Puppeteer's page.$(selector) because it returns structured metadata and handles common failure modes (stale elements, visibility checks) automatically; simpler than raw CDP for agents unfamiliar with low-level browser protocol
page navigation and history management with wait conditions
Medium confidenceHandles page navigation (goto, reload, back, forward) with configurable wait conditions (wait for load, network idle, specific elements). Tracks navigation history and page state, enabling agents to understand page transitions. Implements timeout handling for navigation failures and provides detailed navigation metadata (URL, title, load time).
Provides agent-friendly navigation abstraction with built-in wait condition handling (load, idle, element presence) and timeout management, vs raw CDP which requires agents to manually poll for page readiness
Simpler than Puppeteer's page.goto() for agents because it abstracts wait condition complexity; more reliable than raw CDP navigation because it handles common failure modes (slow loads, redirects) with configurable timeouts
screenshot capture and visual element detection
Medium confidenceCaptures full-page or viewport screenshots as base64-encoded PNG/JPEG, with optional element highlighting and annotation. Provides visual feedback for agent workflows, enabling agents to understand page layout and validate visual state. Supports viewport size configuration and device emulation for responsive testing.
Integrates screenshot capture as first-class MCP tool with element highlighting and viewport control, enabling agents to make visual decisions; vs raw CDP which returns raw image data without agent-friendly metadata
More agent-native than Puppeteer screenshots because it provides structured metadata (element positions, viewport info) alongside image data; enables visual reasoning in agent chains vs text-only automation
network request interception and response mocking
Medium confidenceIntercepts HTTP/HTTPS requests at the network layer (via CDP Network domain), enabling agents to inspect, modify, or mock responses. Supports request filtering by URL pattern, method, and headers. Allows response injection (mock data, error responses) without modifying page code. Useful for testing error scenarios, bypassing API calls, or injecting test data.
Provides agent-native network mocking through MCP tool definitions with pattern-based request filtering, vs raw CDP which requires agents to manage interception state and pattern matching manually
More agent-friendly than Puppeteer's request interception because it abstracts pattern matching and response injection into simple tool parameters; enables agents to test error scenarios without code modification
cookie and local storage management
Medium confidenceManages browser cookies and localStorage/sessionStorage with get/set/delete operations. Enables agents to persist authentication state, manage session tokens, and simulate user preferences. Supports cookie attributes (domain, path, expiry, secure, httpOnly) for realistic cookie handling. Useful for maintaining logged-in state across multiple page navigations.
Exposes cookie and storage management as agent-callable MCP tools with attribute control, enabling agents to manage authentication state without JavaScript code; vs raw CDP which requires agents to construct cookie objects manually
More agent-friendly than Puppeteer's page.cookies() because it provides high-level get/set/delete operations; enables persistent authentication workflows vs stateless scraping
page content extraction with structured data parsing
Medium confidenceExtracts page content (HTML, text, structured data) with optional parsing into structured formats (JSON, CSV). Supports CSS selector-based extraction, XPath queries, and JSON-LD/microdata parsing. Handles encoding detection and text normalization. Provides both raw HTML and parsed structured output for agent consumption.
Provides agent-native content extraction with automatic structured data parsing (JSON-LD, microdata) and format conversion, vs raw CDP which returns only raw HTML requiring agents to parse manually
More agent-friendly than BeautifulSoup or Cheerio because it extracts from rendered DOM (post-JavaScript) vs static HTML; supports semantic data extraction (JSON-LD) vs regex-based parsing
browser session persistence and state management
Medium confidenceManages browser session lifecycle (create, reuse, destroy) with optional state persistence across restarts. Enables agents to maintain browser context (cookies, localStorage, history) between tool calls. Supports session pooling for concurrent agent tasks. Provides session metadata (creation time, last activity, resource usage) for monitoring.
Provides agent-native session management with automatic state persistence and pooling support, enabling long-running agent workflows without manual state tracking; vs raw CDP which creates new browser instance per connection
More efficient than creating new browser instances per task because it reuses sessions with persistent state; enables multi-agent collaboration through session pooling vs isolated browser instances
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with js-reverse-mcp, ranked by overlap. Discovered automatically through the match graph.
chrome-devtools-mcp
Chrome DevTools for coding agents
chrome-devtools-mcp
MCP server for Chrome DevTools
bb-browser
Your browser is the API. CLI + MCP server for AI agents to control Chrome with your login state.
Playwright MCP Server
Automate browsers and run web tests via Playwright MCP.
playwright-mcp
Playwright MCP server
Bright Data
** - Discover, extract, and interact with the web - one interface powering automated access across the public internet.
Best For
- ✓AI agents performing web scraping and data extraction from protected sites
- ✓Teams building reverse-engineering tools that need to bypass anti-bot measures
- ✓Developers testing JavaScript execution in realistic browser conditions
- ✓AI agent frameworks (Claude, custom LLM agents) that support MCP tool calling
- ✓Teams building agent-first automation platforms requiring browser interaction
- ✓Developers integrating browser automation into larger MCP tool ecosystems
- ✓Scraping agents operating on unreliable networks or flaky websites
- ✓Long-running automation workflows requiring resilience to transient failures
Known Limitations
- ⚠Anti-detection is cat-and-mouse game — sophisticated detection systems may still identify automation
- ⚠Requires local Chrome/Chromium installation, cannot run in serverless environments without container support
- ⚠Performance overhead from anti-detection mechanisms adds 500ms-2s per request compared to raw CDP
- ⚠Limited to single-threaded execution per browser instance; concurrent tasks require multiple browser processes
- ⚠Schema generation limited to predefined browser operations; custom CDP commands require manual schema definition
- ⚠No runtime type coercion — agents must pass correctly-typed parameters or calls fail
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Repository Details
Last commit: Mar 24, 2026
About
为 AI Agent 设计的 JS 逆向 MCP Server,内置反检测,基于 chrome-devtools-mcp 重构 | JS reverse engineering MCP server with agent-first tool design and built-in anti-detection. Rebuilt from chrome-devtools-mcp.
Categories
Alternatives to js-reverse-mcp
Are you the builder of js-reverse-mcp?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →