Check whether the Chrome extension and native host are connected.

List current scriptable Chrome tabs. Use before selecting a tab ID.

Open an HTTP, HTTPS, file, or about:blank URL in Chrome.

Activate a Chrome tab and focus its window.

Close a tab only when it was created by Chrome Agent Bridge in the current extension session.

Navigate an existing tab to an HTTP, HTTPS, file, or about:blank URL.

Read visible page text plus semantic interactive elements with short-lived refs. Use a ref with browser_act, then take a fresh snapshot after every action.

Capture the visible viewport of a Chrome tab. This activates the tab.

Perform one atomic high-level action. Prefer a ref from the latest browser_snapshot. Clicks run a complete CDP mouse sequence inside one request; press supports common navigation keys; select is for native controls.

Compatibility selector-based click. New workflows should use browser_snapshot refs with browser_act.

Compatibility selector-based fill. New workflows should use browser_snapshot refs with browser_act.

Long-poll tab created, updated, removed, and activated events after a cursor.

Start a tab-scoped, metadata-only Chrome network monitor. Pass rawSessionId to reuse that Raw CDP attachment instead of attaching a second debugger. Headers and bodies are never returned.

Read sanitized request, response, completion, failure, and WebSocket lifecycle metadata after a cursor. Completion and failure events include method, status when known, and durationMs.

Stop a network monitor and release its resources. It detaches Chrome only when the monitor owns the attachment; a reused Raw session remains attached.

Attach an unrestricted Chrome DevTools Protocol session to one tab. Set captureEvents=false when only commands plus a sanitized network projection are needed; captured Raw events may expose credentials and private data.

Send any CDP method and JSON params without a method allowlist or response sanitization. Use targetSessionId for a child target previously attached within this Raw CDP session.

Read original CDP event methods, source targets, and params without field sanitization. Results may contain secrets or private browsing data.

Detach an unrestricted CDP session from its tab and release child-target routing state.

Parse supplied JavaScript locally and summarize structure, calls, complexity, globals, and optional security signals. No browser session is required.

Find AST nodes by Acorn node type and optional property filters.

Score supplied JavaScript for common obfuscation signals using local deterministic heuristics.

Conservatively restore a canonical while(true)+switch dispatcher when its static order can be proven.

Replace statically resolvable literal array member accesses with their literal values.

Produce a bounded intra-file source, assignment, sink, and shallow taint-path projection.

Run a deterministic static heuristic scan for dynamic code, injection sinks, weak randomness, hard-coded credentials, and related risks.

Identify common cryptographic algorithms and operations referenced by supplied JavaScript.

Run conservative constant folding, dead-branch removal, string-array decoding, and optional control-flow deflattening.

Fold safe literal binary expressions and prune literal boolean branches without executing supplied code.

Preview supported deterministic JavaScript transforms and return a bounded line diff.

Create an in-memory named transform chain for this MCP process.

Apply inline transforms or a previously saved transform chain to supplied JavaScript.

Run a supplied function against deterministic string inputs in a bounded Worker and vm context. This is defense in depth, not a security sandbox.

Run two supplied implementations against identical inputs in separate bounded Workers and compare outputs.

Run a reproducible local binary transform pipeline over base64 input.

Detect common binary formats from magic bytes, text signatures, and entropy.

Decode between base64, hex, UTF-8, and JSON representations.

Encode UTF-8, hex, base64, or JSON input into base64, hex, or UTF-8.

Calculate Shannon entropy and byte-frequency distribution for a bounded payload.

Recursively decode schema-less Protobuf wire fields from base64 input.

Parse one or more raw HTTP/2 frames from hex, including common frame payloads.

Calculate an Akamai-style deterministic fingerprint from captured HTTP/2 preface frames.

Split gRPC or gRPC-Web length-prefixed messages and trailer frames.

Build deterministic gRPC or gRPC-Web length-prefixed messages.

Classify bounded hex payload samples as HTTP, HTTP/2, TLS, DNS, SSH, WebSocket, or unknown.

Infer constant, variable, and variable-tail byte regions across repeated hex payloads.

Infer a deterministic state graph from direction, protocol fingerprint, and payload prefix.

Export inferred fields as a compact proto-like schema for review.

Render an inferred state machine as Mermaid stateDiagram-v2 text.

Parse an RFC 1035-style DNS payload from hex, including compressed names and common addresses.

Parse an HTTP/1 request or response start line, headers, and bounded body representations.

Fingerprint one raw hex payload without sending network traffic.

Inspect a WASM module's sections, imports, exports, names, and producers using a local dependency-free structural parser.

Extract printable strings by WASM section and classify URLs, hashes, base64, and paths.

Enable Debugger on an existing Raw session, collect script metadata, and optionally fetch bounded script sources into the local MCP process.

Search script sources already collected in this MCP process by literal text or regular expression.

Find a named function in collected scripts and recursively project statically named call dependencies.

Evaluate a bounded Webpack module-table collector in the selected Raw target. This modifies the chunk array only by appending a runtime probe.

Discover sourceMappingURL values from Debugger.scriptParsed events and collected script tails.

Parse supplied source-map JSON, or fetch a map through the selected page's authenticated fetch context before parsing it locally.

Summarize mapped original lines and sources for a parsed source map.

Map a one-based generated line and zero-based column back to an original source position.

Reconstruct safe relative source paths and optionally return bounded sourcesContent from a parsed source map.

Parse compatible mappings and preserve ECMA-426 debug ID and scope-field metadata.

Compare source membership and sourcesContent hashes between two locally parsed source maps.

Enable or disable the Debugger domain on an existing Raw CDP session.

Request a pause at the next JavaScript statement.

Resume a paused JavaScript debugger.

Set a breakpoint at a script location and resume execution.

Step into, over, or out from a paused JavaScript frame.

Add, remove, or list source breakpoints and manage exception, XHR, or event-listener breakpoints.

Return the most recently captured Debugger.paused call stack for a Raw session.

Try CDP WASM disassembly for a script and fall back to bounded source-line projection.

Evaluate an expression globally or on one paused call frame. This executes code in the selected page target.

Poll Raw CDP events until Debugger.paused is observed or timeout expires.

Wait for a pause and capture the call stack plus optional bounded top-frame scope variables.

Return the locally cached pause reason and frames without waiting for new events.

Read properties for a Runtime remote object ID in the selected Raw target.

Recursively expand a bounded Runtime object graph from an object ID.

Save, list, load, or export in-memory debugger metadata for one Raw session. Loading never silently recreates breakpoints.

Add, remove, clear, list, and evaluate watch expressions on a global or paused frame.

Append regular-expression patterns and update Debugger.setBlackboxPatterns.

Blackbox common framework and dependency script patterns.

List blackbox patterns maintained for a Raw session.

Return the selected target's CDP Performance.getMetrics values.

Start or stop precise JavaScript coverage and optional CSS rule usage tracking.

Capture HeapProfiler snapshot chunks from Raw events and write a private local artifact. Fails rather than returning an incomplete snapshot when the Raw buffer truncates.

Start or stop CDP Tracing and write bounded events to a private local artifact.

Start or stop the CDP CPU profiler and return the profile plus bounded hotspots.

Start or stop CDP HeapProfiler allocation sampling.

Enable Runtime, consume Raw exception events, and return bounded unsanitized exception details.

Read one response body by its original CDP requestId. The result is unsanitized and may contain secrets or private data.

Consume unsanitized Raw Network events and summarize counts, status, types, bytes, failures, and duration.

Write captured unsanitized requests, headers, and post data to a private local HAR artifact. Requires explicit confirmation.

Extract authentication headers and associated cookies from captured Raw events. Requires explicit confirmation and returns secrets.

Enable, poll, continue, fail, fulfill, list, or disable explicit CDP Fetch interception. Paused requests remain blocked until handled or interception is disabled.