GuideMCPConfig on disk

MCP server list, the one on your disk

Top results for this query are directories of third-party MCP servers. Useful, but they are not your list. Your list is a JSON file sitting in a client-specific path on your machine. If you use Cursor, it is at ~/.cursor/mcp.json. If you use Claude Desktop on macOS, it is at ~/Library/Application Support/Claude/claude_desktop_config.json. Twelve clients, twelve paths, one map inside Terminator's installer source.

T
Terminator
10 min read
4.9from Open-source, MIT
Two senses of 'MCP server list' — your client's list on disk, and the tool list a server returns
12 client paths mapped in crates/terminator-mcp-agent/config.js
VS Code and VS Code Insiders special-cased as command targets (code --add-mcp)
Terminator's own list: 31 tools, generated at compile time by build.rs

Two things people mean by "MCP server list"

The phrase is overloaded. The first sense is the list of MCP servers your client is configured to talk to. That list is a JSON file on your disk, one per client, at a path the client fixes. It is the thing you edit when you want your editor to start spawning a new server. The second sense is the list of tools a single MCP server returns when the client asks for them. That list is not a file; it is a JSON-RPC response the server produces at boot time.

Both matter and both are worth seeing with the source open. The rest of this page walks through both, using the Terminator source as the reference implementation. The first list, because Terminator ships an installer that knows where 12 clients keep theirs. The second list, because Terminator's is code-generated at compile time and reliable to enumerate.

0MCP clients mapped in config.js
0Target kinds: file + command
0Tools in Terminator's server list
0Port the Chrome bridge listens on

Clients the Terminator installer can write to

CursorClaude DesktopClaude CodeVS CodeVS Code InsidersWindsurfClineRooCodeWitsyEnconvoBoltAIAmazon BedrockAmazon Q

The anchor: twelve clients, twelve paths

Inside the Terminator MCP agent's npm package, alongside the Rust binary and the JS wrapper, there is a file called crates/terminator-mcp-agent/config.js. The single most load-bearing object in that file is clientPaths, defined between lines 50 and 100. It encodes where every supported MCP client keeps its server list.

crates/terminator-mcp-agent/config.js

Read that object carefully: every entry has a type, either file (most clients) or command (VS Code and VS Code Insiders). File targets get their JSON merged in place. Command targets get an execFileSync call: the installer runs code --add-mcp <json> because VS Code owns the list and does not expose a stable file path. That asymmetry is the single most practically useful detail in the map.

Verify in 10 seconds: clone mediar-ai/terminator and run grep -nE 'type:\s*"(file|command)"' crates/terminator-mcp-agent/config.js. You will see twelve matches, two of them command targets. Then grep -n supportedClients crates/terminator-mcp-agent/config.js to see the final array of client keys the --add-to-app picker shows.

Every client's list, at the path the client expects

These are not the paths as we wish they were. These are the paths the open-source installer writes to, because these are the paths the clients read from. Everything below is drawn from config.js; check the source if anything surprises you.

Cursor

Single-file JSON at ~/.cursor/mcp.json. Edit it directly or use the installer; the mcpServers key is the server list.

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json. Windows: %APPDATA%\Claude\claude_desktop_config.json. Restart the app after editing.

VS Code + Insiders

No stable JSON path; the editor owns the list. Installer shells out to code --add-mcp <json> (or code-insiders). That is why config.js marks these entries type: command.

Windsurf

~/.codeium/windsurf/mcp_config.json. Same mcpServers shape as Claude and Cursor.

Cline

Deep inside VS Code globalStorage: saoudrizwan.claude-dev/settings/cline_mcp_settings.json. The installer reaches into VS Code's config dir to find it.

RooCode

Same idea as Cline: rooveterinaryinc.roo-cline/settings/mcp_settings.json under VS Code globalStorage.

Witsy, Enconvo, BoltAI

Each has its own home-dir path: Witsy in Application Support/Witsy/settings.json, Enconvo in ~/.config/enconvo/mcp_config.json, BoltAI in ~/.boltai/mcp.json.

Amazon Bedrock + Amazon Q

Bedrock: ~/Amazon Bedrock Client/mcp_config.json. Q: ~/.aws/amazonq/mcp.json. The AWS lineage shows in the paths.

What a server list file actually looks like

Despite the path differences, the shape is consistent. A server list is a JSON object with one top-level key: mcpServers. Inside it, each key is a server name (the label your client will show) and each value is a spawn descriptor with command and args. The client spawns the process, speaks MCP over its stdio, and shows whatever tools/list returns.

claude_desktop_config.json

How --add-to-app routes one server to many lists

Same installer, same entry being written, many destinations. The hub is --add-to-app. The left side is which client you picked. The right side is the file or command it resolves to.

--add-to-app resolves a client to a list target

--add-to-app claude
--add-to-app cursor
--add-to-app vscode
--add-to-app windsurf
--add-to-app cline
writeConfig()
~/Library/.../Claude/claude_desktop_config.json
~/.cursor/mcp.json
code --add-mcp <json>
~/.codeium/windsurf/mcp_config.json
VS Code globalStorage/.../cline_mcp_settings.json

Adding a server to your list, in practice

The installer is an interactive picker, but every choice it offers traces back to one of the 12 entries in clientPaths. If the entry is a file, the installer merges into it. If it is a command, the installer shells out. Either way, after the picker finishes, your client's list contains one more server.

terminator-mcp-agent --add-to-app

The full path, from the two senses of the word

The first list (on disk, per client) is what gets you a running server. The second list (tools, per server) is what the LLM actually dispatches against.

1

List, in the client sense, exists as a JSON file on disk

Before anything else: your client keeps an MCP server list as a JSON object at a known path. For Cursor it is ~/.cursor/mcp.json. For Claude Desktop it is in Application Support. For VS Code it is internal.

2

Installer reads its 12-client map

crates/terminator-mcp-agent/config.js defines clientPaths with 12 entries. Running npx -y terminator-mcp-agent@latest --add-to-app prompts you to pick one.

3

Write the file (or shell out for VS Code)

For file-type entries the installer merges a new mcpServers entry into the existing JSON. For command-type entries (vscode, vscode-insiders) it runs code --add-mcp <json> because the editor owns the list.

4

Restart the client, watch it discover the server

On boot, the client reads its list, spawns terminator-mcp-agent as a child process, and sends initialize. The server replies with its tool list, the other sense of MCP server list.

5

Tool list is also code-generated

build.rs at crates/terminator-mcp-agent/build.rs walks src/server.rs, collects every "tool_name" => match arm, and bakes a comma-separated list into the binary as MCP_TOOLS. prompt.rs reads env!("MCP_TOOLS") at startup so the system prompt and dispatch function cannot drift.

The other list: what Terminator's server returns

Once your client has spawned Terminator as a child process, it sends initialize then tools/list. The server's reply is the second meaning of MCP server list. Terminator's returns 31 entries. The names in the reply are the exact same strings in the match tool_name block at line 9953 of server.rs, because they are extracted from it at build time.

response to tools/list (abridged)

The 31 tools, grouped by what they unlock

A server list is usually just names. Below the names: six real capability groups an LLM can mix inside a single execute_sequence call.

Discovery

get_window_tree, get_applications_and_windows_list, validate_element, wait_for_element. Read-only probes for what is on screen before you touch anything.

Action

click_element, type_into_element, press_key, press_key_global, invoke_element, set_value, set_selected, select_option, scroll_element, mouse_drag. The verbs the LLM picks to move a UI.

Browser bridge

navigate_browser and execute_browser_script, routed through Terminator's MV3 Chrome extension on ws://127.0.0.1:17373. DOM-level access from the same dispatch block as the native arms.

Filesystem

read_file, write_file, edit_file, copy_content, glob_files, grep_files. The server is also a typed filesystem, so workflows can read YAML inputs and write reports.

Escape hatches

run_command (shell or embedded JS/Python/Node), gemini_computer_use (vision-based agentic loop). For the cases where accessibility trees are not enough.

Orchestration

execute_sequence stitches any of the other 30 into a YAML pipeline. stop_execution cancels in flight. delay pads between actions. activate_element brings a window forward.

31

build.rs scans server.rs at compile time, collects every "tool_name" => match arm, and bakes the list into the binary via cargo:rustc-env=MCP_TOOLS. prompt.rs reads env!("MCP_TOOLS") so the system prompt, the dispatcher, and the tools/list response all read from the same source of truth.

crates/terminator-mcp-agent/build.rs line 31

Verifying the server's own list

The authoritative answer to "what does this MCP server expose" is the JSON-RPC reply to tools/list. Two ways to see it without writing a client:

inspect the list a server returns

Two numbers that anchor this page

0
MCP client paths encoded in config.js clientPaths (including two command-target exceptions for VS Code)
0
Tools Terminator's server returns to tools/list, generated at compile time from the dispatch match block

Directory vs. disk, side by side

If you came here from the top SERP results, you were probably looking at a directory of third-party servers. This table is why your local list is a different thing, and why the Terminator installer handles both senses of the phrase.

FeatureOnline directory of MCP serversOn-disk MCP server list (Terminator installer)
What kind of list?A curated directory of third-party MCP servers on a websiteThe literal JSON array in your client's config file, plus the per-tool list a server returns over JSON-RPC
Where does it live?In a web page's databaseOn your disk at a client-specific path (Cursor: ~/.cursor/mcp.json, Claude: ~/Library/Application Support/Claude/claude_desktop_config.json, etc.)
How many clients are mapped?Not applicable (directories are client-agnostic)12 clients in crates/terminator-mcp-agent/config.js: Claude, Cursor, VS Code, VS Code Insiders, Windsurf, Cline, RooCode, Witsy, Enconvo, BoltAI, Amazon Bedrock, Amazon Q
How does the installer write to VS Code?Would expect a shared JSON pathSpecial-cased as { type: "command", command: "code" }; shells out to code --add-mcp <json> because VS Code owns the list itself
How is the 31-tool list kept in sync?Maintained manually in a wikibuild.rs walks server.rs at compile time, scans for "tool_name" => match arms, bakes them into the binary via cargo:rustc-env=MCP_TOOLS, prompt.rs reads env!("MCP_TOOLS") at startup so the system prompt and dispatcher cannot drift
Multi-client installCopy-paste the same JSON into every client manuallynpx -y terminator-mcp-agent@latest --add-to-app prompts for a client and writes the correct file or runs the correct command
Answers 'what tools does this server expose'?Sometimes, for well-documented servers, via a web pageLive, over the wire: POST a tools/list JSON-RPC frame and the server returns the same 31 names its own dispatcher matches against

Questions about MCP server lists

What is an MCP server list?

Two things share the phrase. First sense: your MCP client's list of servers it knows about, stored as a JSON file on disk at a client-specific path (Cursor uses ~/.cursor/mcp.json, Claude Desktop uses ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, Windsurf uses ~/.codeium/windsurf/mcp_config.json, and so on). Second sense: the list of tools a single MCP server exposes, returned over JSON-RPC 2.0 when the client sends a tools/list method. Both are literal lists. Neither is a marketing directory. If you are searching for 'mcp server list' hoping to see tools a specific server exposes, this page shows Terminator's 31-entry tool list below. If you are looking for where your own client stores its list, the 12-path map is also here.

Where does each MCP client store its server list on disk?

From crates/terminator-mcp-agent/config.js lines 50 to 100: Cursor uses ~/.cursor/mcp.json. Claude Desktop uses ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows. Windsurf uses ~/.codeium/windsurf/mcp_config.json. Cline lives inside VS Code globalStorage under saoudrizwan.claude-dev/settings/cline_mcp_settings.json. RooCode is also under VS Code globalStorage at rooveterinaryinc.roo-cline/settings/mcp_settings.json. Witsy uses Application Support/Witsy/settings.json. Enconvo uses ~/.config/enconvo/mcp_config.json. BoltAI uses ~/.boltai/mcp.json. Amazon Bedrock uses ~/Amazon Bedrock Client/mcp_config.json. Amazon Q uses ~/.aws/amazonq/mcp.json. VS Code and VS Code Insiders are the two exceptions: there is no stable JSON path, so the installer shells out to code --add-mcp or code-insiders --add-mcp instead.

Why does VS Code not get a JSON path?

Because VS Code owns its MCP list internally and exposes a stable CLI flag instead. Look at line 82 of config.js: the vscode entry is { type: 'command', command: 'code' }. When you pick vscode in the --add-to-app wizard, the installer runs code --add-mcp <json-string> instead of touching a file. The vscode-insiders entry does the same with code-insiders. This is why config.js has two type kinds: file targets get their JSON merged in-place, command targets get an execFileSync call.

What does a minimal MCP server list file look like?

A flat JSON object with an mcpServers key. Every client listed above shares this shape. Example: { "mcpServers": { "terminator-mcp-agent": { "command": "npx", "args": ["-y", "terminator-mcp-agent@latest"] } } }. Each entry is a key (the server name your client will show in its UI) mapped to an object with command and args. The command is the executable the client spawns as a child process; it speaks MCP over that child's stdin and stdout. You can add as many entries as you like; the client reads the whole list at startup and spawns one subprocess per entry.

How is Terminator's own tool list generated and where is it?

At compile time, by the build script. crates/terminator-mcp-agent/build.rs line 31 has a function extract_mcp_tools() that reads src/server.rs, scrolls until it finds the line containing 'let result = match tool_name', and then collects every string literal that matches the 'tool_name' => match arm pattern. It filters for lowercase-and-underscore names, deduplicates, joins with commas, and emits cargo:rustc-env=MCP_TOOLS=<list> so the value is baked into the binary. prompt.rs line 10 does let mcp_tools = env!("MCP_TOOLS") and pastes the list into the system instructions at line 99. The result: the tool list the LLM sees, the list the dispatcher matches against, and the list the build scanner extracts are always the same list, because they are all read from the same place in server.rs.

Which tools does Terminator's MCP server expose?

Thirty-one: get_window_tree, get_applications_and_windows_list, click_element, type_into_element, press_key, press_key_global, validate_element, wait_for_element, activate_element, navigate_browser, execute_browser_script, open_application, scroll_element, delay, run_command, mouse_drag, highlight_element, select_option, set_selected, invoke_element, set_value, execute_sequence, stop_highlighting, stop_execution, gemini_computer_use, read_file, write_file, edit_file, copy_content, glob_files, grep_files. Five groups: discovery (read the tree), action (click or type), browser bridge (DOM access via the Terminator Bridge extension), filesystem (typed file ops), orchestration (execute_sequence plus stop), and two escape hatches (run_command and gemini_computer_use).

How do I verify the tool list a server actually returns, without trusting its docs?

Use the MCP Inspector or a JSON-RPC client directly. npx @modelcontextprotocol/inspector npx terminator-mcp-agent@latest starts a web UI that connects to the server over stdio and shows the live tools/list response. For raw verification, spawn the server yourself and send it a JSON-RPC frame: { "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} }. The response contains a tools array with name and description for every entry. This is authoritative in a way a docs page is not; you are reading the list the server itself produces at boot.

Can I have two MCP servers with the same name in my list?

No. The JSON object key is the name; object keys cannot repeat. If you add terminator-mcp-agent twice, the second overwrites the first. This is also why the installer's writeConfigFile function reads the existing config, merges a new entry into mcpServers, and writes the result back: it is a dictionary merge, not an append. If you want two instances of the same server (for example, one on stdio and one on HTTP), give them different keys.

Does every MCP client support every server in its list?

Functionally yes, protocol-wise. If the server speaks Model Context Protocol correctly over its declared transport (stdio or HTTP), every compliant client can list its tools and dispatch calls. Ergonomically the clients differ. Claude Desktop and Cursor render the tool list as a sidebar. Claude Code shows it via claude mcp list. VS Code surfaces MCP servers in its extensions model. Cline and RooCode expose the list in their respective panels. The underlying list of servers in the JSON file is identical in shape across clients; the client's UI is what changes.

Why does Terminator publish an installer instead of asking users to edit the JSON?

Because the 12-path map is what users would otherwise have to memorize. Finding Claude Desktop's config on Windows at %APPDATA%\Claude\claude_desktop_config.json is not the same keystroke as finding it on macOS at ~/Library/Application Support/Claude/claude_desktop_config.json, and neither matches the VS Code --add-mcp flow. config.js in the agent's npm package encodes all 12 of those resolutions so one command, --add-to-app, writes to the correct file or runs the correct CLI. Users do not have to learn the map; the installer already knows it. That file is the anchor of this page.

Add Terminator to whichever list you use

One command, twelve clients. The installer knows the path, writes the file, or shells out to VS Code. You get 31 desktop-automation tools in your MCP list.

Install from GitHub
terminatorDesktop automation SDK
© 2026 terminator. All rights reserved.