devcdp
DevCDP is an MCP server that gives an AI assistant real Chrome DevTools access to debug live web apps — reading the console, watching network traffic, querying the DOM, resolving source maps, setting breakpoints, inspecting scopes, and collaborating with a human.
Connection & session management: attach to/claim Chrome tabs, list tabs and sessions, launch isolated browsers or windows, and cleanly disconnect.
Console & runtime: read console logs/errors, evaluate JavaScript, batch-evaluate expressions, and clear buffers.
Network: list/filter requests with timing, status, bodies, headers, and post data; wait for specific requests; fetch full response bodies.
DOM & UI automation: query elements with visibility/geometry/computed styles, list frames, get HTML and mutation history, detect dialogs, and click/hover/drag/scroll/type/fill/select/check/upload/wait-for/inspect UI.
Sources & debugging: list/search scripts and original source-map files, read script/file contents, set breakpoints by file/line or function, list/remove breakpoints, pause/step/resume, inspect scope and evaluate at a paused frame, and get auto-captured pause snapshots.
Observation & collaboration: see user actions, ask the user to perform actions with confirmation, view an activity timeline, and notify the user via the on-page badge.
Project discovery & memory: discover the app's framework/routing/interactive surface and backend API, search project docs, and record/recall learned fixes across sessions.
Configuration: view effective settings, initialize editable settings files, and inspect connection/status.
Provides full browser DevTools access (console, network, DOM, breakpoints, step-through debugging) via Chrome's remote debugging protocol.
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., "@devcdp debug why the Save button does nothing"
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.
DevCDP
Real Chrome DevTools access for an AI assistant, over MCP. Your assistant reads the console, watches the network, queries the DOM, resolves source maps, sets breakpoints and inspects live variables — so it can tell you why something broke instead of guessing from a pasted error.
Works with any assistant that speaks MCP, and with any web app: nothing about a particular framework, product or company is built in.
74 tools — see docs/TOOLS.md for the full reference, generated from the server itself, and docs/PERFORMANCE.md for measured token costs and how to lower them.
What it does
Console | Logs, warnings and uncaught exceptions with file, 1-based line and stack. |
Network | Every request from the moment it attaches — method, status, timing, size, initiator, and response bodies on request. |
DOM | Selector queries with real visibility and geometry, named computed styles, mutation history, iframe support, and structural dialog detection. |
Sources | Loaded scripts, plus original pre-bundling files recovered from source maps — including external |
Debugger | Breakpoints on original files by original line, stepping, and scope inspection that expands nested objects instead of printing |
Discovery | Asks the app what it is: framework, routing, working selectors for its buttons and fields, its backend API surface, and your project's own docs. |
Collaboration | You can take over at any time; what you click, choose and type is recorded and readable by the assistant. |
Four things it is careful about
It never fakes success. A breakpoint that cannot bind says bound: false and
explains why. A body Chrome has discarded says so. A capture from a pause that has
already resumed is marked stale. Every failure is {ok: false, code, message, hint}
with the next action named.
It tells you where its knowledge ends. Chrome cannot replay console history to a debugger that attaches later, so attaching reports exactly that rather than presenting an empty buffer as "no errors".
It cannot be stranded. Every call into the page is bounded on our side —
Runtime.evaluate's own timeout is enforced by the renderer, which is useless when
the renderer is what is stuck. A page wedged in an infinite loop fails in seconds
with the recovery path named, and DevCDP will abort the runaway script and retry by
itself.
It never leaves your app frozen. Breakpoints capture what you need and then
resume on their own. A pause held deliberately is still released after
maxPauseMs, and everything is cleaned up on disconnect.
Related MCP server: cdp-tools-mcp
Install
Requirements: Node 18+, Chrome, and an MCP-capable assistant.
Pick whichever fits your client. All of them run the same server on your machine; nothing is hosted.
Any MCP client, from npm. Add to the client's MCP config:
{ "mcpServers": { "devcdp": { "command": "npx", "args": ["-y", "devcdp"] } } }On native Windows some clients need "command": "cmd", "args": ["/c", "npx", "-y", "devcdp"].
Claude Code, as a plugin (server plus a skill that tells Claude when to reach for which tool):
/plugin marketplace add Dayananda-D/DevCDP
/plugin install devcdp@devcdpCursor: ,
or add the JSON above to
~/.cursor/mcp.json.
Gemini CLI, as an extension that also carries the usage guidance:
gemini extensions install https://github.com/Dayananda-D/DevCDPopencode: opencode mcp add, or in opencode.json:
{ "mcp": { "devcdp": { "type": "local", "command": ["npx", "-y", "devcdp"], "enabled": true } } }Codex (CLI, desktop, VS Code extension), as a plugin:
codex plugin marketplace add Dayananda-D/DevCDPVS Code: Install in VS Code, or run MCP: Add Server, choose NPM Package,
and enter devcdp. Copilot CLI: /mcp add with command npx -y devcdp. DevCDP is in
the official MCP Registry; the picker
inside VS Code shows GitHub's curated subset of that registry, which is a separate listing.
From source, with the setup wizard that also writes usage guidance into your assistant's instructions file: see Setup, next.
Then launch Chrome with remote debugging (debug-chrome.bat, or
chrome --remote-debugging-port=9222 --user-data-dir=<a separate profile>), open your
app, and describe the bug.
Setup
1. node initialize_MCP.js (or double-click initialize_MCP.bat)
2. Fully quit and reopen your assistant
3. Double-click debug-chrome.bat, open your app
4. Describe the bugThe wizard detects installed editors, writes the right config shape for each, and drops a launcher. It never overwrites a config file it cannot parse — it prints the snippet to paste instead — every write is atomic with one timestamped backup, and duplicate registrations from older installs are removed. That path is covered by 23 tests, because getting it wrong damages your machine rather than just failing.
Settings
Everything is optional. Ask the assistant to run devcdp_settings to see the
effective values and where each came from, or devcdp_settings_init to write an
annotated file you can edit.
Files are merged, later winning, so an install-wide baseline can be overridden per project:
<install>/devcdp.settings.json or <install>/settings.json
<cwd>/.devcdp/settings.json
<cwd>/devcdp.settings.jsonthen DEVCDP_* environment variables, then tool arguments. Comments and trailing
commas are tolerated.
Setting | Default | |
|
| show live status messages |
|
| how long, how visible, how many |
|
| the tab indicator and its breathing border |
|
| where the overlay parks. Drag the chip to move it anywhere; that position is remembered per origin. Messages travel with it, so |
|
| show where interaction happens, and what was inspected |
|
| how long an indicator stays up without hearing from its session, before removing itself |
|
| mark and hold tabs the app opens for itself, so a popup is never an unmarked blind spot |
|
| or |
|
| leave off: it hides the CORS bugs you would be debugging |
|
| extra Chrome flags |
|
| liveness ceilings |
|
| autonomous pause control |
|
| always-on capture of typed values |
| auto | where to read your project's README and docs |
|
| pool learned fixes across a team |
|
| one tab group per session, or |
docsRoot and sharedMemoryDir are the two worth setting: the first lets the
assistant learn your domain vocabulary, the second is what makes "the team's fixes
accumulate" actually true.
Multiple sessions at once
Several agents can debug on one machine safely. Each session claims a tab in a
registry under ~/.devcdp/registry/, taken atomically so two processes cannot win
the same tab. A session that dies stops heartbeating and its claim is reaped, so
nothing stays wedged.
A new session gets an unclaimed tab; if all are taken it opens its own — on the page you wanted, not blank, and it says why.
Reloading your assistant briefly overlaps two server processes, so a short grace period lets the departing one release its tab and the new one simply reattaches.
browser: 'new'launches a separate Chrome, own port and profile.window: 'new'gives the session its own browser window.sessions_listshows which session holds which tab.
Knowing which tab is in use
Every claimed tab carries a 1px edge border and a small identity chip. The border tells you who is driving:
breathing blue glow — DevCDP is working
still, green — it has handed control to you
still, red — something failed
Three states, three colours, and each colour means exactly one thing regardless of how many sessions are running. Sessions are told apart by the chip text and by their own Chrome tab group — not by hue, which would turn the border into a puzzle when the only thing worth knowing at a glance is whether the tab is waiting for you.
Tabs the app opens for itself — window.open, target="_blank", a detail screen
in its own window — are marked and held too, labelled "opened tab". devtools_status
lists them under tabsAppOpened, with the call that switches to one.
The indicator cannot outlive the session that drew it. A normal finish — you close
the assistant, it disconnects, the session ends — removes the border immediately. If the
server is killed and never gets to clean up, the overlay notices it has stopped hearing
from its session and removes itself within ownerTimeoutMs (45s), taking the tab out of
its group with it. Either way, a border on screen means a session is genuinely there. For
one left behind by an older build, node scripts/sweep.mjs clears any that no live
session owns (--dry to look first).
Status messages appear as translucent, self-fading toasts. A ring follows pointer activity and a ripple marks each click, so an agent's actions are followable. When the debugger pauses, Chrome's own "Paused in debugger" banner appears — browser UI, adding nothing to your page.
None of it can intercept a click: the whole layer is pointer-events: none except
the confirmation button during a handover, which is 91×24px. There is a test that
fires real mouse events through it.
Real Chrome tab groups are drawn by the bundled extension, which puts each session's
tabs in a titled blue group. Chrome will not let a tool install an extension for you —
branded Google Chrome ignores --load-extension ("not allowed in Google Chrome", from its
own log) and does not expose Extensions.loadUnpacked over the debugging port — so pick
one of:
No manual step: point
chromePathat Chromium or Chrome for Testing. Those builds allow the switch, so the extension loads itself and grouping just works. If such a binary is already on your machine,devtools_statustells you where it is.Branded Chrome: install it once —
chrome://extensions→ Developer mode → Load unpacked → selectextension/. The debug profile is persistent and shared bydebug-chrome.batand DevCDP's own launcher, so once is once.
devtools_status.tabGrouping reports whether the tab is actually in a group, and when it
is not, whether that is because no extension is installed or because an installed one
failed — with the error. Nothing else depends on grouping: the border, the chip and
window:'new' all work without it.
Working with the assistant
You do not have to wait to be asked. Click, type, choose — it is recorded, and the
assistant reads it with session_get_user_actions: which element, which option,
and the value you typed.
Ctrl+Shift+D in the tab hands control to you explicitly. That also opens the window in which typed values are captured, so "use this reference" reaches the assistant. Outside that window values stay private, and password-like fields are redacted either way.
When the assistant needs something only you can do, it asks on the page and waits for the I've done it ✓ button. That button is the only unambiguous signal — Chrome reports automation input as trusted too, so an action cannot be proven human, and the tools say so rather than pretending.
A typical investigation
"The save button does nothing. Find the exact line."devtools_connect— attaches, claims the tab, marks itsource_search("save")— finds the handler by content, no path neededdebugger_set_breakpoint(file, line)— repliesbound: truethe click is triggered
debugger_get_capture— scope, console and network from the pause, one callthe answer is a value that was actually observed, at a line that actually exists
Breakpoints resume themselves, so the click that tripped one still completes.
When you know the function but not the file — which is the usual case with a framework —
debugger_set_breakpoint_at_function("app.store.save") asks the engine where that
function was defined and breaks at its first statement. Searching for a name in source
text is unreliable: a function assigned as Foo.bar = function cannot be found by
searching "bar: function", and that query happily returns unrelated methods on other
classes instead.
A capture stays small even on a framework object graph: the variable that matters is
printed, and anything too large says what it is ("constructor", 77747 bytes expanded)
so you can read just the part you want with debugger_evaluate_at_frame.
Security
The launcher uses a separate Chrome profile, so your everyday browsing is untouched, and leaves web security enabled — disabling it hides exactly the cross-origin failures you would be debugging.
Typed values are not recorded unless you enable it or are actively collaborating, and password-like fields stay redacted regardless.
Remote debugging gives full control of the browser profile to anything that can reach the port. Use the debug profile for development, not for personal accounts.
Layout
index.js entry point
server.js shim for older configs pointing here
src/
core/ config, context, buffers, structured errors, tool registry
cdp/ connection, target selection, session claim registry, launching
browser/ the injected in-page agent
debug/ source maps, scope expansion
store/ learned-memory store
tools/ one module per tool group
extension/ companion extension for Chrome tab groups
plugins/devcdp/ Claude Code plugin: manifest, launcher, skill (generated)
server.json MCP Registry manifest; must agree with package.json
scripts/gen-docs.mjs regenerates docs/TOOLS.md and the plugin skill
docs/TOOLS.md full tool reference (generated)
docs/PUBLISHING.md how each marketplace listing is made and kept current
test/
validate.mjs offline checks, no browser needed
installer.test.mjs the setup wizard, against real files
integration.mjs real Chrome against a fixture app
fixture-app/ small app with a staged bug and a real source map
BACKLOG.md every defect found, its fix, and what remainsWorking on DevCDP
node scripts/call.mjs <tool> '<json>' call one tool, see the exact response and its cost
node scripts/mcp-probe.mjs the same thing over real MCP, raw JSON-RPCBreakpoints, logs, and the traps this codebase has already fallen into: docs/DEBUGGING.md.
Tests
npm run validate offline checks
npm run test:installer the setup wizard
npm test all three suites
npm run docs regenerate the tool reference199 checks. The integration suite attaches to a page that has already finished
loading, because that is the case the previous version got wrong. npm run validate fails if docs/TOOLS.md is out of date, so the reference cannot drift.
Troubleshooting
Tools not appearing — fully quit the assistant (tray/menu, not just the window) and reopen. Re-run the wizard if still missing.
"Chrome is not reachable" — launch via debug-chrome.bat, then check
http://localhost:9222/json/version. Only one Chrome can own a port.
A breakpoint never fires — debugger_list_breakpoints and look at bound. An
unbound breakpoint reports why.
Support the project
DevCDP is free and MIT-licensed, built and maintained by one person. If it saved you a debugging afternoon, sponsoring on GitHub keeps it moving. Teams wanting a hosted setup, shared learned memory across engineers, or an onboarding workshop can open an issue to start the conversation.
Privacy and license
DevCDP runs locally and sends nothing anywhere except to the MCP client you connected it to: PRIVACY.md. MIT licensed: LICENSE.
A selector finds nothing — dom_list_frames; the content may be in an iframe.
Retry with frame: 'all'.
Empty console or network right after attaching — expected. Capture starts at
attach; page_reload replays the page with DevCDP watching.
The page stops responding — its main thread is blocked, usually a loop in app
JS. page_interrupt aborts the running script; reloading will not free it.
A tab is unavailable — sessions_list shows which session holds it.
Available Tools
73 toolsapi_discoverA
Build a map of the backend the page actually talks to: endpoints grouped with ids collapsed, call counts, status codes, timings and failures — plus an OpenAPI/Swagger specification if the server publishes one at a standard path. Use it to understand the API surface, and to see at a glance which calls are failing.
Inputs: probe_openapi, include_static.
app_discoverA
Ask the running page what it is: which UI libraries it uses, how it routes, how many frames it has, and its actual interactive surface — visible buttons, fields, grids and tabs with working selectors. Call this once before driving an unfamiliar app, instead of guessing selectors.
Inputs: no named parameters.
console_clearA
Empty the console buffer so that what you read next belongs only to the action you are about to take. Does not touch the browser's own console display.
Inputs: no named parameters.
console_evaluateA
Run a JavaScript expression in the page and return its value. On failure returns the full exception detail (message, 1-based line and column, URL, stack). Use it to read app state; use debugger_evaluate_at_frame instead when you are paused and need a local variable.
Inputs: expression (required), timeout_ms, await_promise.
console_get_logsA
Read console output captured since attach: logs, warnings, uncaught exceptions with file, line and stack. Pass cursor=nextCursor from a previous call to get only what is new. Note that Chrome does not replay messages logged before DevCDP attached — reproduce the action or call page_reload to see those.
Inputs: clear, level, limit, since, +2 more.
debugger_evaluate_at_frameA
Evaluate an expression in the scope of a paused call frame, so local variables and closures are in scope. This is how you confirm a hypothesis with a real value rather than inferring one.
Inputs: expression (required), depth, frame_index.
debugger_get_captureA
Everything captured automatically at the last breakpoint hit — scope for the top frames, recent console output and recent network requests — in one call instead of four. Tells you whether the pause is still current or has already resumed, so a stale snapshot is never mistaken for live state.
Inputs: no named parameters.
debugger_get_scopeA
Read the variables in scope at a paused call frame, with objects and arrays expanded rather than printed as 'Object'. Includes this. Anything omitted for size is explicitly marked, so you never have to guess whether you saw the whole value.
Inputs: depth, frame_index, include_global, max_properties.
debugger_get_stateA
Where execution is paused right now: the reason, and the full call stack with function names and 1-based file positions. Returns paused:false when the page is running.
Inputs: no named parameters.
debugger_list_breakpointsA
List the breakpoints DevCDP has set, including whether each is actually bound to executable code. An unbound breakpoint will never fire — check here first when a breakpoint 'is not hitting'.
Inputs: no named parameters.
debugger_pauseA
Pause JavaScript execution at the next statement the page runs, and hold it so you can inspect and step. The page is frozen while held, so DevCDP releases it automatically after maxPauseMs if you have not resumed — no human ever has to press resume in Chrome.
Inputs: no named parameters.
debugger_remove_all_breakpointsA
Remove every breakpoint DevCDP set, and resume the page if it is currently paused. Call this before handing the browser back to a human, so they do not find a frozen app.
Inputs: no named parameters.
debugger_remove_breakpointA
Remove one breakpoint by its breakpointId. Use debugger_remove_all_breakpoints to clear them in one call.
Inputs: breakpoint_id (required).
debugger_resumeA
Resume execution and drop any hold. Breakpoints resume themselves by default, so this is only needed after an explicit pause, after stepping, or after a breakpoint set with auto_resume:false.
Inputs: no named parameters.
debugger_set_breakpointA
Set a breakpoint and report honestly whether Chrome could bind it. Accepts either a loaded script URL (a substring is resolved to the exact script) or an original pre-bundling file path, which is translated through the source map. Set auto_resume:true when the action is being driven by an automation tool, so the page does not stay frozen and time that action out.
Inputs: url (required), line (required), column, condition, +1 more.
debugger_set_breakpoint_at_functionA
Set a breakpoint on a function you can name, without knowing which file it lives in. Give any expression that evaluates to a function — 'app.saveOrder', 'MyClass.prototype.load', a framework helper — and DevCDP finds its definition and breaks at its first statement. Use this when you know what runs but not where it is defined; use debugger_set_breakpoint when you already have a file and line.
Inputs: function_expression (required), condition, auto_resume.
debugger_step_intoA
Step into from the current pause and stop at the next statement. Stepping implies you want the pause held, so it will not auto-resume between steps — but it is still released automatically after maxPauseMs if you stop. The new location and scope are available from debugger_get_state and debugger_get_scope once it settles.
Inputs: no named parameters.
debugger_step_outA
Step out from the current pause and stop at the next statement. Stepping implies you want the pause held, so it will not auto-resume between steps — but it is still released automatically after maxPauseMs if you stop. The new location and scope are available from debugger_get_state and debugger_get_scope once it settles.
Inputs: no named parameters.
debugger_step_overA
Step over from the current pause and stop at the next statement. Stepping implies you want the pause held, so it will not auto-resume between steps — but it is still released automatically after maxPauseMs if you stop. The new location and scope are available from debugger_get_state and debugger_get_scope once it settles.
Inputs: no named parameters.
devcdp_settingsA
Show every DevCDP setting: its effective value, where that value came from (default, which settings file, or which environment variable), which files were searched and loaded, and any that failed to parse or were not recognised. Use it before changing configuration, and to check a change actually took effect.
Inputs: group, changed_only.
devcdp_settings_initA
Write a settings file containing every option with its current value and an explanation, so it can be edited by hand. Refuses to overwrite an existing file unless you say so.
Inputs: path, overwrite.
devtools_connectA
Attach to a Chrome tab over the DevTools Protocol and start observing it (console, network, DOM, debugger). Claims the tab so no other DevCDP session can drive it, marks it visibly in the browser, and reports what was loaded before we attached. Call this once at the start of a debugging session.
Inputs: host, port, target, window, +2 more.
devtools_disconnectA
Detach cleanly: resume the page if it is paused at a breakpoint, remove every breakpoint we set, remove the in-page badge, and release the tab claim so another session can use it. Always call this when you are done.
Inputs: no named parameters.
devtools_statusA
Connection health and buffer accounting: which tab is attached, how many console/network/script entries are held, whether the debugger is paused, and whether anything has been evicted from the buffers.
Inputs: no named parameters.
dialog_detectA
Detect modal dialogs, alerts and confirmation overlays that are visible right now, with their title, message and button labels. Detection is structural — ARIA roles, the dialog element, and stacked-overlay geometry — so it works regardless of which UI framework drew it. Call it after any action that might raise a prompt.
Inputs: frame.
docs_outlineA
List the documentation available under the docs root, with each file's headings, so you can see what the project documents before searching. A good first call when you do not yet know the app's vocabulary.
Inputs: root, max_files.
docs_searchA
Search the project's own documentation — README and any markdown/text/pdf docs under the configured docs root — and return matching passages with file and line. Use it to learn what a screen, field or business term means in this app, instead of inferring it from the UI. Set docsRoot in your settings file if the docs live elsewhere.
Inputs: query (required), root, max_results, context_lines.
dom_get_htmlA
Get the inner or outer HTML of the first element matching a selector, truncated to a byte budget. Useful for understanding structure you cannot infer from dom_query alone.
Inputs: selector (required), frame, inner, max_bytes.
dom_get_mutationsA
DOM changes recorded since the last call — what was added, removed or re-attributed, and where. Use it after an action to see whether the app re-rendered at all, which distinguishes 'handler never ran' from 'handler ran and produced nothing'.
Inputs: clear, limit.
dom_list_framesA
List the frames and JavaScript execution contexts in the attached tab. Use it when a selector finds nothing — the content may live in an iframe, which needs frame:'all' on dom_query.
Inputs: no named parameters.
dom_queryA
Query elements by CSS selector and return tag, id, classes, text, attributes, geometry and real visibility. Ask for computed styles by naming the properties you want. Set frame:'all' to search inside iframes too — single-page apps often render the screen you care about in a child frame.
Inputs: selector (required), frame, limit, fields, +4 more.
list_tabsA
List the debuggable tabs in Chrome with their index, title, URL, whether each is the visible one, and which DevCDP session (if any) currently owns it. Use the index with target:'index:' in devtools_connect.
Inputs: host, port, probe.
memory_getA
Look up what previous sessions learned about this app — failures and the recovery that worked. Returns short summaries so it is cheap to call at the start of a session; pass full:true or an id to read one in detail. Search it whenever a step fails, before asking the user for help.
Inputs: id, full, limit, query, +1 more.
memory_import_legacyA
One-off import of a v4 Markdown memory file into the current store, skipping the malformed entries v4's missing validation produced. Run once after upgrading, then delete the old file.
Inputs: path (required).
memory_recordA
Record a failure and the recovery that worked, so a later session can skip the dead end. Call it after any user-assisted recovery or non-obvious workaround. All four fields are required and validated — a vague entry is worse than none, because it costs context on every future lookup.
Inputs: failure (required), pattern (required), category (required), recovery (required), +2 more.
network_clearA
Empty the network buffer so the next thing you read belongs only to the action you are about to take. Does not affect the browser's own Network panel.
Inputs: no named parameters.
network_get_requestsA
List HTTP requests captured since attach, with method, status, duration, size and initiator. Filter by URL substring, method, status or failures only. Response bodies are opt-in via include_bodies because they are large. Capture starts when DevCDP attaches, so requests from before that are not here — reload to see them.
Inputs: limit, method, offset, status, +7 more.
network_get_response_bodyA
Fetch the full response body for one requestId from network_get_requests. Chrome discards bodies when the page navigates, so read them while the page is still on the same document.
Inputs: requestId, request_id, max_body_bytes.
network_wait_for_requestA
Block until a request whose URL contains url_filter completes, then return it. Event driven, so there is no polling. Call this immediately AFTER triggering the action, or pass a filter that has not fired yet — a request that already completed is returned straight away. Gives up after timeout_ms and tells you so.
Inputs: url_filter (required), method, timeout_ms, allow_existing.
notify_userA
Show a short status line to the human, in the badge on the page you are debugging. This is the only channel the user actually sees — call it before a slow or surprising step so a frozen-looking app is explained. Keep it to a few words.
Inputs: action (required), detail (required).
page_interruptA
Abort the JavaScript the page is currently running. Use it when a tool reports PAGE_UNRESPONSIVE — an infinite loop or a long synchronous task has blocked the main thread. This is the only thing that frees it: reloading and navigating do not, because the blocked thread never processes them. The page keeps its DOM and state; only the in-flight script is killed.
Inputs: no named parameters.
page_reloadA
Reload the attached tab. Useful right after attaching, because console history and network traffic from before the attach cannot be recovered — a reload replays everything with DevCDP watching.
Inputs: bypass_cache.
runtime_evaluate_manyA
Evaluate several named expressions in one round trip and get a map of name to result. Use it to sample a lot of app state at once instead of paying a round trip per question. Individual failures are reported per entry rather than aborting the batch.
Inputs: expressions (required), await_promise.
session_ask_userA
Ask the human to do something in the browser, and show the request in the on-page badge with a confirmation button. Returns immediately — poll session_poll_user_action for the outcome. Also relay the instruction in your reply, so it is visible whether or not they are looking at the browser window.
Inputs: instruction (required), wait_for.
session_endA
Close the session and return a summary. Does not detach — call devtools_disconnect to release the tab and clear breakpoints when you are finished with the browser entirely.
Inputs: no named parameters.
session_get_activityA
Unified timeline of everything observed in this session — console output, requests, navigations, dialogs, clicks, pauses and handovers, in order. Use it to reconstruct what happened when a step behaved unexpectedly.
Inputs: limit, since, types.
session_get_stateA
One snapshot of console output, network requests and DOM mutations together, instead of three separate calls. Pass the cursors back on the next call to get only what is new. This is the cheapest way to see the effect of an action.
Inputs: log_limit, mut_limit, net_limit, log_cursor, +2 more.
session_get_statusA
Where the session plan stands: the goal, each step's status, which step is current, and whether a human handover is outstanding.
Inputs: no named parameters.
session_get_user_actionsA
What the human has done in the browser — clicks, typed values, chosen options, submissions — and the element each one touched. Works whether or not you asked, so unprompted help is still readable. Pass the cursor back for only what is new. Values are captured during a handover or takeover; sensitive fields stay redacted.
Inputs: kinds, limit, cursor.
session_poll_user_actionA
Check whether the human has completed what session_ask_user requested. Returns acted:false while waiting. Poll at a human pace — a few seconds apart — rather than in a tight loop.
Inputs: no named parameters.
sessions_listA
Show every DevCDP session currently running on this machine and the tabs each one holds. Use it to understand why a tab is unavailable, or to confirm two agents are not fighting over the same page.
Inputs: no named parameters.
session_startA
Open a debugging session with a goal and an ordered list of steps, so progress is tracked and a failed step can fall back to asking the human. Use it for multi-step reproductions; a single-question investigation does not need it.
Inputs: goal (required), steps (required).
session_step_doneA
Mark the current step complete with what you found, and advance. Returns the next step, or allDone when the plan is finished.
Inputs: result.
session_step_failedA
Report that you cannot complete the current step yourself. Checks memory for a known recovery first, then tells you how to hand over to the human. Use it for anything automation genuinely cannot do — a login you have no credentials for, a challenge, a physical device.
Inputs: reason (required).
source_get_fileA
Read an original pre-bundling source file via the page's source maps. Falls back to the loaded script when no map is available, and always tells you which of the two you got, so a bundle line is never mistaken for an original one.
Inputs: path (required), end_line, start_line.
source_get_scriptA
Read the source Chrome actually loaded, by scriptId or URL substring, optionally a line range. Lines come back numbered so the numbers you quote to a breakpoint are the numbers you saw.
Inputs: url, end_line, script_id, start_line.
source_list_filesA
List the original source files recoverable from the page's source maps — the pre-bundling file tree. Use it to discover real file paths before calling source_get_file or setting a breakpoint on an original file.
Inputs: limit, filter.
source_list_scriptsA
List the JavaScript files loaded in the page, with size and whether each has a source map. This is indexed the moment DevCDP attaches, so it works on a page that was already open. Filter by URL substring to find the file you need before setting a breakpoint.
Inputs: limit, filter, with_source_maps.
source_searchA
Search the text of every loaded script — and every original file recoverable from source maps — for a string or regular expression. This is the fastest way to locate a handler when you know a function name, a message or a field name but not the file. Returns file, 1-based line and the matching line.
Inputs: query (required), regex, url_filter, ignore_case, +3 more.
ui_checkA
Set a checkbox or radio to a specific state, rather than toggling it blindly. Reads the current state first and clicks only if it differs, so calling it twice does not undo the first call — the usual way a 'toggle' helper leaves a form in the wrong state.
Inputs: nth, role, text, exact, +5 more.
ui_clickA
Click an element, identified by CSS selector, visible text or test id. Waits until it is actually clickable — rendered, enabled, stopped moving, and not covered by anything — then dispatches real (trusted) mouse events, and reports what the click caused: requests fired, console errors, whether the DOM changed at all. If it never became clickable it says which of those conditions failed and what was in the way.
Inputs: nth, role, text, exact, +8 more.
ui_dragA
Drag one element onto another — reordering rows, moving a card between columns, resizing a split. Dispatches a real press, several intermediate moves and a release, because drag implementations almost always ignore a press followed immediately by a release somewhere else.
Inputs: text, frame, steps, testid, +5 more.
ui_fillA
Set the value of a text field, textarea or contenteditable in one step, and fire the input and change events the application listens for. Fast, because it does not type character by character — use ui_type instead when the field reacts to each keystroke, such as a typeahead or an autocomplete.
Inputs: value (required), nth, role, text, +6 more.
ui_hoverA
Move the pointer over an element and leave it there. Use before clicking anything that only appears on hover — dropdown menus, row action buttons, tooltips — because those elements do not exist to click until something is hovering over their parent.
Inputs: nth, role, text, exact, +4 more.
ui_inspectA
List what can be interacted with on the current screen — buttons, links, inputs, selects and anything with an interactive ARIA role — with the target you would use to reach each one. Use it when a selector fails and you need to see what is really there. Far cheaper than dumping the DOM, and it names elements the way these tools expect them to be named.
Inputs: kind, frame, limit, filter.
ui_pressA
Press a key — Enter to submit, Tab to move on, Escape to dismiss, arrows to move through a list or grid. Optionally focuses an element first. This is the tool for keyboard-driven screens, where clicking the control is not how the application expects to be used.
Inputs: key (required), nth, role, text, +7 more.
ui_scrollA
Scroll the page, or scroll a specific container. Needed before interacting with anything in a virtualised list or grid, where rows outside the viewport do not exist in the DOM at all — scrolling is what creates them.
Inputs: dx, dy, to, text, +4 more.
ui_selectA
Choose an option in a dropdown, by visible label or by value. Handles a native directly; for the custom dropdowns most applications actually use — a div that opens a list — it opens the control and clicks the matching option. Reports the options it could see when nothing matches, which is usually the whole answer.
Inputs: option (required), by, nth, role, +6 more.
ui_typeA
Type into a field one character at a time, with real key events for each. Slower than ui_fill and necessary exactly when the field reacts per keystroke — search-as-you-type, autocomplete, input masks, and fields that reformat while you type. If ui_fill left the field looking right but the application unaware, use this.
Inputs: text_to_type (required), nth, role, text, +8 more.
ui_uploadA
Attach one or more local files to a file input, without opening the operating system's file picker — which automation cannot drive at all. Give the absolute paths of files on the machine running Chrome.
Inputs: files (required), nth, role, text, +5 more.
ui_wait_forA
Block until the page reaches a state: an element appears, disappears, becomes enabled, or some text shows up. This is the honest alternative to guessing a sleep — it returns as soon as the condition holds, and when it does not, it says what the page looked like instead of just timing out.
Inputs: nth, role, text, exact, +6 more.
workflow_guideA
How to use DevCDP effectively: the observe/act division of labour, the fastest path from a bug report to an exact line, and the traps worth knowing. Call it once at the start of a debugging session.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 73 tools
The descriptions are careful and cross-reference each other, but the sheer number of getter/snapshot tools (debugger_get_capture/state/scope, session_get_state/activity/status, devtools_status) and pairs like list_tabs/sessions_list and app_discover/ui_inspect create real selection ambiguity. Most tools are distinguishable, but an agent could easily pick the wrong one when several seem to return similar state.
The dominant pattern is domain_verb_noun in snake_case (network_get_requests, debugger_set_breakpoint, session_get_status), which is quite consistent across 73 tools. A few outliers like list_tabs, notify_user, and workflow_guide break the prefix convention, so it is not perfect.
73 tools is far beyond a workable MCP tool surface and exceeds the 50+ extreme ceiling. Even though the tools are organized into coherent domains, this count will dominate agent context and make tool selection expensive.
The set covers an unusually broad workflow: attach/detach, console, network, DOM, interaction, source/debugger, sessions, memory, discovery, docs, and settings. It only misses peripheral browser operations such as screenshots, storage/cookies, or performance tracing, which agents can work around.
Maintenance
Related MCP Connectors
Live browser debugging for AI assistants — DOM, console, network via MCP.
Cloud browsers for AI agents: saved logins, residential IPs, live human takeover, 57 browser tools.
Let AI agents use your real, signed-in Chrome: tabs, clicks, forms, screenshots and video.
Let your AI agent operate any website through a real, logged-in browser session.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to debug frontend applications by providing direct access to browser DevTools, React state, DOM inspection, and runtime debugging capabilities. Bridges the gap between AI and complex web applications for autonomous debugging and issue resolution.1MIT
- AlicenseBqualityBmaintenanceEnables AI agents to debug code and automate browsers using Chrome DevTools Protocol, supporting breakpoints, variable inspection, and replayable interaction recording.35611 npm19MIT
- AlicenseCqualityDmaintenanceEnables AI assistants to connect to browser DevTools and backend debuggers for full-stack debugging, including frontend console, network, performance, and backend log analysis.1620 npm7MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI coding assistants to control and inspect a live Chrome browser through Chrome DevTools for automation, debugging, and performance analysis.Apache 2.0