@yash_pandit/mcpconfig 1.0.0

package/dist/add-server-app.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { McpConfig } from './config.js';
+type Props = {
+    writableConfigs: McpConfig[];
+};
+export default function AddServerApp({ writableConfigs }: Props): React.JSX.Element;
+export {};

package/dist/add-server-app.js

@@ -0,0 +1,166 @@
+import React, { useState, useCallback, useMemo } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { addServerToConfig } from './config.js';
+const SELECT_ALL_INDEX = 0;
+const INDICES_OFFSET = 1; // first row is "Select all"
+function parseArgsInput(input) {
+    if (!input.trim())
+        return [];
+    return input.split(',').map((s) => s.trim()).filter(Boolean);
+}
+export default function AddServerApp({ writableConfigs }) {
+    const [step, setStep] = useState('app');
+    const [selectedPaths, setSelectedPaths] = useState(new Set());
+    const [cursorIndex, setCursorIndex] = useState(0);
+    const [name, setName] = useState('');
+    const [command, setCommand] = useState('');
+    const [argsInput, setArgsInput] = useState('');
+    const [errorMessage, setErrorMessage] = useState(null);
+    const maxIndex = writableConfigs.length; // 0 = Select all, 1..n = configs
+    const selectedConfigs = useMemo(() => writableConfigs.filter((c) => selectedPaths.has(c.path)), [writableConfigs, selectedPaths]);
+    const allSelected = writableConfigs.length > 0 && selectedPaths.size === writableConfigs.length;
+    useInput((input, key) => {
+        if (step !== 'app')
+            return;
+        if (key.downArrow) {
+            setCursorIndex((i) => (i < maxIndex ? i + 1 : i));
+        }
+        else if (key.upArrow) {
+            setCursorIndex((i) => (i > 0 ? i - 1 : i));
+        }
+        else if (input === ' ') {
+            if (cursorIndex === SELECT_ALL_INDEX) {
+                setSelectedPaths((prev) => {
+                    if (prev.size === writableConfigs.length)
+                        return new Set();
+                    return new Set(writableConfigs.map((c) => c.path));
+                });
+            }
+            else {
+                const config = writableConfigs[cursorIndex - INDICES_OFFSET];
+                if (config) {
+                    setSelectedPaths((prev) => {
+                        const next = new Set(prev);
+                        if (next.has(config.path))
+                            next.delete(config.path);
+                        else
+                            next.add(config.path);
+                        return next;
+                    });
+                }
+            }
+        }
+        else if (key.return && selectedConfigs.length > 0) {
+            setStep('name');
+        }
+    }, { isActive: step === 'app' });
+    const handleNameSubmit = useCallback((value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        setName(trimmed);
+        setStep('command');
+    }, []);
+    const handleCommandSubmit = useCallback((value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        setCommand(trimmed);
+        setStep('args');
+    }, []);
+    const handleArgsSubmit = useCallback((value) => {
+        if (selectedConfigs.length === 0)
+            return;
+        const args = parseArgsInput(value);
+        const server = { name, command, args: args.length > 0 ? args : undefined };
+        try {
+            for (const config of selectedConfigs) {
+                addServerToConfig(config.path, server);
+            }
+            setStep('done');
+        }
+        catch (err) {
+            setErrorMessage(err instanceof Error ? err.message : String(err));
+            setStep('error');
+        }
+    }, [selectedConfigs, name, command]);
+    if (writableConfigs.length === 0) {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { color: "yellow" }, "No writable MCP configs found."),
+            React.createElement(Text, { dimColor: true }, "Run `mcpconfig list-configs` to see which configs exist. Add-server supports JSON and Codex TOML configs.")));
+    }
+    if (step === 'app') {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Select apps to add the server to (Space to toggle, Enter to confirm)"),
+            React.createElement(Text, { dimColor: true }, "\u2191/\u2193 move \u00B7 Space toggle \u00B7 Enter continue"),
+            React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: cursorIndex === SELECT_ALL_INDEX ? 'cyan' : undefined },
+                        cursorIndex === SELECT_ALL_INDEX ? '❯ ' : '  ',
+                        allSelected ? '◉' : '○',
+                        " Select all")),
+                writableConfigs.map((c, i) => {
+                    const rowIndex = i + INDICES_OFFSET;
+                    const isSelected = selectedPaths.has(c.path);
+                    const isFocused = cursorIndex === rowIndex;
+                    return (React.createElement(Box, { key: c.path },
+                        React.createElement(Text, { color: isFocused ? 'cyan' : undefined },
+                            isFocused ? '❯ ' : '  ',
+                            isSelected ? '◉' : '○',
+                            " ",
+                            c.name),
+                        React.createElement(Text, { dimColor: true },
+                            " (",
+                            c.path,
+                            ")")));
+                })),
+            selectedConfigs.length > 0 && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    selectedConfigs.length,
+                    " selected \u2014 press Enter to continue")))));
+    }
+    if (step === 'name') {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Server name"),
+            React.createElement(Text, { dimColor: true }, "Unique key for this MCP server (e.g. my-mcp-server)"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(TextInput, { value: name, onChange: setName, onSubmit: handleNameSubmit, placeholder: "server-name", focus: true }))));
+    }
+    if (step === 'command') {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Command"),
+            React.createElement(Text, { dimColor: true }, "Executable to run (e.g. npx, python, node)"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(TextInput, { value: command, onChange: setCommand, onSubmit: handleCommandSubmit, placeholder: "npx", focus: true }))));
+    }
+    if (step === 'args') {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { bold: true }, "Arguments (comma-separated)"),
+            React.createElement(Text, { dimColor: true }, "Optional: args passed to the command (e.g. -y, /path/to/script.js)"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(TextInput, { value: argsInput, onChange: setArgsInput, onSubmit: handleArgsSubmit, placeholder: "arg1, arg2", focus: true }))));
+    }
+    if (step === 'error') {
+        return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+            React.createElement(Text, { color: "red", bold: true }, "Error"),
+            React.createElement(Text, { color: "red" }, errorMessage)));
+    }
+    // step === 'done'
+    return (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+        React.createElement(Text, { color: "green", bold: true },
+            "\u2713 Server added to ",
+            selectedConfigs.length,
+            " config(s)"),
+        React.createElement(Text, { dimColor: true },
+            "  Name: ",
+            name),
+        React.createElement(Text, { dimColor: true },
+            "  Command: ",
+            command),
+        selectedConfigs.map((c) => (React.createElement(Text, { key: c.path, dimColor: true },
+            "  \u00B7 ",
+            c.name,
+            ": ",
+            c.path)))));
+}

package/dist/app.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type McpConfig = {
+    name: string;
+    path: string;
+    found: boolean;
+};
+type Props = {
+    mcpConfigs: McpConfig[];
+};
+export default function App({ mcpConfigs }: Props): React.JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Text, Box } from 'ink';
+const CHECK = '✓';
+const CROSS = '✗';
+export default function App({ mcpConfigs = [] }) {
+    const nameWidth = Math.max(14, ...mcpConfigs.map((c) => c.name.length));
+    return (React.createElement(Box, { flexDirection: "column", padding: 0, marginTop: 1 },
+        React.createElement(Text, { bold: true, dimColor: true }, "MCP configs"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, mcpConfigs.map((config) => (React.createElement(Box, { key: config.path, flexDirection: "column", marginBottom: 1 },
+            React.createElement(Box, null,
+                React.createElement(Text, null,
+                    config.name.padEnd(nameWidth),
+                    " "),
+                React.createElement(Text, { color: config.found ? 'green' : 'red', bold: config.found }, config.found ? CHECK : CROSS)),
+            config.found && (React.createElement(Text, { dimColor: true },
+                "  ",
+                config.path))))))));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import TOML from '@iarna/toml';
+import App from './app.js';
+import ServersApp from './servers-app.js';
+import AddServerApp from './add-server-app.js';
+import { getMcpConfigs, getWritableConfigs } from './config.js';
+function parseServersFromConfig(configPath, raw) {
+    const ext = path.extname(configPath).toLowerCase();
+    if (ext === '.toml') {
+        // Codex config.toml: [mcp_servers.<name>] with command and args
+        // https://developers.openai.com/codex/config-reference/
+        try {
+            const data = TOML.parse(raw);
+            const mcpServers = data.mcp_servers ?? {};
+            return Object.entries(mcpServers).map(([name, entry]) => ({
+                name,
+                command: typeof entry?.command === 'string' ? entry.command : undefined,
+                args: Array.isArray(entry?.args) ? entry.args : undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    // JSON: mcpServers object (Claude Desktop, Cursor, Cline, etc.)
+    try {
+        const data = JSON.parse(raw);
+        const mcpServers = data.mcpServers ?? {};
+        return Object.entries(mcpServers).map(([name, entry]) => ({
+            name,
+            command: typeof entry?.command === 'string' ? entry.command : undefined,
+            args: Array.isArray(entry?.args) ? entry.args : undefined,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+const cli = meow(`
+	Usage
+	  $ mcpconfig <command> [options]
+
+	Commands
+	  list-configs   List MCP configs (found only, unless --all)
+	  list-servers   List MCP servers from found JSON and Codex TOML configs
+	  add-server     Interactively add an MCP server to a config (JSON or Codex TOML)
+
+	Options
+	  --all   (list-configs only) Show all configs (found and not found)
+
+	Examples
+	  $ mcpconfig list-configs
+	  $ mcpconfig list-configs --all
+	  $ mcpconfig list-servers
+	  $ mcpconfig add-server
+`, {
+    importMeta: import.meta,
+    flags: {
+        all: {
+            type: 'boolean',
+            shortFlag: 'a',
+        },
+    },
+});
+const [command] = cli.input;
+if (!command) {
+    cli.showHelp(0);
+}
+const allowedCommands = ['list-configs', 'list-servers', 'add-server'];
+if (!allowedCommands.includes(command)) {
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}
+const home = os.homedir();
+const mcpConfigs = getMcpConfigs(home);
+const configsToShow = cli.flags.all ? mcpConfigs : mcpConfigs.filter((c) => c.found);
+if (command === 'add-server') {
+    const writableConfigs = getWritableConfigs(home);
+    render(React.createElement(AddServerApp, { writableConfigs: writableConfigs }));
+}
+else if (command === 'list-servers') {
+    // Configs we can extract servers from: JSON (mcpServers) or Codex TOML (mcp_servers)
+    const configsWithServers = mcpConfigs.filter((c) => c.found &&
+        (c.path.endsWith('.json') || (c.path.endsWith('.toml') && c.path.includes('.codex'))));
+    const serverLists = configsWithServers.map((config) => {
+        let servers = [];
+        try {
+            const raw = fs.readFileSync(config.path, 'utf8');
+            servers = parseServersFromConfig(config.path, raw);
+        }
+        catch {
+            // File read or parse error: leave servers empty
+        }
+        return { appName: config.name, configPath: config.path, servers };
+    });
+    render(React.createElement(ServersApp, { serverLists: serverLists }));
+}
+else {
+    render(React.createElement(App, { mcpConfigs: configsToShow }));
+}

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+export type McpConfig = {
+    name: string;
+    path: string;
+    found: boolean;
+};
+export type ServerEntry = {
+    name: string;
+    command?: string;
+    args?: string[];
+};
+export declare function getMcpConfigs(home?: string): McpConfig[];
+/** Configs we can add servers to: found and (JSON or Codex TOML). */
+export declare function getWritableConfigs(home?: string): McpConfig[];
+/** Add a server to a config file. Handles JSON (mcpServers) and Codex TOML (mcp_servers). */
+export declare function addServerToConfig(configPath: string, server: ServerEntry): void;

package/dist/config.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import TOML from '@iarna/toml';
+const MCP_CONFIGS = [
+    { segments: ['Library', 'Application Support', 'Claude'], filename: 'claude_desktop_config.json', name: 'Claude Desktop' },
+    { segments: ['.codex'], filename: 'config.toml', name: 'OpenAI Codex' },
+    { segments: ['.cursor'], filename: 'mcp.json', name: 'Cursor' },
+    { segments: ['.cline', 'data', 'settings'], filename: 'cline_mcp_settings.json', name: 'Cline' },
+    { segments: ['Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings'], filename: 'mcp_settings.json', name: 'Roo Code' },
+    { segments: ['.codeium', 'windsurf'], filename: 'mcp_config.json', name: 'Windsurf' },
+    { segments: ['.config', 'zed'], filename: 'settings.json', name: 'Zed' },
+    { segments: ['.config', 'cody'], filename: 'mcp_servers.json', name: 'Cody' },
+    { segments: ['.config', 'goose'], filename: 'config.yaml', name: 'Goose' },
+    { segments: ['.continue'], filename: 'config.yaml', name: 'Continue.dev' },
+    { segments: ['.junie', 'mcp'], filename: 'mcp.json', name: 'Junie CLI' },
+];
+export function getMcpConfigs(home = os.homedir()) {
+    return MCP_CONFIGS.map(({ segments, filename, name }) => {
+        const fullPath = path.join(home, ...segments, filename);
+        return { name, path: fullPath, found: fs.existsSync(fullPath) };
+    });
+}
+/** Configs we can add servers to: found and (JSON or Codex TOML). */
+export function getWritableConfigs(home = os.homedir()) {
+    const all = getMcpConfigs(home);
+    return all.filter((c) => c.found &&
+        (c.path.endsWith('.json') || (c.path.endsWith('.toml') && c.path.includes('.codex'))));
+}
+/** Add a server to a config file. Handles JSON (mcpServers) and Codex TOML (mcp_servers). */
+export function addServerToConfig(configPath, server) {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const ext = path.extname(configPath).toLowerCase();
+    if (ext === '.toml') {
+        const data = TOML.parse(raw);
+        if (!data['mcp_servers'] || typeof data['mcp_servers'] !== 'object') {
+            data['mcp_servers'] = {};
+        }
+        const mcpServers = data['mcp_servers'];
+        mcpServers[server.name] = {
+            command: server.command ?? '',
+            args: server.args?.length ? server.args : undefined,
+        };
+        fs.writeFileSync(configPath, TOML.stringify(data), 'utf8');
+        return;
+    }
+    // JSON
+    const data = JSON.parse(raw);
+    if (!data['mcpServers'] || typeof data['mcpServers'] !== 'object') {
+        data['mcpServers'] = {};
+    }
+    const mcpServers = data['mcpServers'];
+    mcpServers[server.name] = {
+        command: server.command ?? '',
+        ...(server.args?.length ? { args: server.args } : {}),
+    };
+    fs.writeFileSync(configPath, JSON.stringify(data, null, 2), 'utf8');
+}

package/dist/servers-app.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export type ServerEntry = {
+    name: string;
+    command?: string;
+    args?: string[];
+};
+export type ServerList = {
+    appName: string;
+    configPath: string;
+    servers: ServerEntry[];
+};
+type Props = {
+    serverLists: ServerList[];
+};
+export default function ServersApp({ serverLists }: Props): React.JSX.Element;
+export {};

package/dist/servers-app.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import { Text, Box } from 'ink';
+function formatArgs(server) {
+    if (!Array.isArray(server.args) || server.args.length === 0)
+        return '—';
+    return server.args.join(' ');
+}
+export default function ServersApp({ serverLists = [] }) {
+    const rows = [];
+    for (const { appName, servers } of serverLists) {
+        for (const server of servers) {
+            rows.push({
+                app: appName,
+                server: server.name,
+                command: server.command ?? '—',
+                args: formatArgs(server),
+            });
+        }
+    }
+    if (rows.length === 0) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 0, marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "No MCP servers in found configs.")));
+    }
+    const appWidth = Math.max(14, ...rows.map((r) => r.app.length));
+    const serverWidth = Math.max(6, ...rows.map((r) => r.server.length));
+    const commandWidth = Math.max(7, ...rows.map((r) => r.command.length));
+    const header = `${'APP'.padEnd(appWidth + 1)}${'SERVER'.padEnd(serverWidth + 1)}${'COMMAND'.padEnd(commandWidth + 1)}ARGS`;
+    return (React.createElement(Box, { flexDirection: "column", padding: 0, marginTop: 1 },
+        React.createElement(Text, { bold: true, dimColor: true }, header),
+        rows.map((row, i) => {
+            const line = `${row.app.padEnd(appWidth + 1)}${row.server.padEnd(serverWidth + 1)}${row.command.padEnd(commandWidth + 1)}${row.args}`;
+            return React.createElement(Text, { key: `${row.app}-${row.server}-${i}` }, line);
+        })));
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+	"name": "@yash_pandit/mcpconfig",
+	"version": "1.0.0",
+	"description": "CLI to discover and inspect MCP (Model Context Protocol) configs and servers across Claude Desktop, Cursor, Codex, Cline, and more",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/YashPandit4u/mcpconfig.git"
+	},
+	"homepage": "https://github.com/YashPandit4u/mcpconfig#readme",
+	"bugs": "https://github.com/YashPandit4u/mcpconfig/issues",
+	"keywords": [
+		"mcp",
+		"model-context-protocol",
+		"claude",
+		"cursor",
+		"codex",
+		"cline",
+		"cli"
+	],
+	"bin": {
+		"mcpconfig": "dist/cli.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"start": "node dist/cli.js",
+		"prepublishOnly": "npm run build",
+		"test": "prettier --check . && xo && ava"
+	},
+	"files": [
+		"dist",
+		"readme.md"
+	],
+	"dependencies": {
+		"@iarna/toml": "^2.2.5",
+		"ink": "^4.1.0",
+		"ink-select-input": "^5.0.0",
+		"ink-text-input": "^5.0.1",
+		"meow": "^11.0.0",
+		"react": "^18.2.0"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/node": "^25.3.5",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.53.1"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}

package/readme.md

@@ -0,0 +1,148 @@
+# mcpconfig
+
+**A CLI to discover and inspect MCP (Model Context Protocol) configs and servers across your AI coding tools.**
+
+If you use Claude Desktop, Cursor, Codex, Cline, or similar apps, each one stores its MCP configuration in a different place. **mcpconfig** finds those config files and lists them—and can show every MCP server (name, command, args) from all of them in one view.
+
+---
+
+## What is MCP?
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) is a standard that lets AI assistants connect to external tools and data sources (files, databases, APIs). Many AI coding apps support MCP via a config file where you declare “servers” (each with a command and optional args). mcpconfig does not run or manage those servers; it only **lists where configs live** and **what servers are defined** in them.
+
+---
+
+## Features
+
+- **List config locations** — See which MCP config files exist on your system and their full paths. Optionally show all known locations (including ones that don’t exist yet).
+- **List servers across configs** — For every found JSON config and Codex TOML, show a combined table of app name, server name, command, and args so you can compare setups at a glance.
+- **Add a server interactively** — Run `add-server` to select one or more apps (multi-select with “Select all”), then enter server name, command, and args; mcpconfig writes to every selected config (JSON or Codex TOML) per each app’s spec.
+- **Multi-app support** — Knows the default config paths for Claude Desktop, Cursor, Codex, Cline, Roo Code, Windsurf, Zed, Cody, Goose, Continue.dev, and Junie CLI.
+
+---
+
+## Requirements
+
+- **Node.js** 16 or newer
+
+---
+
+## Install
+
+**Global install** (recommended if you want the `mcpconfig` command everywhere):
+
+```bash
+npm install --global mcpconfig
+```
+
+**Run without installing** (e.g. try it once or use in scripts):
+
+```bash
+npx mcpconfig list-configs
+npx mcpconfig list-servers
+```
+
+**From source** (clone the repo, then):
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+After `npm link`, `mcpconfig` is available globally from your dev build. You can also run the built CLI with `npm start` or `node dist/cli.js`.
+
+---
+
+## Usage
+
+```bash
+mcpconfig <command> [options]
+```
+
+### Commands
+
+| Command         | Description |
+|----------------|-------------|
+| `list-configs` | List MCP config file locations. By default shows only configs that were **found** on disk. |
+| `list-servers` | Read all found **JSON** configs and **Codex** `config.toml`, extract MCP servers (`mcpServers` or `mcp_servers`), and print a table: app name, server name, command, args. |
+| `add-server`   | Interactive flow: select one or more apps (↑/↓ move, Space toggle, “Select all” option, Enter to confirm), then enter server name, command, and args. Writes to every selected config (JSON or Codex TOML) per spec. |
+
+### Options
+
+| Option     | Short | Description |
+|-----------|-------|-------------|
+| `--all`   | `-a`  | **Only for `list-configs`.** Show every known config location (found and not found). |
+
+### Examples
+
+```bash
+# See which MCP configs exist and where they are
+mcpconfig list-configs
+
+# See all known config locations (including missing ones)
+mcpconfig list-configs --all
+
+# See all MCP servers from every found JSON config in one table
+mcpconfig list-servers
+
+# Interactively add an MCP server to a config (choose app, then name, command, args)
+mcpconfig add-server
+```
+
+**`list-configs`** prints one line per config: app name, ✓ or ✗ (found or not), and the full path when found.
+
+**`list-servers`** prints a table with columns: **APP**, **SERVER**, **COMMAND**, **ARGS**. JSON configs use the `mcpServers` key; Codex uses `~/.codex/config.toml` and the `[mcp_servers.<name>]` tables per the [Codex config reference](https://developers.openai.com/codex/config-reference/). Other TOML/YAML configs are not parsed for servers.
+
+**`add-server`** shows only configs that exist and support adding servers (JSON and Codex TOML). You can select multiple apps: use **↑/↓** to move, **Space** to toggle each app (or “Select all”), then **Enter** to continue. You’re then prompted for **name**, **command**, and **args** (comma-separated). The new server is written to every selected config; JSON gets a `mcpServers` entry and Codex TOML gets an `[mcp_servers.<name>]` section.
+
+---
+
+## Supported apps and config paths
+
+mcpconfig looks for these files under your home directory:
+
+| App              | Config path (relative to `~`) |
+|------------------|-------------------------------|
+| Claude Desktop   | `Library/Application Support/Claude/claude_desktop_config.json` |
+| OpenAI Codex     | `.codex/config.toml` |
+| Cursor           | `.cursor/mcp.json` |
+| Cline            | `.cline/data/settings/cline_mcp_settings.json` |
+| Roo Code         | `Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json` |
+| Windsurf         | `.codeium/windsurf/mcp_config.json` |
+| Zed              | `.config/zed/settings.json` |
+| Cody             | `.config/cody/mcp_servers.json` |
+| Goose            | `.config/goose/config.yaml` |
+| Continue.dev     | `.continue/config.yaml` |
+| Junie CLI        | `.junie/mcp/mcp.json` |
+
+Only **JSON** configs are used for `list-servers`; the tool expects an `mcpServers` object in them. TOML/YAML apps are listed by `list-configs` but not parsed for servers.
+
+---
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build TypeScript → dist/
+npm run build
+
+# Watch mode (rebuild on file changes)
+npm run dev
+
+# Run the CLI from the built output
+npm start
+# or
+npx mcpconfig list-configs
+
+# Lint and test
+npm test
+```
+
+---
+
+## License
+
+MIT