sync-project-mcps 1.0.2 → 1.2.0

package/README.md

@@ -61,8 +61,11 @@ npx -y sync-project-mcps@latest -v
 | **Cursor** | `.cursor/mcp.json` | Project |
 | **Claude Code** | `.mcp.json` | Project |
 | **Windsurf** | `.windsurf/mcp.json` | Project |
-| **Cline** | VS Code globalStorage | Global |
+| **Cline** | `.cline/mcp.json` | Project |
 | **Roo Code** | `.roo/mcp.json` | Project |
+| **Gemini CLI** | `.gemini/settings.json` | Project |
+| **Codex** | `.codex/config.toml` | Project |
+| **OpenCode** | `.opencode/opencode.jsonc` | Project |
 
 ---
 
@@ -176,19 +179,34 @@ Done!
 sync-project-mcps [options]
 
 Options:
+  -s, --source  Use specific client as source of truth (cursor, claude, windsurf, cline, roo, gemini, codex, opencode)
   --dry-run     Show what would be synced without writing files
   -v, --verbose Show detailed information about each server
   -h, --help    Show help message
   --version     Show version
 ```
 
+### Source Mode
+
+By default, the tool **merges** all configs (add-only). Use `--source` to pick one client as the source of truth:
+
+```bash
+# Use Cursor's config as the canonical source
+npx -y sync-project-mcps@latest -s cursor
+
+# Preview what would be removed
+npx -y sync-project-mcps@latest -s cursor --dry-run -v
+```
+
+This will sync **only** the servers from the source client to all others, removing servers that don't exist in the source.
+
 ---
 
 ## FAQ
 
 ### Does it delete servers?
 
-No. It only adds missing servers. If a server exists in Cursor but not Claude Code, it gets added to Claude Code. Servers are never removed.
+By default, no. It only adds missing servers. Use `--source` to sync from a specific client, which will also remove servers that don't exist in the source.
 
 ### What if the same server has different configs?
 

package/dist/clients/codex.d.ts

@@ -0,0 +1,3 @@
+import type { ClientConfig, McpConfig } from "../types.js";
+export declare function getCodexConfig(projectRoot: string): ClientConfig;
+export declare function serializeCodexConfig(config: McpConfig, existingContent: string): string;

package/dist/clients/codex.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseToml, stringifyToml } from "../parsers/toml.js";
+const CONFIG_PATH = ".codex/config.toml";
+const MCP_PREFIX = "mcp_servers.";
+export function getCodexConfig(projectRoot) {
+    const configPath = join(projectRoot, CONFIG_PATH);
+    const exists = existsSync(configPath);
+    if (!exists) {
+        return {
+            name: "Codex",
+            path: configPath,
+            config: null,
+            exists: false,
+        };
+    }
+    try {
+        const content = readFileSync(configPath, "utf-8");
+        const parsed = parseToml(content);
+        const mcpServers = {};
+        for (const [section, values] of Object.entries(parsed)) {
+            if (!section.startsWith(MCP_PREFIX))
+                continue;
+            const serverName = section.slice(MCP_PREFIX.length);
+            const command = values.command;
+            const args = values.args;
+            const env = values.env;
+            if (command) {
+                mcpServers[serverName] = { command, args, env };
+            }
+        }
+        return {
+            name: "Codex",
+            path: configPath,
+            config: { mcpServers },
+            exists: true,
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        console.error(`Warning: Failed to parse ${configPath}: ${msg}`);
+        return {
+            name: "Codex",
+            path: configPath,
+            config: null,
+            exists: true,
+        };
+    }
+}
+export function serializeCodexConfig(config, existingContent) {
+    const existing = parseToml(existingContent);
+    for (const key of Object.keys(existing)) {
+        if (key.startsWith(MCP_PREFIX)) {
+            delete existing[key];
+        }
+    }
+    for (const [name, server] of Object.entries(config.mcpServers)) {
+        const section = `${MCP_PREFIX}${name}`;
+        existing[section] = {
+            command: server.command,
+            ...(server.args && { args: server.args }),
+            ...(server.env && { env: server.env }),
+        };
+    }
+    return stringifyToml(existing);
+}

package/dist/clients/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { ClientConfig } from "../types.js";
+export declare function getGeminiConfig(projectRoot: string): ClientConfig;

package/dist/clients/gemini.js

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const CONFIG_PATH = ".gemini/settings.json";
+export function getGeminiConfig(projectRoot) {
+    const configPath = join(projectRoot, CONFIG_PATH);
+    const exists = existsSync(configPath);
+    if (!exists) {
+        return {
+            name: "Gemini CLI",
+            path: configPath,
+            config: null,
+            exists: false,
+        };
+    }
+    try {
+        const content = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        const config = {
+            mcpServers: (parsed.mcpServers ?? {}),
+        };
+        return {
+            name: "Gemini CLI",
+            path: configPath,
+            config,
+            exists: true,
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        console.error(`Warning: Failed to parse ${configPath}: ${msg}`);
+        return {
+            name: "Gemini CLI",
+            path: configPath,
+            config: null,
+            exists: true,
+        };
+    }
+}

package/dist/clients/opencode.d.ts

@@ -0,0 +1,3 @@
+import type { ClientConfig, McpConfig } from "../types.js";
+export declare function getOpenCodeConfig(projectRoot: string): ClientConfig;
+export declare function serializeOpenCodeConfig(config: McpConfig, existingContent: string): string;

package/dist/clients/opencode.js

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseJsonc } from "../parsers/jsonc.js";
+const CONFIG_PATH = ".opencode/opencode.jsonc";
+export function getOpenCodeConfig(projectRoot) {
+    const configPath = join(projectRoot, CONFIG_PATH);
+    const exists = existsSync(configPath);
+    if (!exists) {
+        return {
+            name: "OpenCode",
+            path: configPath,
+            config: null,
+            exists: false,
+        };
+    }
+    try {
+        const content = readFileSync(configPath, "utf-8");
+        const parsed = parseJsonc(content);
+        const mcpServers = {};
+        if (parsed.mcp) {
+            for (const [name, server] of Object.entries(parsed.mcp)) {
+                if (server.type !== "local")
+                    continue;
+                if (server.enabled === false)
+                    continue;
+                const [command, ...args] = server.command;
+                mcpServers[name] = {
+                    command,
+                    ...(args.length > 0 && { args }),
+                    ...(server.environment && { env: server.environment }),
+                };
+            }
+        }
+        return {
+            name: "OpenCode",
+            path: configPath,
+            config: { mcpServers },
+            exists: true,
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        console.error(`Warning: Failed to parse ${configPath}: ${msg}`);
+        return {
+            name: "OpenCode",
+            path: configPath,
+            config: null,
+            exists: true,
+        };
+    }
+}
+export function serializeOpenCodeConfig(config, existingContent) {
+    const existing = parseJsonc(existingContent);
+    const remoteMcp = {};
+    if (existing.mcp) {
+        for (const [name, server] of Object.entries(existing.mcp)) {
+            if (server.type === "remote") {
+                remoteMcp[name] = server;
+            }
+        }
+    }
+    const newMcp = { ...remoteMcp };
+    for (const [name, server] of Object.entries(config.mcpServers)) {
+        const command = [server.command, ...(server.args ?? [])];
+        newMcp[name] = {
+            type: "local",
+            command,
+            ...(server.env && { environment: server.env }),
+        };
+    }
+    return JSON.stringify({ ...existing, mcp: newMcp }, null, 2) + "\n";
+}

package/dist/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { getCursorConfig } from "./clients/cursor.js";
 import { getClaudeCodeConfig } from "./clients/claude-code.js";
 import { getWindsurfConfig } from "./clients/windsurf.js";
 import { getClineConfig } from "./clients/cline.js";
 import { getRooCodeConfig } from "./clients/roo-code.js";
+import { getGeminiConfig } from "./clients/gemini.js";
+import { getCodexConfig, serializeCodexConfig } from "./clients/codex.js";
+import { getOpenCodeConfig, serializeOpenCodeConfig } from "./clients/opencode.js";
 import { mergeConfigs, getChanges } from "./merge.js";
 const COLORS = {
     reset: "\x1b[0m",
@@ -21,12 +23,26 @@ const COLORS = {
 function c(color, text) {
     return `${COLORS[color]}${text}${COLORS.reset}`;
 }
+const CLIENT_ALIASES = {
+    cursor: "Cursor",
+    claude: "Claude Code",
+    "claude-code": "Claude Code",
+    windsurf: "Windsurf",
+    cline: "Cline",
+    roo: "Roo Code",
+    "roo-code": "Roo Code",
+    gemini: "Gemini CLI",
+    "gemini-cli": "Gemini CLI",
+    codex: "Codex",
+    opencode: "OpenCode",
+};
 const { values: args } = parseArgs({
     options: {
         "dry-run": { type: "boolean", default: false },
         verbose: { type: "boolean", short: "v", default: false },
         help: { type: "boolean", short: "h", default: false },
         version: { type: "boolean", default: false },
+        source: { type: "string", short: "s" },
     },
 });
 function printHelp() {
@@ -37,6 +53,7 @@ ${c("bold", "USAGE")}
   npx sync-project-mcps [options]
 
 ${c("bold", "OPTIONS")}
+  -s, --source  Use specific client as source of truth (cursor, claude, windsurf, cline, roo, gemini, codex, opencode)
   --dry-run     Show what would be synced without writing files
   -v, --verbose Show detailed information
   -h, --help    Show this help message
@@ -48,10 +65,14 @@ ${c("bold", "SUPPORTED CLIENTS")}
   - Windsurf    ${c("dim", ".windsurf/mcp.json")}
   - Cline       ${c("dim", ".cline/mcp.json")}
   - Roo Code    ${c("dim", ".roo/mcp.json")}
+  - Gemini CLI  ${c("dim", ".gemini/settings.json")}
+  - Codex       ${c("dim", ".codex/config.toml")}
+  - OpenCode    ${c("dim", ".opencode/opencode.jsonc")}
 
 ${c("bold", "EXAMPLES")}
-  npx sync-project-mcps              Sync all MCP configurations
-  npx sync-project-mcps --dry-run    Preview changes without writing
+  npx sync-project-mcps                    Merge all configs (add-only)
+  npx sync-project-mcps -s cursor          Use Cursor as source of truth
+  npx sync-project-mcps -s cursor --dry-run Preview changes
 `);
 }
 function run() {
@@ -66,7 +87,17 @@ function run() {
     const projectRoot = process.cwd();
     const dryRun = args["dry-run"];
     const verbose = args.verbose;
+    const sourceArg = args.source?.toLowerCase();
+    const sourceName = sourceArg ? CLIENT_ALIASES[sourceArg] : null;
+    if (sourceArg && !sourceName) {
+        console.error(c("red", `Unknown source: ${sourceArg}`));
+        console.error(`Valid sources: ${Object.keys(CLIENT_ALIASES).join(", ")}`);
+        process.exit(1);
+    }
     console.log(c("bold", "\nSync MCP Configurations\n"));
+    if (sourceName) {
+        console.log(c("cyan", `Source: ${sourceName}\n`));
+    }
     if (dryRun) {
         console.log(c("yellow", "DRY RUN - no files will be modified\n"));
     }
@@ -76,6 +107,9 @@ function run() {
         getWindsurfConfig(projectRoot),
         getClineConfig(projectRoot),
         getRooCodeConfig(projectRoot),
+        getGeminiConfig(projectRoot),
+        getCodexConfig(projectRoot),
+        getOpenCodeConfig(projectRoot),
     ];
     const existingClients = clients.filter((c) => c.exists && c.config);
     const missingClients = clients.filter((c) => !c.exists);
@@ -99,19 +133,34 @@ function run() {
         }
     }
     if (missingClients.length > 0 && verbose) {
-        console.log(c("dim", "\nNot found (will be created):"));
+        console.log(c("dim", "\nNot found (skipped):"));
         for (const client of missingClients) {
             console.log(c("dim", `  - ${client.name}`));
         }
     }
-    const merged = mergeConfigs(existingClients);
+    let merged;
+    if (sourceName) {
+        const sourceClient = existingClients.find((cl) => cl.name === sourceName);
+        if (!sourceClient) {
+            console.error(c("red", `\nSource "${sourceName}" not found in project.`));
+            console.error("Available configs:");
+            for (const client of existingClients) {
+                console.error(c("dim", `  - ${client.name}`));
+            }
+            process.exit(1);
+        }
+        merged = { mcpServers: { ...sourceClient.config.mcpServers } };
+    }
+    else {
+        merged = mergeConfigs(existingClients);
+    }
     const mergedCount = Object.keys(merged.mcpServers).length;
     console.log(`\n${c("cyan", "Merged result:")} ${mergedCount} unique server(s)`);
     for (const name of Object.keys(merged.mcpServers).sort()) {
         console.log(`  ${c("blue", "-")} ${name}`);
     }
     console.log(`\n${c("cyan", "Syncing to clients...")}`);
-    for (const client of clients) {
+    for (const client of existingClients) {
         const changes = getChanges(client, merged);
         const parts = [];
         if (changes.added.length > 0) {
@@ -120,20 +169,35 @@ function run() {
         if (changes.removed.length > 0) {
             parts.push(c("red", `-${changes.removed.length}`));
         }
-        const changeInfo = parts.length > 0 ? ` (${parts.join(", ")})` : c("dim", " (no changes)");
-        const status = client.exists ? c("green", "update") : c("yellow", "create");
+        const hasChanges = parts.length > 0;
+        const changeInfo = hasChanges ? ` (${parts.join(", ")})` : "";
+        const status = hasChanges ? c("green", "sync") : c("dim", "skip");
         console.log(`  [${status}] ${client.name}${changeInfo}`);
-        if (verbose && changes.added.length > 0) {
+        if (verbose) {
             for (const name of changes.added) {
                 console.log(c("green", `      + ${name}`));
             }
+            for (const name of changes.removed) {
+                console.log(c("red", `      - ${name}`));
+            }
         }
-        if (!dryRun) {
-            const dir = dirname(client.path);
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
+        if (!dryRun && hasChanges) {
+            const existingContent = readFileSync(client.path, "utf-8");
+            let output;
+            if (client.name === "Gemini CLI") {
+                const existing = JSON.parse(existingContent);
+                output = JSON.stringify({ ...existing, mcpServers: merged.mcpServers }, null, 2) + "\n";
+            }
+            else if (client.name === "Codex") {
+                output = serializeCodexConfig(merged, existingContent);
+            }
+            else if (client.name === "OpenCode") {
+                output = serializeOpenCodeConfig(merged, existingContent);
+            }
+            else {
+                output = JSON.stringify(merged, null, 2) + "\n";
             }
-            writeFileSync(client.path, JSON.stringify(merged, null, 2) + "\n");
+            writeFileSync(client.path, output);
         }
     }
     console.log(`\n${c("green", "Done!")} ${dryRun ? "(dry run)" : ""}\n`);

package/dist/parsers/jsonc.d.ts

@@ -0,0 +1 @@
+export declare function parseJsonc<T>(content: string): T;

package/dist/parsers/jsonc.js

@@ -0,0 +1,35 @@
+export function parseJsonc(content) {
+    let result = "";
+    let inString = false;
+    let i = 0;
+    while (i < content.length) {
+        const char = content[i];
+        const next = content[i + 1];
+        if (char === '"' && (i === 0 || content[i - 1] !== "\\")) {
+            inString = !inString;
+            result += char;
+            i++;
+            continue;
+        }
+        if (!inString) {
+            if (char === "/" && next === "/") {
+                while (i < content.length && content[i] !== "\n" && content[i] !== "\r") {
+                    i++;
+                }
+                continue;
+            }
+            if (char === "/" && next === "*") {
+                i += 2;
+                while (i < content.length - 1 && !(content[i] === "*" && content[i + 1] === "/")) {
+                    i++;
+                }
+                i += 2;
+                continue;
+            }
+        }
+        result += char;
+        i++;
+    }
+    const cleaned = result.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(cleaned);
+}

package/dist/parsers/toml.d.ts

@@ -0,0 +1,5 @@
+type TomlValue = string | string[] | Record<string, string>;
+type TomlSection = Record<string, TomlValue>;
+export declare function parseToml(content: string): Record<string, TomlSection>;
+export declare function stringifyToml(data: Record<string, TomlSection>): string;
+export {};

package/dist/parsers/toml.js

@@ -0,0 +1,100 @@
+export function parseToml(content) {
+    const result = {};
+    let currentSection = "";
+    const lines = content.split("\n");
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            result[currentSection] = {};
+            continue;
+        }
+        if (!currentSection)
+            continue;
+        const keyValueMatch = line.match(/^(\w+)\s*=\s*(.+)$/);
+        if (!keyValueMatch)
+            continue;
+        const [, key, rawValue] = keyValueMatch;
+        result[currentSection][key] = parseValue(rawValue.trim());
+    }
+    return result;
+}
+function parseValue(value) {
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        return parseArray(value);
+    }
+    if (value.startsWith("{") && value.endsWith("}")) {
+        return parseInlineTable(value);
+    }
+    return value;
+}
+function parseArray(value) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return [];
+    const result = [];
+    let current = "";
+    let inString = false;
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (char === '"' && inner[i - 1] !== "\\") {
+            inString = !inString;
+            continue;
+        }
+        if (char === "," && !inString) {
+            if (current.trim())
+                result.push(current.trim());
+            current = "";
+            continue;
+        }
+        if (!inString && (char === " " || char === "\t"))
+            continue;
+        current += char;
+    }
+    if (current.trim())
+        result.push(current.trim());
+    return result;
+}
+function parseInlineTable(value) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return {};
+    const result = {};
+    const pairs = inner.split(",");
+    for (const pair of pairs) {
+        const match = pair.trim().match(/^"?(\w+)"?\s*=\s*"([^"]*)"$/);
+        if (match) {
+            result[match[1]] = match[2];
+        }
+    }
+    return result;
+}
+export function stringifyToml(data) {
+    const lines = [];
+    for (const [section, values] of Object.entries(data)) {
+        lines.push(`[${section}]`);
+        for (const [key, value] of Object.entries(values)) {
+            lines.push(`${key} = ${stringifyValue(value)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function stringifyValue(value) {
+    if (typeof value === "string") {
+        return `"${value}"`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => `"${v}"`).join(", ")}]`;
+    }
+    const pairs = Object.entries(value)
+        .map(([k, v]) => `"${k}" = "${v}"`)
+        .join(", ");
+    return `{ ${pairs} }`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sync-project-mcps",
-  "version": "1.0.2",
-  "description": "Sync project-level MCP configurations across AI coding assistants (Cursor, Claude Code, Windsurf, Cline)",
+  "version": "1.2.0",
+  "description": "Sync project-level MCP configurations across AI coding assistants (Cursor, Claude Code, Windsurf, Cline, Gemini CLI, Codex, OpenCode)",
   "type": "module",
   "bin": {
     "sync-project-mcps": "./dist/index.js"
@@ -10,10 +10,12 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "test": "node --test --experimental-strip-types src/**/*.test.ts",
+    "prepublishOnly": "npm run build && npm test"
   },
   "keywords": ["mcp", "cursor", "claude", "sync", "cli", "windsurf", "cline", "project"],
   "author": "Vlad Tansky",