Apply a multi-file patch atomically (nothing is written unless every hunk applies). Preferred way to change code. Format: *** Begin Patch *** Update File: src/app.ts @@ function main() { (optional anchor line to jump near the change) context line (space prefix) -removed line +added line *** Add File: src/new.ts +file content line *** Delete File: src/old.ts *** Update File: a.ts *** Move to: b.ts *** End Patch Include ~3 unchanged context lines around each change. The result reports compiler/linter problems in the changed files and a checkpoint id for undo.

Run several tool calls in one request. Parallel mode is allowed only when every called tool is read-only.

Click an element by ref (preferred), selector or text. Returns the updated snapshot.

Close the Playwright browser (the persistent profile stays on disk).

Console messages, page errors, failed requests and dialogs captured from the browser.

Inspect or answer a JavaScript dialog (alert/confirm/prompt) in the Playwright browser. Dialogs are never accepted automatically.

Run JavaScript in the page. Pass an expression ("document.title") or a function body using return.

Visible text of the page or of an element (CSS selector).

Hover over an element.

Open a URL in the Playwright-controlled Chrome (persistent profile: logins are remembered). Returns the page snapshot with element refs.

Press a key or chord on the page, e.g. "Enter", "Escape", "Control+A", "ArrowDown".

Start recording a video of a browser session. Opens a dedicated recording tab (with your profile logins); every browser_* action afterwards is filmed until browser_record_stop.

Stop the recording and save the clip (mp4 via ffmpeg). Returns the file path.

Set the viewport size.

Screenshot of the page (or one element). The image is returned so you can see it, and saved to disk.

Scroll the page by deltaY/deltaX pixels, or scroll an element (ref/selector/text) into view.

Select option(s) in a .

Accessibility snapshot of the current page with [ref=eN] handles. Use it before clicking/typing.

List, open (new), select or close tabs by index.

Type into an input/textarea/contenteditable. Replaces its value unless slowly: true (types key by key). submit: true presses Enter.

Upload local file(s) through a file input or an upload button (ref/selector/text).

Wait for a selector or text to appear (state visible/hidden/attached), or just wait timeoutMs.

Fallback dispatcher for a capability present on the live server but missing from a cached client catalog.

List the live MCP capability catalog. Use prefix to filter tool names.

Run the relevant compilers/linters (tsc, eslint, node --check, go vet, gofmt, py_compile, ruff, JSON) on specific files and report problems.

List recent checkpoints (one per file-changing tool call) with the files each one touched.

Undo: restore files to their state before the given checkpoint (default: the latest), undoing it and every later checkpoint.

Invoke a tool the web page itself declares (window.mcp / window.mcp_tools / meta[name=webmcp-tool]). Take a chrome_snapshot first to see the catalog.

Click an element by its [#N] ref using a real (trusted) mouse click via the Chrome debugger; falls back to a DOM click if the debugger cannot attach.

Close a tab.

Console messages and exceptions captured from a tab since the debugger attached to it.

Inspect or answer a JavaScript dialog (alert/confirm/prompt/beforeunload) that is blocking a tab. Dialogs are never accepted automatically: read the message, then accept or dismiss (promptText for prompt()).

Recent Chrome downloads (file path, state, size, source URL, referrer).

Run JavaScript in a tab's page context (via the debugger). Pass an expression; the JSON-serializable result is returned.

Reload the Free Codin Agent Chrome extension from disk (after it was updated) and report the new version.

Visible text of a tab (document.body.innerText, truncated).

List all tabs in the user's real Chrome.

Navigate a tab to an http(s) URL and wait for it to load.

Open a new tab in the real Chrome.

Securely configure or rotate the Chrome bridge pairing token in both the connected extension and .env. The secret is never returned. Restart the MCP worker afterwards to enforce it.

Press a key or chord (e.g. "Enter", "Tab", "Escape", "Control+a") as a trusted key event in the tab.

Screenshot of a tab in the real Chrome (visible viewport). The image is returned so you can see it.

Scroll the inspected tab by y pixels (negative scrolls up).

Semantic snapshot of a tab: interactive elements with [#N] refs, plus page-declared site tools. Take one before clicking or typing.

Connection status of the Chrome extension bridge (the user's real, logged-in Chrome).

Activate a tab and focus its window.

Focus an element by ref and type text with trusted input (replaces the current value unless append: true). submit: true presses Enter afterwards.

Copy a file or directory.

Delete a file, or a directory when recursive is true. Undoable with checkpoint_rewind.

Replace exact text in one file. Either oldText/newText, or edits: [{oldText,newText,replaceAll}] applied atomically in order. oldText must match exactly once unless replaceAll. Reports diagnostics and a checkpoint id.

Fetch a URL (follows redirects) and return readable text. raw: true returns the unprocessed body (useful for JSON/APIs).

Check whether a path exists and get its type, size and modification time.

Find files by glob pattern, e.g. "**/*.test.js" or "package.json".

Find where a function/class/type/method is defined (name or Container.name) and where it is used (whole-word references).

Host info, configured workspaces, default workspace and available integrations. Call this first in a new conversation.

Stage files (all changes by default) and create a commit.

Full unified diff of the working tree (or staged changes, or against a ref), optionally for one file.

Recent commit history.

git status (short) plus diff stat against HEAD.

Cancel a running job (kills its process tree).

Recent background jobs with status.

Read a job log: tail (default 200 lines), a line range (fromLine/lines), or grep (regex with context lines).

Run a long command (test suite, build, install, benchmark) as a background job. Waits up to waitMs (default 25s): if it finishes you get a smart summary (pass/fail counts, failing tests with context, output tail) instead of the raw log; otherwise poll job_status.

Status of a job; waitMs (≤50s) waits for it to finish. Finished jobs return the failure summary.

Kill an OS process tree by PID.

Tree listing of a directory (skips node_modules, .git, build outputs unless includeIgnored).

List OS processes (optionally filtered by name substring).

List configured project workspaces with git branch and number of changed files.

Call hierarchy of the function at file:line: incoming (who calls it) or outgoing (what it calls).

List language-server code actions/quick fixes/refactors for a source range without applying them.

Go to definition (kind: definition | typeDefinition | implementation) of the symbol at file:line (give character or symbol name).

Compiler/type-checker diagnostics from the real language server (gopls, typescript-language-server, pyright) for files or a directory — no VS Code needed. all: true also returns diagnostics the server reported for other files of the project.

Preview language-server formatting edits for a file without applying them.

Type signature and documentation of the symbol at file:line.

All references to the symbol at file:line, resolved by the language server (exact, not text search).

Preview the exact workspace edits a semantic rename would make. Does not write files; apply reviewed changes through apply_patch/edit_file.

Which language servers are installed and running (language, project root, pid).

Symbols: of one file (file), or matching a query across the project (query + path).

Move or rename a file or directory.

All symbols (functions, classes, methods, types) of a file with line numbers, so you can read_file just the part you need. A directory gives a repo map of it.

Write text to stdin of a process started with process_start (REPLs, prompts, interactive CLIs). close: true writes the data and closes stdin.

List background processes started by this bridge.

Read new output from a background process since the last read (or all buffered output with all: true).

Start a long-running background command (dev server, watcher, long build). Returns an id; read logs with process_output, stop with process_stop.

Stop a background process started with process_start (kills its whole process tree).

Start here for any project: detected stack and build/test/lint commands, git state, top-level layout, project instruction files, README start and saved memory notes.

Durable per-project notes shown by project_context in future conversations. action: list | add (note) | remove (index). Save conventions, gotchas and verified commands — not temporary state.

List interactive PTY sessions.

Read new terminal output from a PTY session (or all buffered output with all: true). ANSI escapes are stripped by default.

Resize a PTY terminal.

Start a real interactive terminal backed by Windows ConPTY. Use for REPLs, debuggers, SSH/TUI programs and CLIs that require a terminal. By default starts the configured interactive shell; command runs inside it, or file+args starts an executable directly.

Stop and remove an interactive PTY session.

Write to an interactive PTY. enter: true appends the Enter key.

Read a text file with line numbers. Relative paths resolve against the default workspace. Use startLine/endLine for large files.

Read up to 50 files in one call (strings, or {path,startLine,endLine}). Much faster than several read_file calls.

Render a video clip from code: pass a complete HTML document (CSS/JS/canvas/SVG animation) or a URL; it is played headlessly at the given size for durationMs and saved as mp4/webm/gif. Default 1080x1920 (vertical, Shorts/TikTok/Reels). If the page defines window.startClip(), it is called when recording begins.

Compact map of a codebase: the most-referenced files with their key functions/classes/types and line numbers. Understand a large project in one call. focus: file names or symbols to prioritise.

Current workstation resource pressure and admission-controller slots for commands, builds/tests, LSP, diagnostics, background processes and video work.

Run a shell command (/bin/bash) and wait for it to finish. Returns exitCode, stdout, stderr. Use for builds, tests, git, npm, python, ffmpeg, etc. For servers/watchers that never exit use process_start.

Search file contents with a regex (ripgrep when installed, Node fallback otherwise). Returns path:line: text; context adds surrounding lines.

Add a breakpoint (optionally conditional).

Active debug session and breakpoints.

Live compiler/linter errors and warnings from VS Code language servers (optionally filtered to one file).

All references to the symbol at a position (via the language server).

Definition location of the symbol at a position.

Open a file in VS Code at a line so the user can see it.

Open editor tabs and the active file in VS Code.

Search the web (DuckDuckGo). Returns title, url, snippet for the top results.

Act on a native Windows UI Automation element from windows_snapshot: invoke, setValue, toggle, select, expand, collapse, focus or scrollIntoView. Re-snapshot after meaningful UI changes.

List visible top-level native Windows application windows with process IDs and UI Automation refs.

Capture the visible bounds of a native Windows application window selected semantically by pid/title. Returns the PNG to the client and saves it under screenshots/.

Semantic Windows UI Automation snapshot of a native app window. Returns stable runtime refs, control names/types, supported patterns and bounds. Prefer this over coordinate clicking.

Wait for a semantic native Windows control to appear, become enabled, or disappear. Matches by accessible name substring, AutomationId and/or control type.

Create or fully overwrite a file (parent folders are created). Prefer apply_patch/edit_file for changes to existing files.