cdp-tools-mcp
This MCP server lets an agent launch and control Chrome, inspect/debug pages and Node.js, manage dev servers, and record/replay browser workflows for testing.
Launch/kill Chrome, manage tabs and debugger connections, navigate pages, and get page/Chrome/debugger status.
Click, type, press keys, hover, focus, drag, scroll, pinch, detect modals, and dismiss them.
Read page content, find interactive elements, and verify UI issues like dead buttons/links, touch targets, overflow, clipping, and horizontal scroll.
Take screenshots/PDFs, query the DOM, extract text, inspect cookies/localStorage/sessionStorage, and save files to disk.
Monitor console messages and network requests, search/filter them, and set network throttling conditions.
Set breakpoints, logpoints, DOM/event/XHR breakpoints; step execution; inspect call stacks/variables; evaluate JS; search code/functions; load source maps; debug Node.js via
--inspect.Start, stop, restart, and monitor npm/Docker/Docker Compose dev servers; read logs; auto-run servers; block browser tools when a monitored port is down.
Record and replay sequences, save/load/export to Playwright or Puppeteer, repeat history steps, and assert conditions within sequence steps.
Make HTTP requests from Node or the browser, with response capture into sequence variables.
Track bugs/features as issues, link reproduction sequences, work on issues with auto-replay, and resolve/acknowledge them.
Configure local/global settings, back up/reset config, list/toggle tools, and manage the web dashboard.
Use the bench to point at elements and attach annotated screenshots/notes, and support multiple agent connections/tabs.
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., "@cdp-tools-mcp Set a breakpoint on line 42 of app.js and inspect the user variable."
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.
devharness
Let Claude open your app, use it, and see what actually goes wrong.
When you build with an AI agent, you end up as its tester. It changes the code, then you open the browser, click through, and paste the error back. It can't see the page, the browser console or your server's output, so it works from what you paste, and "fixed" often isn't.
devharness gives the agent its own Chrome window. It opens your app, clicks and types like you would, reads the errors in the console and the server logs, and can try its own fix in the browser before telling you it's done.
/plugin marketplace add InDate/indate-tools
/plugin install devharness@indate-toolsWas
cdp-tools-mcp. Migrating.
What you'll notice
A Chrome window opens and the agent uses your app. You can watch it navigate, fill forms and click buttons. It runs with its own temporary profile, so your everyday browser, bookmarks and logins are untouched.
The agent sees errors without you pasting them. After each action it gets any new output from your dev server and the newest error in the browser console, with where it came from.
The agent runs your dev server. It can start it, restart it and read its logs. With port monitoring on, a server that dies stops browser actions with a message saying so, rather than the agent clicking away at a dead page and reporting made-up results.
Setup isn't redone by hand. Every action gets a number. To get back to the broken screen after a fix, the agent re-runs those numbered steps in one call, with exactly the values it used the first time.
Related MCP server: Chrome DevTools MCP
Things to ask
Ask for the outcome. The agent picks the tools.
"Open the app at localhost:3000 and check the signup form works."
"The total on the checkout page is wrong. Find where it's calculated."
"Start the dev server and keep an eye on it while we work."
"Click through the settings page and tell me which buttons do nothing."
"Record the steps that reproduce this bug, then re-run them after you fix it."
Show it the problem instead of describing it
Some bugs are hard to put into words: "the thing on the right, under the header, is too far down". Ask the agent to open the bench, and a panel opens beside your app. Click the element you mean and type a note, and attach a screenshot you can crop and draw on. The note records what the element is - its selector, and its component and source file where your dev build exposes them - and reaches the agent as soon as you save it.
Keep a bug and prove the fix
The steps the agent takes can be saved as a sequence and replayed later, or exported as a Playwright or Puppeteer test. An issue can carry the sequence that reproduces it, so working on it starts by replaying to the broken state.
Closing an issue needs you. The agent opens a Fixed / Not Fixed prompt in the browser and waits for your click; it can record what it found, but it can't mark its own work as fixed. Issues can be published to GitHub, which shows you a draft and posts nothing until you confirm.
Setup
You need Google Chrome installed in its usual place and Node.js 18 or later.
Claude Code (recommended) - the plugin registers the server, adds the skill that teaches the agent how to use it, and pins the version, so what you installed is what runs until you update:
/plugin marketplace add InDate/indate-tools
/plugin install devharness@indate-toolsClaude Code, server only:
claude mcp add devharness -- npx devharness@latestClaude Desktop:
{
"mcpServers": {
"devharness": {
"command": "npx",
"args": ["-y", "devharness@latest"]
}
}
}Other MCP clients: run npx devharness@latest over stdio.
The tools' descriptions and replies carry how to use them; the full reference is
docs/instructions.md.
For developers
devharness is an MCP server that drives Chrome and Node.js through the Chrome DevTools Protocol. Beyond the above:
Debugger. Breakpoints (line, conditional, logpoints, DOM changes, events, XHR), stepping, the call stack and variables in scope, in Chrome and in Node.js started with
--inspect, both at once. Source maps put TypeScript breakpoints on TypeScript lines.Page checks.
content verifyreports dead buttons, dead links, small touch targets, clipped overflow and horizontal scroll, from what the browser reports.Network. Console, requests and responses, cookies and storage. With
connection({ action: 'launch', proxy: true })the browser runs through a recording proxy that ties each request and socket message to the step that caused it and keeps the app's own polling apart.Dev servers. npm scripts, Docker and Docker Compose.
start({ monitorPort: true })watches the port and blocks browser tools while it is down;start({ watch: true })restarts on file changes.Several agents. Every tool takes a named connection, so nested agents each drive their own tab in one Chrome.
Recovery. A call missing a field returns what is missing and the retry sends only that.
config({ action: 'restart' })respawns a stuck server without the client reconnecting.
A Node service by hand:
1. node --inspect=9229 app.js
2. connection({ action: 'attach', connection: "my-api-server", port: 9229 })
3. breakpoint({ action: 'set', connection: "my-api-server", file: "user.ts", line: 42 })
4. Trigger the request.
5. inspect({ action: 'getVariables', connection: "my-api-server" })examples/test-app is an app with deliberate bugs to practise on.
Command line
devharness <command>, run from a shell inside an editor session, executes a tool in that session's own server process, against the browser and dev servers it already has open. Only sessions rooted at the shell's directory or above it are candidates, because issues, config and sequences resolve against the answering server's root; process ancestry picks among those. Nothing needs to be passed in.
devharness which # which session this shell belongs to
devharness call config '{"action":"status"}' # any tool, arguments as one JSON object
devharness watch # wait for this session's next events, for a client with no messaging socket
devharness bug "Title" Body words here # files an issue; feature does the same
devharness bench [sequence] [url] # opens the bench against this session--session=<id> targets a session explicitly, --json prints the unrendered response, and the exit code is 1 when the tool returns an error. Each session listens on a unix socket under ~/.devharness/endpoints/, mode 0600 - not a TCP port, because the tools reachable through it evaluate JavaScript in that session's browser.
devharness run <sequenceName> is separate: it starts its own headless Chrome and replays a saved sequence, with no session involved.
Documentation
docs/README.md: guides for installation, debugging, automation, replay and troubleshooting
docs/instructions.md: every tool and action
CHANGELOG.md: what each release changed
Migrating
cdp-tools-mcp is deprecated on npm and points here. Tools unchanged. Package,
repo, and skill renamed.
-"args": ["-y", "cdp-tools-mcp@latest"]
+"args": ["-y", "devharness@latest"]Your MCP server name (devharness, or whatever you called it) is yours and keeps
working. Renaming it is cosmetic — but tools are addressed as
mcp__<server-name>__<tool>, so update project docs if you do.
State moved .cdp-tools/ → .devharness/ in 0.9.0. Migrates itself on first
run; profiles, config, sequences, and issues carry over. DEVHARNESS_DIR
supersedes CDP_TOOLS_DIR, which still works.
From source
git clone https://github.com/InDate/devharness.git
cd devharness
npm install && npm run build && npm testContributing
Issues and PRs welcome. Reporting a bug? Attach a recorded reproduction sequence.
License
MIT
Available Tools
35 toolsassertA
Assert a condition as a sequence step. Fails the sequence (isError, executor stops) if the condition is false - use with {{var:name.path}} templates to check values captured by a prior request({saveAs}) step.
Inputs: operator (required), left, right, message.
breakpointB
Manage breakpoints and logpoints. Actions: set (line breakpoint), remove (remove by ID), list (list all), setLogpoint (log without pausing), validate (test expressions), resetCounter (reset logpoint counter), waitForScript (wait for script load), setDOMBreakpoint (pause when element changes), setEventBreakpoint (pause when event fires), setXHRBreakpoint (pause on network requests), await (set breakpoint and wait for hit - user can abort)
Inputs: action (required), url, timeout, selector, +13 more.
configA
Manage cdp-tools configuration. Actions: status (show where config is loaded from), useLocal (switch to project-local config), useGlobal (switch to global ~/.cdp-tools config), reset (reset to defaults), backup (create timestamped backup), cloneFromGlobal (copy global config to local), show (display current settings), listTools (list all toggleable tools with their status and dependencies)
Inputs: action (required), path, seedFromGlobal.
connectDebuggerC
Connect to debugger
Inputs: reference (required), host, port.
consoleC
Monitor and manage console messages. Actions: list, get, recent, search, clear, setObjectDepth
Inputs: action (required), connectionReason (required), id, full, +11 more.
contentA
Primary tool for page content. Prefer over screenshots. Actions: extractText (extract webpage text with outline/full/section modes), findInteractive (find all interactive elements like links, buttons, inputs with summary or filtered view), verify (run CDP-based UI verification for dead buttons, viewport issues, touch targets, overflow clipping)
Inputs: action (required), connectionReason (required), mode, save, +6 more.
dashboardA
Manage the cdp-tools web dashboard. Actions: open (get URL to open in browser), status (show whether this session is hub or client), stop (stop the hub server if this session is the hub)
Inputs: action (required).
detectModalsD
Detect modals
Inputs: connectionReason (required), minZIndex, includeBackdrops, minViewportCoverage.
disconnectDebuggerD
Disconnect debugger
Inputs: reason (required), reference (required).
dismissModalC
Dismiss modal
Inputs: connectionReason (required), index, selector, strategy, +1 more.
domA
Inspect and query the DOM. Actions: querySelector (find element by CSS selector and get basic info), getProperties (get detailed properties of an element), snapshot (get full DOM structure snapshot)
Inputs: action (required), connectionReason (required), maxDepth, selector.
executionA
Control execution flow when paused at breakpoints. Actions: pause (pause execution), resume (resume execution), stepOver (step to next line), stepInto (step into function call), stepOut (step out of current function), acknowledge (acknowledge breakpoint pause to allow other tools to run while paused)
Inputs: action (required), connectionReason.
getChromeStatusD
Get Chrome status
Inputs: no named parameters.
getDebuggerStatusC
Get debugger status
Inputs: reference (required).
getDebugLoggingStatusB
Check debug logging status
Inputs: no named parameters.
getSourceCodeB
Get source code at line range
Inputs: url (required), endLine, startLine, connectionReason.
inputC
Perform browser input actions. Actions: click (click element), type (type text into element), press (press keyboard key), hover (hover over element), focus (focus element by selector), focusNext (Tab to next focusable element), focusPrevious (Shift+Tab to previous focusable element), drag (drag from one point to another), scroll (scroll wheel at position), mousemove (move mouse to position), pinch (pinch zoom gesture)
Inputs: action (required), connectionReason (required), x, y, +17 more.
inspectC
Inspect and debug code. Actions: getCallStack (get call stack when paused), getVariables (get variables in call frame), evaluateExpression (evaluate JavaScript), searchCode (search code by pattern), searchFunctions (find function definitions)
Inputs: action (required), limit, filter, isRegex, +11 more.
issuesA
Track and manage bugs and features. Actions: list (show all issues with optional filters), create (create new issue, optionally linking a sequence), workOn (start working on issue with auto-replay), resolve (mark as fixed/implemented), acknowledge (acknowledge pending bugs to unblock tools)
Inputs: action (required), id, type, search, +8 more.
killChromeC
Kill Chrome process
Inputs: reason (required), port.
launchChromeC
Launch Chrome with debugging
Inputs: url, port, width, height, +5 more.
listConnectionsA
List debugger connections
Inputs: no named parameters.
loadSourceMapsC
Load source maps
Inputs: directory (required).
networkB
Monitor and manage network requests. Actions: list (list requests with optional type filter and pagination), get (get specific request by ID), search (search requests by regex pattern), enable (enable network monitoring), disable (disable network monitoring), setConditions (set network throttling conditions)
Inputs: action (required), id, flags, limit, +8 more.
replayB
Record and replay command sequences for testing and automation. Actions: repeat (immediately execute commands by history indices - use this to repeat recent actions), history (view command history), create (create sequence from indices), list (list in-memory sequences), get (get sequence details), delete (delete from memory), save (save sequence to disk), load (load sequence from disk), listSaved (list saved files), deleteSaved (delete saved file), run (load and execute sequence from disk in one step), step (execute next N commands in paused sequence), finish (complete remaining commands), insert (insert recorded commands into sequence), status (show active sequence status), startMouseRecording (start recording mouse events), stopMouseRecording (stop recording and get events), mouseRecordingStatus (check recording status)
Inputs: action (required), name, limit, lines, +34 more.
requestA
Make an HTTP request as a sequence step. destination "node" sends it from the MCP server process directly (no browser, no CORS/cookies). destination "browser" runs fetch() inside a connected tab (uses that page's cookies/session/origin).
Inputs: url (required), destination (required), body, method, +4 more.
resetChromeLauncherD
Reset Chrome launcher
Inputs: reason (required).
saveToDiskC
Download file to disk
Inputs: url (required), filename (required), overwriteIfExists.
screenshotB
Visual verification only. Use extractText for content. Actions: fullPage (full page screenshot), viewport (viewport screenshot), element (element screenshot), pdf (print to PDF with Chrome or WeasyPrint engines)
Inputs: action (required), connectionReason (required), clip, type, +16 more.
serverB
Manage development servers. Actions: start (start a server from npm script), stop (stop a running server), restart (restart a server), list (list running servers with status), logs (get log file paths or docker command), stopAll (stop all servers), setAutoRun (enable/disable auto-start on MCP startup)
Inputs: action (required), id, cwd, env, +10 more.
setDebugLoggingC
Toggle debug logging
Inputs: enabled (required).
storageC
Access and manage browser storage (cookies, localStorage, sessionStorage). Actions: getCookies (get cookies), setCookie (set cookie), getLocalStorage (get localStorage), setLocalStorage (set localStorage), clear (clear storage)
Inputs: action (required), key, url, name, +9 more.
switchConnectionC
Switch debugger connection
Inputs: reference (required).
tabC
Manage browser tabs. Actions: list (show all open tabs), create (open new tab with reference), rename (change tab reference), switch (switch active tab), close (close a tab)
Inputs: action (required), url, reference, newReference.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 35 tools
Each tool has a clearly distinct domain and action set. Despite many tools, there is little to no overlap: e.g., breakpoint vs execution, content vs screenshot, navigate vs tab are all well-differentiated.
All tool names consistently use camelCase with verb + noun pattern. Sub-actions are also consistently named (e.g., set, remove, list). No mixing of conventions.
35 tools is on the higher side but appropriate for the comprehensive scope covering debugging, navigation, input, network, storage, breakpoints, and server management. Some granularity (e.g., multiple status tools) could be consolidated, but overall reasonable.
The tool surface covers major browser automation and debugging workflows: navigation, DOM interaction, input, network, console, storage, breakpoints, execution control, screenshots, and logging. Minor gaps like performance profiling or mobile emulation exist but core operations are well-covered.
Maintenance
Related MCP Connectors
Live browser debugging for AI assistants — DOM, console, network via MCP.
Give AI agents a real cloud Chrome: open sessions, navigate, read pages, click, type and screenshot.
Control a real browser from AI agents: navigate, click, type, screenshot, read the page.
Cloud browser, web extraction, screenshots, and remote CDP tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables AI coding assistants to control and inspect a live Chrome browser through Chrome DevTools. Provides browser automation, performance analysis, debugging capabilities, and network request monitoring.2,562,190 npm57,558Apache 2.0
- AlicenseAqualityCmaintenanceEnables AI coding assistants to control and inspect a live Chrome browser for automation, debugging, performance analysis, and screenshot capture through Chrome DevTools.262,562,190 npm3Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables AI coding assistants to control and inspect a live Chrome browser for automation, debugging, performance analysis, network monitoring, and DOM interaction through Chrome DevTools Protocol.2,562,190 npmApache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables AI coding assistants to control and inspect a live Chrome browser through Chrome DevTools for automation, debugging, and performance analysis.2,562,190 npmApache 2.0