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.

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

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

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

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

List background processes started by this bridge.

List OS processes (optionally filtered by name substring).

Kill an OS process tree by PID.

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

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.

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

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

Resize a PTY terminal.

Stop and remove an interactive PTY session.

List interactive PTY sessions.

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.

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

Cancel a running job (kills its process tree).

Recent background jobs with status.

Create a durable provider-neutral agent task. Supports dependencies, exclusive tree leases, idempotency, repair limits, and authoritative verification commands.

Claim one queued/repairing task with an exclusive durable lease. Refuses unmet dependencies, lease conflicts, critical resource pressure, and worker-capacity overflow.

Agent-loop primitive: atomically claim the highest-priority runnable task for this worker. Multiple model clients can call this concurrently; leases prevent two workers owning the same tree.

Renew a running task lease. Long-lived workers should heartbeat before lease expiry.

Worker handoff: mark implementation ready for verification and release the worker lease. The task keeps its tree reserved while verification runs.

Run the task verification gates and apply the verdict durably. Passing gates transition to succeeded; failures transition to repairing until maxRepairRounds is exhausted.

Report a worker failure or interruption while it owns the task. Successful work must go through task_ready then task_verify.

Recover a task left interrupted after restart/lease loss. Requeue it, mark it failed, or explicitly reattach a known-live worker with a fresh lease.

Read the self-contained execution/verification contract for one durable task.

Read the current durable state of one task.

List durable tasks filtered by state/project, ordered by priority then creation time.

Read the append-only task audit trail, optionally for one task.

Read task counts, active workers, configured capacity, and current resource pressure.

Cancel a durable task. A running task requires its current lease; queued/verifying/repairing tasks can be cancelled by id.

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

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.

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.

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.

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

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.

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

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

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

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

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

Copy a file or directory.

Move or rename a file or directory.

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.

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.

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.

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

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 configured project workspaces with git branch and number of changed files.

git status (short) plus diff stat against HEAD.

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

Recent commit history.

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

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

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

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

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

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

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

Select option(s) in a .

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

Hover over an element.

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

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

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

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).

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

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

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

Set the viewport size.

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

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

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.

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.

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

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

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.

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).

List all tabs in the user's real Chrome.

Activate a tab and focus its window.

Open a new tab in the real Chrome.

Close a tab.

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

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

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.

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

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

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

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

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

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

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

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.

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

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.

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.

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

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/.

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.

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

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

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

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

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

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

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

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

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

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 editor tabs and the active file in VS Code.

Active debug session and breakpoints.

Add a breakpoint (optionally conditional).

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

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

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

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