@swmansion/argent 0.5.1

package/dist/cli/mcp-configs.js

@@ -0,0 +1,724 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { MCP_SERVER_KEY, MCP_BINARY_NAME, PERMISSION_RULE, CURSOR_ALLOWLIST_PATTERN, } from "./constants.js";
+import { readJson, writeJson, dirExists, readToml, writeToml } from "./utils.js";
+const TOOL_SERVER_BUNDLE = path.join(import.meta.dirname, "..", "tool-server.cjs");
+function getAvailableToolIds() {
+    const out = execFileSync("node", [TOOL_SERVER_BUNDLE, "-t"], { encoding: "utf8" });
+    const tools = JSON.parse(out);
+    return tools.map((t) => t.id);
+}
+// ── Shared helpers ────────────────────────────────────────────────────────────
+function buildMcpEntry() {
+    const logFile = path.join(homedir(), ".argent", "mcp-calls.log");
+    return {
+        command: MCP_BINARY_NAME,
+        args: ["mcp"],
+        env: { ARGENT_MCP_LOG: logFile },
+    };
+}
+export function getMcpEntry() {
+    return buildMcpEntry();
+}
+function removeDirIfEmpty(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath))
+            return;
+        if (!fs.statSync(dirPath).isDirectory())
+            return;
+        if (fs.readdirSync(dirPath).length > 0)
+            return;
+        fs.rmdirSync(dirPath);
+    }
+    catch {
+        // non-fatal
+    }
+}
+function pruneEmptyConfig(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value : undefined;
+    }
+    if (value && typeof value === "object") {
+        const cleaned = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const next = pruneEmptyConfig(entry);
+            if (next !== undefined)
+                cleaned[key] = next;
+        }
+        return Object.keys(cleaned).length > 0 ? cleaned : undefined;
+    }
+    return value;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function writeJsonOrRemove(filePath, data) {
+    const cleaned = pruneEmptyConfig(data);
+    if (!isRecord(cleaned)) {
+        fs.rmSync(filePath, { force: true });
+        removeDirIfEmpty(path.dirname(filePath));
+        return;
+    }
+    writeJson(filePath, cleaned);
+}
+function writeTomlOrRemove(filePath, data) {
+    const cleaned = pruneEmptyConfig(data);
+    if (!isRecord(cleaned)) {
+        fs.rmSync(filePath, { force: true });
+        removeDirIfEmpty(path.dirname(filePath));
+        return;
+    }
+    writeToml(filePath, cleaned);
+}
+// ── Cursor adapter ────────────────────────────────────────────────────────────
+// MARK: Cursor
+// Format: { mcpServers: { argent: { command, args, env } } }
+const cursorAdapter = {
+    name: "Cursor",
+    detect() {
+        return (dirExists(path.join(homedir(), ".cursor")) || dirExists(path.join(process.cwd(), ".cursor")));
+    },
+    projectPath(root) {
+        return path.join(root, ".cursor", "mcp.json");
+    },
+    globalPath() {
+        return path.join(homedir(), ".cursor", "mcp.json");
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.mcpServers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.mcpServers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+    addAllowlist() {
+        const permPath = path.join(homedir(), ".cursor", "permissions.json");
+        const config = readJson(permPath);
+        const list = (config.mcpAllowlist ?? []);
+        if (!list.includes(CURSOR_ALLOWLIST_PATTERN)) {
+            list.push(CURSOR_ALLOWLIST_PATTERN);
+            config.mcpAllowlist = list;
+            writeJson(permPath, config);
+        }
+    },
+    removeAllowlist() {
+        const permPath = path.join(homedir(), ".cursor", "permissions.json");
+        if (!fs.existsSync(permPath))
+            return;
+        const config = readJson(permPath);
+        const list = config.mcpAllowlist;
+        if (!Array.isArray(list))
+            return;
+        const idx = list.indexOf(CURSOR_ALLOWLIST_PATTERN);
+        if (idx === -1)
+            return;
+        list.splice(idx, 1);
+        config.mcpAllowlist = list;
+        writeJsonOrRemove(permPath, config);
+    },
+};
+// ── Claude Code adapter ───────────────────────────────────────────────────────
+// MARK: Claude
+// Format: { mcpServers: { argent: { type: "stdio", command, args, env } } }
+// Project: .mcp.json   Global: ~/.claude.json
+// Also manages permissions in .claude/settings.json
+const claudeAdapter = {
+    name: "Claude Code",
+    detect() {
+        return (fs.existsSync(path.join(process.cwd(), ".mcp.json")) ||
+            fs.existsSync(path.join(homedir(), ".claude.json")) ||
+            dirExists(path.join(process.cwd(), ".claude")) ||
+            dirExists(path.join(homedir(), ".claude")));
+    },
+    projectPath(root) {
+        return path.join(root, ".mcp.json");
+    },
+    globalPath() {
+        return path.join(homedir(), ".claude.json");
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            type: "stdio",
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.mcpServers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.mcpServers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+    addAllowlist(root, scope) {
+        addClaudePermission(root, scope);
+    },
+    removeAllowlist(root, scope) {
+        removeClaudePermission(root, scope);
+    },
+};
+// ── VS Code adapter ──────────────────────────────────────────────────────────
+// MARK: VSCode
+// Format: { servers: { argent: { type: "stdio", command, args, env } } }
+// Project only: .vscode/mcp.json
+const vscodeAdapter = {
+    name: "VS Code",
+    detect() {
+        return (dirExists(path.join(process.cwd(), ".vscode")) || dirExists(path.join(homedir(), ".vscode")));
+    },
+    projectPath(root) {
+        return path.join(root, ".vscode", "mcp.json");
+    },
+    globalPath() {
+        return null;
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.servers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            type: "stdio",
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.servers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.servers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+};
+// ── Windsurf adapter ─────────────────────────────────────────────────────────
+// MARK: Windsurf
+// Format: { mcpServers: { argent: { command, args, env } } }
+// Global only: ~/.codeium/windsurf/mcp_config.json
+const windsurfAdapter = {
+    name: "Windsurf",
+    detect() {
+        return dirExists(path.join(homedir(), ".codeium", "windsurf"));
+    },
+    projectPath() {
+        return null;
+    },
+    globalPath() {
+        return path.join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.mcpServers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.mcpServers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+    addAllowlist() {
+        const configPath = path.join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        const entry = servers[MCP_SERVER_KEY];
+        if (!entry)
+            return;
+        entry.alwaysAllow = ["*"];
+        writeJson(configPath, config);
+    },
+    removeAllowlist() {
+        const configPath = path.join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+        if (!fs.existsSync(configPath))
+            return;
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        const entry = servers[MCP_SERVER_KEY];
+        if (!entry?.alwaysAllow)
+            return;
+        delete entry.alwaysAllow;
+        writeJsonOrRemove(configPath, config);
+    },
+};
+// ── Zed adapter ──────────────────────────────────────────────────────────────
+// MARK: Zed
+// Format: merges { context_servers: { argent: { source: "custom", command, args, env } } }
+// Into existing settings.json
+const zedAdapter = {
+    name: "Zed",
+    detect() {
+        return dirExists(path.join(homedir(), ".config", "zed"));
+    },
+    projectPath(root) {
+        return path.join(root, ".zed", "settings.json");
+    },
+    globalPath() {
+        return path.join(homedir(), ".config", "zed", "settings.json");
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.context_servers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            source: "custom",
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.context_servers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.context_servers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+    // Zed doesn't support server-level wildcards for MCP tools — each tool
+    // would need its own entry.  Setting the global default to "allow" is the
+    // documented opt-in; built-in security rules still protect against
+    // destructive operations.
+    addAllowlist(root, scope) {
+        const settingsPath = scope === "global"
+            ? path.join(homedir(), ".config", "zed", "settings.json")
+            : path.join(root, ".zed", "settings.json");
+        const config = readJson(settingsPath);
+        const agent = (config.agent ?? {});
+        const perms = (agent.tool_permissions ?? {});
+        perms.default = "allow";
+        agent.tool_permissions = perms;
+        config.agent = agent;
+        writeJson(settingsPath, config);
+    },
+    removeAllowlist(root, scope) {
+        const settingsPath = scope === "global"
+            ? path.join(homedir(), ".config", "zed", "settings.json")
+            : path.join(root, ".zed", "settings.json");
+        if (!fs.existsSync(settingsPath))
+            return;
+        const config = readJson(settingsPath);
+        const perms = config.agent?.tool_permissions;
+        if (!perms || perms.default !== "allow")
+            return;
+        perms.default = "confirm";
+        writeJsonOrRemove(settingsPath, config);
+    },
+};
+// ── Gemini CLI adapter ────────────────────────────────────────────────────────
+// MARK: Gemini
+// Format: { mcpServers: { argent: { command, args, env } } }
+// Project: <root>/.gemini/settings.json   Global: ~/.gemini/settings.json
+const geminiAdapter = {
+    name: "Gemini",
+    detect() {
+        return (dirExists(path.join(homedir(), ".gemini")) || dirExists(path.join(process.cwd(), ".gemini")));
+    },
+    projectPath(root) {
+        return path.join(root, ".gemini", "settings.json");
+    },
+    globalPath() {
+        return path.join(homedir(), ".gemini", "settings.json");
+    },
+    write(configPath, entry) {
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.mcpServers = servers;
+        writeJson(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readJson(configPath);
+        const servers = config.mcpServers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeJsonOrRemove(configPath, config);
+        return true;
+    },
+    addAllowlist(root, scope) {
+        const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
+        if (!configPath) {
+            return;
+        }
+        const config = readJson(configPath);
+        const servers = (config.mcpServers ?? {});
+        const entry = servers[MCP_SERVER_KEY];
+        if (!entry)
+            return;
+        entry.trust = true;
+        writeJson(configPath, config);
+    },
+    removeAllowlist(root, scope) {
+        const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
+        if (!configPath || !fs.existsSync(configPath)) {
+            return;
+        }
+        const config = readJson(configPath);
+        const servers = config.mcpServers;
+        const entry = servers?.[MCP_SERVER_KEY];
+        if (!entry?.trust)
+            return;
+        delete entry.trust;
+        writeJsonOrRemove(configPath, config);
+    },
+};
+// ── Codex CLI adapter ────────────────────────────────────────────────────────
+// MARK: Codex
+// Format (TOML): [mcp_servers.argent] command = "argent" args = ["mcp"] env = { ... }
+// Project: <root>/.codex/config.toml   Global: ~/.codex/config.toml
+const CODEX_FILENAME = ".codex";
+const codexAdapter = {
+    name: "Codex",
+    detect() {
+        return (dirExists(path.join(homedir(), CODEX_FILENAME)) ||
+            dirExists(path.join(process.cwd(), CODEX_FILENAME)));
+    },
+    projectPath(root) {
+        return path.join(root, CODEX_FILENAME, "config.toml");
+    },
+    globalPath() {
+        return path.join(homedir(), CODEX_FILENAME, "config.toml");
+    },
+    write(configPath, entry) {
+        const config = readToml(configPath);
+        const servers = (config.mcp_servers ?? {});
+        servers[MCP_SERVER_KEY] = {
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+        };
+        config.mcp_servers = servers;
+        writeToml(configPath, config);
+    },
+    remove(configPath) {
+        if (!fs.existsSync(configPath))
+            return false;
+        const config = readToml(configPath);
+        const servers = config.mcp_servers;
+        if (!servers?.[MCP_SERVER_KEY])
+            return false;
+        delete servers[MCP_SERVER_KEY];
+        writeTomlOrRemove(configPath, config);
+        return true;
+    },
+    addAllowlist(root, scope) {
+        const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
+        if (!configPath) {
+            return;
+        }
+        const tools = getAvailableToolIds();
+        const config = readToml(configPath);
+        config.mcp_servers ??= {};
+        config.mcp_servers.argent ??= {};
+        config.mcp_servers.argent.tools ??= {};
+        const toolsConfig = config.mcp_servers.argent.tools;
+        for (const tool of tools) {
+            toolsConfig[tool] = {
+                approval_mode: "approve",
+            };
+        }
+        writeToml(configPath, config);
+    },
+    removeAllowlist(root, scope) {
+        const configPath = scope === "global" ? this.globalPath() : this.projectPath(root);
+        if (!configPath) {
+            return;
+        }
+        const tools = getAvailableToolIds();
+        const config = readToml(configPath);
+        const toolsConfig = config?.mcp_servers?.argent?.tools;
+        if (toolsConfig === undefined) {
+            return;
+        }
+        for (const tool of tools) {
+            if (tool in toolsConfig) {
+                delete toolsConfig[tool];
+            }
+        }
+        writeToml(configPath, config);
+    },
+};
+// ── Registry ──────────────────────────────────────────────────────────────────
+// MARK: Registry
+export const ALL_ADAPTERS = [
+    cursorAdapter,
+    claudeAdapter,
+    vscodeAdapter,
+    windsurfAdapter,
+    zedAdapter,
+    geminiAdapter,
+    codexAdapter,
+];
+export function detectAdapters() {
+    return ALL_ADAPTERS.filter((a) => a.detect());
+}
+export function getAdapterByName(name) {
+    return ALL_ADAPTERS.find((a) => a.name.toLowerCase() === name.toLowerCase());
+}
+// ── Claude permissions helpers ────────────────────────────────────────────────
+export function addClaudePermission(root, scope) {
+    const settingsPath = scope === "global"
+        ? path.join(homedir(), ".claude", "settings.json")
+        : path.join(root, ".claude", "settings.json");
+    const config = readJson(settingsPath);
+    const permissions = (config.permissions ?? {});
+    const allow = (permissions.allow ?? []);
+    if (!allow.includes(PERMISSION_RULE)) {
+        allow.push(PERMISSION_RULE);
+        permissions.allow = allow;
+        config.permissions = permissions;
+        writeJson(settingsPath, config);
+    }
+}
+export function removeClaudePermission(root, scope) {
+    const settingsPath = scope === "global"
+        ? path.join(homedir(), ".claude", "settings.json")
+        : path.join(root, ".claude", "settings.json");
+    if (!fs.existsSync(settingsPath))
+        return;
+    const config = readJson(settingsPath);
+    const allow = config?.permissions?.allow;
+    if (!Array.isArray(allow))
+        return;
+    const idx = allow.indexOf(PERMISSION_RULE);
+    if (idx === -1)
+        return;
+    allow.splice(idx, 1);
+    writeJsonOrRemove(settingsPath, config);
+}
+function formatManagedPathLabel(targetPath, root) {
+    const home = homedir();
+    if (targetPath === home || targetPath.startsWith(`${home}${path.sep}`)) {
+        return `~${targetPath.slice(home.length)}`;
+    }
+    const relative = path.relative(root, targetPath);
+    if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+        return relative;
+    }
+    return targetPath;
+}
+function addManagedTarget(targets, editorName, targetPath, root) {
+    targets.push({
+        editorName,
+        targetPath,
+        label: formatManagedPathLabel(targetPath, root),
+    });
+}
+function getAdapterBasePath(adapter, root, scope) {
+    const configPath = scope === "global" ? adapter.globalPath() : adapter.projectPath(root);
+    return configPath ? path.dirname(configPath) : null;
+}
+export function getManagedContentTargets(adapters, root, scope) {
+    const targets = {
+        skillTargets: [],
+        ruleTargets: [],
+        agentTargets: [],
+        codexConfigTargets: [],
+        skillsLockTargets: [],
+    };
+    const workspaceBase = scope === "global" ? homedir() : root;
+    addManagedTarget(targets.skillTargets, "skills", path.join(workspaceBase, ".agents", "skills"), root);
+    addManagedTarget(targets.skillsLockTargets, "skills", path.join(workspaceBase, "skills-lock.json"), root);
+    for (const adapter of adapters) {
+        switch (adapter.name) {
+            case "Cursor": {
+                const base = getAdapterBasePath(adapter, root, scope);
+                if (!base)
+                    break;
+                addManagedTarget(targets.skillTargets, adapter.name, path.join(base, "skills"), root);
+                addManagedTarget(targets.ruleTargets, adapter.name, path.join(base, "rules"), root);
+                break;
+            }
+            case "Claude Code": {
+                const claudeBase = scope === "global" ? path.join(homedir(), ".claude") : path.join(root, ".claude");
+                addManagedTarget(targets.skillTargets, adapter.name, path.join(claudeBase, "skills"), root);
+                addManagedTarget(targets.ruleTargets, adapter.name, path.join(claudeBase, "rules"), root);
+                addManagedTarget(targets.agentTargets, adapter.name, path.join(claudeBase, "agents"), root);
+                break;
+            }
+            case "Gemini": {
+                const geminiBase = scope === "global" ? path.join(homedir(), ".gemini") : path.join(root, ".gemini");
+                addManagedTarget(targets.ruleTargets, adapter.name, path.join(geminiBase, "rules"), root);
+                addManagedTarget(targets.agentTargets, adapter.name, path.join(geminiBase, "agents"), root);
+                break;
+            }
+            case "Codex": {
+                const configPath = scope === "global" ? adapter.globalPath() : adapter.projectPath(root);
+                if (!configPath)
+                    break;
+                addManagedTarget(targets.codexConfigTargets, adapter.name, configPath, root);
+                break;
+            }
+        }
+    }
+    return targets;
+}
+// ── Codex developer_instructions helpers ─────────────────────────────────────
+// Codex has no rules/ directory for model instructions. Instead we inject
+// rule content into the `developer_instructions` field of config.toml,
+// delimited by markers so we can update/remove without touching user content.
+const ARGENT_RULES_START = "# --- argent rules (managed by argent init — do not edit) ---";
+const ARGENT_RULES_END = "# --- end argent rules ---";
+function stripFrontmatter(content) {
+    const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+    return match ? content.slice(match[0].length).trim() : content.trim();
+}
+function readAndConcatRules(rulesDir) {
+    if (!fs.existsSync(rulesDir))
+        return null;
+    const files = fs
+        .readdirSync(rulesDir)
+        .filter((f) => f.endsWith(".md"))
+        .sort();
+    if (files.length === 0)
+        return null;
+    const parts = [];
+    for (const file of files) {
+        const raw = fs.readFileSync(path.join(rulesDir, file), "utf8");
+        const stripped = stripFrontmatter(raw);
+        if (stripped)
+            parts.push(stripped);
+    }
+    return parts.length > 0 ? parts.join("\n\n") : null;
+}
+function injectArgentSection(existing, rules) {
+    const section = `${ARGENT_RULES_START}\n${rules}\n${ARGENT_RULES_END}`;
+    if (!existing)
+        return section;
+    // Replace existing argent section if present
+    const re = new RegExp(`${escapeRegExp(ARGENT_RULES_START)}[\\s\\S]*?${escapeRegExp(ARGENT_RULES_END)}`);
+    if (re.test(existing))
+        return existing.replace(re, section);
+    // Append after user content
+    return `${existing}\n\n${section}`;
+}
+function removeArgentSection(existing) {
+    const re = new RegExp(`\\n*${escapeRegExp(ARGENT_RULES_START)}[\\s\\S]*?${escapeRegExp(ARGENT_RULES_END)}\\n*`);
+    return existing.replace(re, "").trim();
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function injectCodexRules(configPath, rulesDir) {
+    const rules = readAndConcatRules(rulesDir);
+    if (!rules)
+        return null;
+    const config = readToml(configPath);
+    const existing = config.developer_instructions;
+    config.developer_instructions = injectArgentSection(existing, rules);
+    writeToml(configPath, config);
+    return configPath;
+}
+export function removeCodexRules(configPath) {
+    if (!fs.existsSync(configPath))
+        return false;
+    const config = readToml(configPath);
+    const existing = config.developer_instructions;
+    if (!existing || !existing.includes(ARGENT_RULES_START))
+        return false;
+    const cleaned = removeArgentSection(existing);
+    if (cleaned) {
+        config.developer_instructions = cleaned;
+    }
+    else {
+        delete config.developer_instructions;
+    }
+    writeTomlOrRemove(configPath, config);
+    return true;
+}
+// ── Copy orchestrator ────────────────────────────────────────────────────────
+// MARK: Copy orchestrator
+export function copyRulesAndAgents(adapters, root, scope, rulesDir, agentsDir) {
+    const results = [];
+    const managedTargets = getManagedContentTargets(adapters, root, scope);
+    for (const target of managedTargets.ruleTargets) {
+        try {
+            if (fs.existsSync(rulesDir)) {
+                fs.mkdirSync(target.targetPath, { recursive: true });
+                fs.cpSync(rulesDir, target.targetPath, { recursive: true });
+                results.push(`  Copied rules to ${target.targetPath}`);
+            }
+        }
+        catch (err) {
+            results.push(`  Could not copy rules to ${target.targetPath}: ${err}`);
+        }
+    }
+    for (const target of managedTargets.agentTargets) {
+        try {
+            if (fs.existsSync(agentsDir)) {
+                fs.mkdirSync(target.targetPath, { recursive: true });
+                fs.cpSync(agentsDir, target.targetPath, { recursive: true });
+                results.push(`  Copied agents to ${target.targetPath}`);
+            }
+        }
+        catch (err) {
+            results.push(`  Could not copy agents to ${target.targetPath}: ${err}`);
+        }
+    }
+    // Codex: inject rules into developer_instructions in config.toml
+    for (const target of managedTargets.codexConfigTargets) {
+        try {
+            const injected = injectCodexRules(target.targetPath, rulesDir);
+            if (injected) {
+                results.push(`  Injected rules into ${target.targetPath} (developer_instructions)`);
+            }
+        }
+        catch (err) {
+            results.push(`  Could not inject rules into ${target.targetPath}: ${err}`);
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=mcp-configs.js.map