add-mcp 1.11.0 → 1.13.0

package/README.md

@@ -50,7 +50,7 @@ MCP servers can be installed to any of these agents:
 
 | Agent                  | `--agent`            | Project Path            | Global Path                                                                                                     |
 | ---------------------- | -------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------- |
-| Antigravity            | `antigravity`        | -                       | `~/.gemini/antigravity/mcp_config.json`                                                                         |
+| Antigravity            | `antigravity`        | -                       | `~/.gemini/config/mcp_config.json` (shared by Antigravity, Antigravity IDE, and Antigravity CLI)                |
 | Cline VSCode Extension | `cline`              | -                       | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` |
 | Cline CLI              | `cline-cli`          | -                       | `~/.cline/data/settings/cline_mcp_settings.json`                                                                |
 | Claude Code            | `claude-code`        | `.mcp.json`             | `~/.claude.json`                                                                                                |
@@ -128,6 +128,12 @@ npx add-mcp https://mcp.example.com/mcp --header "Authorization: Bearer $TOKEN"
 # (each agent only keeps the fields it supports; others are dropped with a warning)
 npx add-mcp https://mcp.example.com/mcp --timeout 30000 --scopes "read,write"
 
+# Auto-approve all tools for agents that support it (Codex, Claude Code)
+npx add-mcp "executor mcp" --name executor -a codex -a claude-code --auto-approve
+
+# Auto-approve only selected tools
+npx add-mcp "executor mcp" --name executor -a codex --auto-approve --approve-tool execute
+
 # npm package (runs via npx)
 npx add-mcp @modelcontextprotocol/server-postgres
 
@@ -164,21 +170,23 @@ npx add-mcp https://mcp.example.com/mcp -a cursor -y --gitignore
 
 ### Options
 
-| Option                   | Description                                                              |
-| ------------------------ | ------------------------------------------------------------------------ |
-| `-g, --global`           | Install to user directory instead of project                             |
-| `-a, --agent <agent>`    | Target specific agents (e.g., `cursor`, `claude-code`). Can be repeated. |
-| `-t, --transport <type>` | Transport type for remote servers: `http` (default), `sse`               |
-| `--type <type>`          | Alias for `--transport`                                                  |
-| `-h, --header <header>`  | HTTP header for remote servers (repeatable, `Key: Value`)                |
-| `--env <env>`            | Env var for local stdio servers (repeatable, `KEY=VALUE`)                |
-| `--timeout <ms>`         | Request timeout (ms) for remote servers (capability-gated, see below)    |
-| `--scopes <scopes>`      | OAuth scopes for remote servers, comma-separated (capability-gated)      |
-| `--oauth-scopes <scopes>`| Alias for `--scopes`                                                     |
-| `-n, --name <name>`      | Server name (auto-inferred if not provided)                              |
-| `-y, --yes`              | Skip all confirmation prompts                                            |
-| `--all`                  | Install to all agents                                                    |
-| `--gitignore`            | Add generated config files to `.gitignore`                               |
+| Option                    | Description                                                              |
+| ------------------------- | ------------------------------------------------------------------------ |
+| `-g, --global`            | Install to user directory instead of project                             |
+| `-a, --agent <agent>`     | Target specific agents (e.g., `cursor`, `claude-code`). Can be repeated. |
+| `-t, --transport <type>`  | Transport type for remote servers: `http` (default), `sse`               |
+| `--type <type>`           | Alias for `--transport`                                                  |
+| `-h, --header <header>`   | HTTP header for remote servers (repeatable, `Key: Value`)                |
+| `--env <env>`             | Env var for local stdio servers (repeatable, `KEY=VALUE`)                |
+| `--timeout <ms>`          | Request timeout (ms) for remote servers (capability-gated, see below)    |
+| `--scopes <scopes>`       | OAuth scopes for remote servers, comma-separated (capability-gated)      |
+| `--oauth-scopes <scopes>` | Alias for `--scopes`                                                     |
+| `--auto-approve`          | Auto-approve MCP tool calls for supported agents (Codex, Claude Code)    |
+| `--approve-tool <tool>`   | Tool to auto-approve with `--auto-approve` (repeatable; defaults to all) |
+| `-n, --name <name>`       | Server name (auto-inferred if not provided)                              |
+| `-y, --yes`               | Skip all confirmation prompts                                            |
+| `--all`                   | Install to all agents                                                    |
+| `--gitignore`             | Add generated config files to `.gitignore`                               |
 
 #### Capability-gated fields (`--timeout`, `--scopes`)
 
@@ -186,15 +194,36 @@ Not every MCP client understands every field. `add-mcp` keeps one canonical
 server config and each agent declares which optional fields it supports, mapping
 them into that client's native shape:
 
-| Field      | Flag             | Supported by                | Mapped to                          |
-| ---------- | ---------------- | --------------------------- | ---------------------------------- |
-| Timeout    | `--timeout`      | Claude Code, Gemini CLI     | `timeout` (milliseconds)           |
-| OAuth scopes | `--scopes`     | Cursor, Gemini CLI          | Cursor `auth.scopes`, Gemini `oauth.scopes` |
+| Field              | Flag                                | Supported by            | Mapped to                                                |
+| ------------------ | ----------------------------------- | ----------------------- | -------------------------------------------------------- |
+| Timeout            | `--timeout`                         | Claude Code, Gemini CLI | `timeout` (milliseconds)                                 |
+| OAuth scopes       | `--scopes`                          | Cursor, Gemini CLI      | Cursor `auth.scopes`, Gemini `oauth.scopes`              |
+| Tool auto-approval | `--auto-approve` / `--approve-tool` | Codex, Claude Code      | Codex approval modes; Claude Code permission allow rules |
 
 When you target an agent that does not support a field, `add-mcp` drops it from
 that agent's config and prints a warning (e.g. _"request timeout is not
 supported by VS Code; dropped from that config."_). Other agents still receive
-it. Both flags apply to remote servers only.
+it. `--timeout` and `--scopes` apply to remote servers only; `--auto-approve`
+applies to both remote and local servers.
+
+#### Auto-approving tool calls (`--auto-approve`)
+
+`--auto-approve` preconfigures agent-level approval so the agent doesn't prompt
+before each MCP tool call — useful for servers that already gate actions
+internally. Use `--approve-tool <name>` (repeatable) to approve only specific
+tools; without it, all tools are approved.
+
+- **Codex** — writes approval modes into `config.toml`: per-tool
+  `tools.<name>.approval_mode = "approve"`, or `default_tools_approval_mode = "approve"` for all tools.
+- **Claude Code** — writes permission allow rules to a separate settings file
+  (`.claude/settings.local.json` for project installs, `~/.claude/settings.json`
+  for global), e.g. `mcp__<server>__<tool>`, or `mcp__<server>` for all tools.
+  The MCP server entry itself stays clean.
+
+> Note: Claude Code's all-tools rule (`mcp__<server>`) follows the documented
+> format, but a known Claude Code bug ([#34739](https://github.com/anthropics/claude-code/issues/34739))
+> can still prompt for non-fully-qualified MCP rules. Listing tools explicitly
+> with `--approve-tool` is the most reliable path there.
 
 ### Transport Types
 
@@ -232,14 +261,16 @@ npx add-mcp find github --all --gitignore
 
 ### Options
 
-| Option                | Description                                                              |
-| --------------------- | ------------------------------------------------------------------------ |
-| `-g, --global`        | Install to user directory instead of project                             |
-| `-a, --agent <agent>` | Target specific agents (e.g., `cursor`, `claude-code`). Can be repeated. |
-| `-n, --name <name>`   | Server name override (defaults to the selected catalog entry name)       |
-| `-y, --yes`           | Skip confirmation prompts                                                |
-| `--all`               | Install to all agents                                                    |
-| `--gitignore`         | Add generated config files to `.gitignore`                               |
+| Option                  | Description                                                              |
+| ----------------------- | ------------------------------------------------------------------------ |
+| `-g, --global`          | Install to user directory instead of project                             |
+| `-a, --agent <agent>`   | Target specific agents (e.g., `cursor`, `claude-code`). Can be repeated. |
+| `-n, --name <name>`     | Server name override (defaults to the selected catalog entry name)       |
+| `-y, --yes`             | Skip confirmation prompts                                                |
+| `--auto-approve`        | Auto-approve MCP tool calls for supported agents (Codex, Claude Code)    |
+| `--approve-tool <tool>` | Tool to auto-approve with `--auto-approve` (repeatable; defaults to all) |
+| `--all`                 | Install to all agents                                                    |
+| `--gitignore`           | Add generated config files to `.gitignore`                               |
 
 Transport for `find`/`search` is inferred from registry metadata. The CLI prefers HTTP remotes when available and only falls back to SSE when HTTP is not available for the selected install context.
 

package/dist/{chunk-2OCTBM45.js → chunk-3ZFFEEQJ.js}

@@ -133,7 +133,7 @@ var { appSupport, vscodePath, gooseConfigPath } = getPlatformPaths();
 var antigravityConfigPath = join2(
   home,
   ".gemini",
-  "antigravity",
+  "config",
   "mcp_config.json"
 );
 var clineCliConfigPath = join2(
@@ -250,6 +250,17 @@ function transformOpenCodeConfig(_serverName, config) {
     environment: config.env || {}
   };
 }
+function applyCodexApproval(target, autoApproveTools) {
+  if (!autoApproveTools) return target;
+  if (autoApproveTools.length === 0) {
+    target.default_tools_approval_mode = "approve";
+    return target;
+  }
+  target.tools = Object.fromEntries(
+    autoApproveTools.map((tool) => [tool, { approval_mode: "approve" }])
+  );
+  return target;
+}
 function transformCodexConfig(_serverName, config) {
   if (config.url) {
     const remoteConfig = {
@@ -259,13 +270,16 @@ function transformCodexConfig(_serverName, config) {
     if (config.headers && Object.keys(config.headers).length > 0) {
       remoteConfig.http_headers = config.headers;
     }
-    return remoteConfig;
+    return applyCodexApproval(remoteConfig, config.autoApproveTools);
   }
-  return {
-    command: config.command,
-    args: config.args || [],
-    env: config.env
-  };
+  return applyCodexApproval(
+    {
+      command: config.command,
+      args: config.args || [],
+      env: config.env
+    },
+    config.autoApproveTools
+  );
 }
 function transformCursorConfig(_serverName, config) {
   if (config.url) {
@@ -375,7 +389,7 @@ var agents = {
     supportedTransports: ["stdio", "http", "sse"],
     supportedFields: [],
     detectGlobalInstall: async () => {
-      return existsSync(join2(home, ".gemini"));
+      return existsSync(join2(home, ".gemini", "config"));
     },
     transformConfig: transformAntigravityConfig
   },
@@ -418,7 +432,7 @@ var agents = {
     configKey: "mcpServers",
     format: "json",
     supportedTransports: ["stdio", "http", "sse"],
-    supportedFields: ["timeout"],
+    supportedFields: ["timeout", "autoApprove"],
     detectGlobalInstall: async () => {
       return existsSync(join2(home, ".claude"));
     },
@@ -452,7 +466,7 @@ var agents = {
     configKey: "mcp_servers",
     format: "toml",
     supportedTransports: ["stdio", "http", "sse"],
-    supportedFields: [],
+    supportedFields: ["autoApprove"],
     detectGlobalInstall: async () => {
       return existsSync(join2(home, ".codex"));
     },
@@ -603,6 +617,13 @@ function getAgentTypes() {
 function supportsProjectConfig(agentType) {
   return agents[agentType].localConfigPath !== void 0;
 }
+function getCommonInstallScopes(agentTypes) {
+  if (agentTypes.length === 0) return [];
+  if (agentTypes.some((agentType) => !supportsProjectConfig(agentType))) {
+    return ["global"];
+  }
+  return ["local", "global"];
+}
 function getProjectCapableAgents() {
   return Object.keys(agents).filter(
     (type) => supportsProjectConfig(type)
@@ -1181,6 +1202,15 @@ var OPTIONAL_FIELD_SPECS = {
     clear: (config) => {
       delete config.oauthScopes;
     }
+  },
+  autoApprove: {
+    label: "tool auto-approval",
+    // An empty array is meaningful ("approve all tools"), so presence alone
+    // counts as set — unlike scopes where an empty list means "nothing".
+    isSet: (config) => Array.isArray(config.autoApproveTools),
+    clear: (config) => {
+      delete config.autoApproveTools;
+    }
   }
 };
 var ALL_OPTIONAL_FIELDS = Object.keys(
@@ -1193,6 +1223,7 @@ function applyFieldSupport(config, supportedFields) {
   const supported = new Set(supportedFields);
   const copy = { ...config };
   if (copy.oauthScopes) copy.oauthScopes = [...copy.oauthScopes];
+  if (copy.autoApproveTools) copy.autoApproveTools = [...copy.autoApproveTools];
   const dropped = [];
   for (const field of ALL_OPTIONAL_FIELDS) {
     const spec = OPTIONAL_FIELD_SPECS[field];
@@ -1206,7 +1237,9 @@ function applyFieldSupport(config, supportedFields) {
 
 // src/installer.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
 import { join as join3, dirname as dirname6, isAbsolute, relative, sep } from "path";
+var home2 = homedir3();
 function buildServerConfig(parsed, options = {}) {
   if (parsed.type === "remote") {
     const config2 = {
@@ -1222,6 +1255,9 @@ function buildServerConfig(parsed, options = {}) {
     if (options.oauthScopes && options.oauthScopes.length > 0) {
       config2.oauthScopes = options.oauthScopes;
     }
+    if (options.autoApproveTools) {
+      config2.autoApproveTools = options.autoApproveTools;
+    }
     return config2;
   }
   if (parsed.type === "command") {
@@ -1243,6 +1279,9 @@ function buildServerConfig(parsed, options = {}) {
     if (options.env && Object.keys(options.env).length > 0) {
       config2.env = options.env;
     }
+    if (options.autoApproveTools) {
+      config2.autoApproveTools = options.autoApproveTools;
+    }
     return config2;
   }
   const config = {
@@ -1252,8 +1291,66 @@ function buildServerConfig(parsed, options = {}) {
   if (options.env && Object.keys(options.env).length > 0) {
     config.env = options.env;
   }
+  if (options.autoApproveTools) {
+    config.autoApproveTools = options.autoApproveTools;
+  }
   return config;
 }
+function readJsonObject(filePath) {
+  if (!existsSync5(filePath)) {
+    return {};
+  }
+  const parsed = JSON.parse(readFileSync4(filePath, "utf-8"));
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function writeJsonObject(filePath, value) {
+  const dir = dirname6(filePath);
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  writeFileSync4(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function addUniqueStrings(existing, additions) {
+  const values = Array.isArray(existing) ? existing.filter((value) => typeof value === "string") : [];
+  for (const addition of additions) {
+    if (!values.includes(addition)) {
+      values.push(addition);
+    }
+  }
+  return values;
+}
+function claudeAutoApproveRules(serverName, tools) {
+  if (tools.length === 0) {
+    return [`mcp__${serverName}`];
+  }
+  return tools.map((tool) => `mcp__${serverName}__${tool}`);
+}
+function getClaudeCodeSettingsPath(options = {}) {
+  const local = Boolean(options.local);
+  const cwd = options.cwd || process.cwd();
+  return local ? join3(cwd, ".claude", "settings.local.json") : join3(home2, ".claude", "settings.json");
+}
+function installClaudeCodeAutoApproval(serverName, tools, options = {}) {
+  const settingsPath = getClaudeCodeSettingsPath(options);
+  try {
+    const settings = readJsonObject(settingsPath);
+    const permissions = settings.permissions && typeof settings.permissions === "object" && !Array.isArray(settings.permissions) ? settings.permissions : {};
+    permissions.allow = addUniqueStrings(
+      permissions.allow,
+      claudeAutoApproveRules(serverName, tools)
+    );
+    settings.permissions = permissions;
+    writeJsonObject(settingsPath, settings);
+    return { success: true, path: settingsPath };
+  } catch (error) {
+    return {
+      success: false,
+      path: settingsPath,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
 function updateGitignoreWithPaths(paths, options = {}) {
   const cwd = options.cwd || process.cwd();
   const gitignorePath = join3(cwd, ".gitignore");
@@ -1324,10 +1421,27 @@ function installServerForAgent(serverName, serverConfig, agentType, options = {}
     const configKey = getConfigKey(agent, options);
     const config = buildConfigWithKey(configKey, serverName, transformedConfig);
     writeConfig2(configPath, config, agent.format, configKey);
+    const extraPaths = [];
+    if (agentType === "claude-code" && gatedConfig.autoApproveTools) {
+      const approval = installClaudeCodeAutoApproval(
+        serverName,
+        gatedConfig.autoApproveTools,
+        options
+      );
+      if (!approval.success) {
+        return {
+          success: false,
+          path: approval.path,
+          error: approval.error
+        };
+      }
+      extraPaths.push(approval.path);
+    }
     return {
       success: true,
       path: configPath,
-      ...dropped.length > 0 ? { droppedFields: dropped } : {}
+      ...dropped.length > 0 ? { droppedFields: dropped } : {},
+      ...extraPaths.length > 0 ? { extraPaths } : {}
     };
   } catch (error) {
     return {
@@ -1480,6 +1594,7 @@ export {
   agents,
   getAgentTypes,
   supportsProjectConfig,
+  getCommonInstallScopes,
   getProjectCapableAgents,
   detectProjectAgents,
   detectGlobalAgents,

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   detectProjectAgents,
   findMatchingServers,
   getAgentTypes,
+  getCommonInstallScopes,
   getConfigPath,
   getFindRegistries,
   getLastSelectedAgents,
@@ -23,7 +24,7 @@ import {
   selectAgentsInteractive,
   supportsProjectConfig,
   updateGitignoreWithPaths
-} from "./chunk-2OCTBM45.js";
+} from "./chunk-3ZFFEEQJ.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -783,7 +784,7 @@ async function runFind(query, options) {
 // package.json
 var package_default = {
   name: "add-mcp",
-  version: "1.11.0",
+  version: "1.13.0",
   description: "Add MCP servers to your favorite coding agents with a single command.",
   author: "Andre Landgraf <andre@neon.tech>",
   license: "Apache-2.0",
@@ -974,6 +975,25 @@ function extractSubcommandOptionsFromArgv() {
       result.gitignore = true;
       continue;
     }
+    if (arg === "--auto-approve") {
+      result.autoApprove = true;
+      continue;
+    }
+    if (arg === "--approve-tool") {
+      const tools = result.approveTool ? [...result.approveTool] : [];
+      let j = i + 1;
+      while (j < argv.length) {
+        const value = argv[j];
+        if (!value || value.startsWith("-")) break;
+        tools.push(value);
+        j += 1;
+      }
+      if (tools.length > 0) {
+        result.approveTool = tools;
+      }
+      i = j - 1;
+      continue;
+    }
     if ((arg === "-h" || arg === "--header") && argv[i + 1]) {
       const headers = result.header ? [...result.header] : [];
       headers.push(argv[i + 1]);
@@ -1126,7 +1146,15 @@ program.name("add-mcp").description(
 ).option(
   "--scopes <scopes>",
   "OAuth scopes to request for remote servers (comma-separated). Only applied to agents that support it (e.g. Cursor, Gemini CLI); dropped with a warning elsewhere."
-).option("--oauth-scopes <scopes>", "Alias for --scopes").option("-y, --yes", "Skip confirmation prompts").option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(async (target, options) => {
+).option("--oauth-scopes <scopes>", "Alias for --scopes").option(
+  "--auto-approve",
+  "Auto-approve MCP tool calls for agents that support it (Codex, Claude Code). Dropped with a warning for other agents."
+).option(
+  "--approve-tool <tool>",
+  "Tool name to auto-approve when --auto-approve is set (repeatable; defaults to all tools)",
+  collect,
+  []
+).option("-y, --yes", "Skip confirmation prompts").option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(async (target, options) => {
   await main(target, options);
 });
 program.command("list-agents").description("List all supported coding agents").action(() => {
@@ -1172,7 +1200,15 @@ program.command("find [keyword]").description(
 ).option("-a, --agent <agent>", "Specify agents to install to", collect, []).option(
   "-n, --name <name>",
   "Server name override (defaults to catalog entry name)"
-).option("-y, --yes", "Skip confirmation prompts").option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(
+).option("-y, --yes", "Skip confirmation prompts").option(
+  "--auto-approve",
+  "Auto-approve MCP tool calls for agents that support it (Codex, Claude Code)"
+).option(
+  "--approve-tool <tool>",
+  "Tool name to auto-approve when --auto-approve is set (repeatable; defaults to all tools)",
+  collect,
+  []
+).option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(
   async (keyword, options) => {
     await runFindCommand(keyword, options);
   }
@@ -1183,7 +1219,15 @@ program.command("search [keyword]").description("Alias for find").option(
 ).option("-a, --agent <agent>", "Specify agents to install to", collect, []).option(
   "-n, --name <name>",
   "Server name override (defaults to catalog entry name)"
-).option("-y, --yes", "Skip confirmation prompts").option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(
+).option("-y, --yes", "Skip confirmation prompts").option(
+  "--auto-approve",
+  "Auto-approve MCP tool calls for agents that support it (Codex, Claude Code)"
+).option(
+  "--approve-tool <tool>",
+  "Tool name to auto-approve when --auto-approve is set (repeatable; defaults to all tools)",
+  collect,
+  []
+).option("--all", "Install to all agents").option("--gitignore", "Add generated project config files to .gitignore").action(
   async (keyword, options) => {
     await runFindCommand(keyword, options);
   }
@@ -1829,18 +1873,19 @@ async function main(target, options) {
       p2.log.warn("--scopes is only used for remote URLs, ignoring");
     }
   }
+  const approveTools = [...new Set(options.approveTool ?? [])];
+  const autoApproveTools = options.autoApprove || approveTools.length > 0 ? approveTools : void 0;
   const serverConfig = buildServerConfig(parsed, {
     transport: resolvedTransport,
     headers: headersForConfig && Object.keys(headersForConfig).length > 0 ? headersForConfig : void 0,
     env: envForConfig && Object.keys(envForConfig).length > 0 ? envForConfig : void 0,
     args: argsForConfig && argsForConfig.length > 0 ? argsForConfig : void 0,
     timeout: resolvedTimeout,
-    oauthScopes: resolvedScopes
+    oauthScopes: resolvedScopes,
+    autoApproveTools
   });
   let targetAgents;
   const allAgentTypes = getAgentTypes();
-  const hasExplicitAgentFlags = options.agent && options.agent.length > 0 || options.all === true;
-  let selectedViaPrompt = false;
   let agentRouting = /* @__PURE__ */ new Map();
   if (options.agent && options.agent.length > 0) {
     const resolved = [];
@@ -1900,7 +1945,7 @@ async function main(target, options) {
           );
         }
       } else {
-        const availableAgents = options.global ? allAgentTypes : getProjectCapableAgents();
+        const availableAgents = allAgentTypes;
         p2.log.warn(
           options.global ? "No coding agents detected." : "No agents detected in this project."
         );
@@ -1911,18 +1956,14 @@ async function main(target, options) {
           p2.cancel("Installation cancelled");
           process.exit(0);
         }
-        selectedViaPrompt = true;
         targetAgents = selected;
-        for (const agent of targetAgents) {
-          agentRouting.set(agent, options.global ? "global" : "local");
-        }
       }
     } else if (options.yes) {
       targetAgents = detectedAgents;
       const agentNames = detectedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ");
       p2.log.info(`Installing to: ${agentNames}`);
     } else {
-      const availableAgents = options.global ? allAgentTypes : getProjectCapableAgents();
+      const availableAgents = allAgentTypes;
       let lastSelected;
       try {
         lastSelected = await getLastSelectedAgents();
@@ -1944,11 +1985,7 @@ async function main(target, options) {
         p2.cancel("Installation cancelled");
         process.exit(0);
       }
-      selectedViaPrompt = true;
       targetAgents = selected;
-      for (const agent of targetAgents) {
-        agentRouting.set(agent, options.global ? "global" : "local");
-      }
     }
   }
   const requiredTransport = isRemoteSource(parsed) ? resolvedTransport ?? "http" : "stdio";
@@ -1982,70 +2019,62 @@ async function main(target, options) {
       process.exit(1);
     }
   }
-  const hasSmartRouting = agentRouting.size > 0;
   if (options.global) {
+    agentRouting = /* @__PURE__ */ new Map();
     for (const agent of targetAgents) {
       agentRouting.set(agent, "global");
     }
-  } else if (!hasSmartRouting) {
-    const selectedWithLocal = targetAgents.filter(
-      (a) => supportsProjectConfig(a)
-    );
-    const globalOnlySelected = targetAgents.filter(
-      (a) => !supportsProjectConfig(a)
-    );
-    for (const agent of globalOnlySelected) {
-      agentRouting.set(agent, "global");
+  } else {
+    const commonScopes = getCommonInstallScopes(targetAgents);
+    if (commonScopes.length === 0) {
+      p2.log.error("No agents selected");
+      process.exit(1);
     }
-    if (selectedWithLocal.length > 0) {
-      let installLocally = true;
-      if (!options.yes) {
-        const scope = await p2.select({
-          message: "Installation scope",
-          options: [
-            {
-              value: true,
-              label: "Project",
-              hint: "Install in current directory (committed with your project)"
-            },
-            {
-              value: false,
-              label: "Global",
-              hint: "Install in home directory (available across all projects)"
-            }
-          ]
-        });
-        if (p2.isCancel(scope)) {
-          p2.cancel("Installation cancelled");
-          process.exit(0);
-        }
-        installLocally = scope;
-      }
-      for (const agent of selectedWithLocal) {
-        agentRouting.set(agent, installLocally ? "local" : "global");
+    let installScope = commonScopes[0];
+    if (commonScopes.length > 1 && !options.yes) {
+      const scope = await p2.select({
+        message: "Installation scope",
+        options: [
+          {
+            value: "local",
+            label: "Project",
+            hint: "Install in current directory (committed with your project)"
+          },
+          {
+            value: "global",
+            label: "Global",
+            hint: "Install in home directory (available across all projects)"
+          }
+        ]
+      });
+      if (p2.isCancel(scope)) {
+        p2.cancel("Installation cancelled");
+        process.exit(0);
       }
-    } else {
-      p2.log.info("Selected agents only support global installation");
+      installScope = scope;
+    } else if (installScope === "global") {
+      p2.log.info("Selected agents require global installation");
+    }
+    agentRouting = /* @__PURE__ */ new Map();
+    for (const agent of targetAgents) {
+      agentRouting.set(agent, installScope);
     }
   }
   const summaryLines = [];
   summaryLines.push(`${chalk.cyan("Server:")} ${serverName}`);
   summaryLines.push(`${chalk.cyan("Type:")} ${sourceType}`);
+  if (autoApproveTools) {
+    summaryLines.push(
+      `${chalk.cyan("Auto-approve:")} ${autoApproveTools.length === 0 ? "All tools" : autoApproveTools.join(", ")}`
+    );
+  }
   const localAgents = targetAgents.filter(
     (a) => agentRouting.get(a) === "local"
   );
   const globalAgents = targetAgents.filter(
     (a) => agentRouting.get(a) === "global"
   );
-  if (localAgents.length > 0 && globalAgents.length > 0) {
-    summaryLines.push(`${chalk.cyan("Scope:")} Mixed (project + global)`);
-    summaryLines.push(
-      `${chalk.cyan("  Project:")} ${localAgents.map((a) => agents[a].displayName).join(", ")}`
-    );
-    summaryLines.push(
-      `${chalk.cyan("  Global:")} ${globalAgents.map((a) => agents[a].displayName).join(", ")}`
-    );
-  } else if (localAgents.length > 0) {
+  if (localAgents.length > 0) {
     summaryLines.push(`${chalk.cyan("Scope:")} Project`);
     summaryLines.push(
       `${chalk.cyan("Agents:")} ${localAgents.map((a) => agents[a].displayName).join(", ")}`
@@ -2083,6 +2112,11 @@ async function main(target, options) {
       resultLines.push(
         `${chalk.green("\u2713")} ${agent.displayName}: ${chalk.dim(shortPath)}`
       );
+      for (const extraPath of result.extraPaths ?? []) {
+        resultLines.push(
+          `  ${chalk.dim("\u21B3 permissions:")} ${chalk.dim(shortenPath(extraPath))}`
+        );
+      }
     }
     p2.note(
       resultLines.join("\n"),
@@ -2118,12 +2152,15 @@ async function main(target, options) {
       `${describeOptionalField(field)} is not supported by ${agentNames.join(", ")}; dropped from ${agentNames.length === 1 ? "that config" : "those configs"}.`
     );
   }
-  if (options.gitignore && options.global) {
+  if (options.gitignore && localAgents.length === 0) {
     p2.log.warn(
       "--gitignore is only supported for project-scoped installations; ignoring."
     );
   } else if (options.gitignore) {
-    const successfulPaths = successful.map(([_, result]) => result.path);
+    const successfulPaths = successful.flatMap(([_, result]) => [
+      result.path,
+      ...result.extraPaths ?? []
+    ]);
     const gitignoreUpdate = updateGitignoreWithPaths(successfulPaths);
     if (gitignoreUpdate.added.length > 0) {
       p2.log.info(

package/dist/lib.d.ts

@@ -8,7 +8,7 @@
  * before its transform runs, guaranteeing that only known fields are ever
  * written to a client config.
  */
-type OptionalField = "timeout" | "scopes";
+type OptionalField = "timeout" | "scopes" | "autoApprove";
 
 type AgentType = "antigravity" | "cline" | "cline-cli" | "claude-code" | "claude-desktop" | "codex" | "cursor" | "gemini-cli" | "goose" | "github-copilot-cli" | "mcporter" | "opencode" | "vscode" | "windsurf" | "zed";
 type ConfigFormat = "json" | "yaml" | "toml";
@@ -79,6 +79,15 @@ interface McpServerConfig {
      * their own native shape (e.g. Cursor `auth.scopes`, Gemini `oauth.scopes`).
      */
     oauthScopes?: string[];
+    /**
+     * Tools to auto-approve (skip the agent's per-call approval prompt). An empty
+     * array means "all tools". This is an install directive rather than a literal
+     * server-config key: capability-gated via `"autoApprove"` in `supportedFields`
+     * and each supporting agent applies it in its own way (e.g. Codex emits
+     * approval modes in its config; Claude Code writes permission allow rules to a
+     * separate settings file). It is never written into a server entry verbatim.
+     */
+    autoApproveTools?: string[];
 }
 
 interface InstallOptions {
@@ -96,6 +105,12 @@ interface InstallResult {
      * does not support them. Empty/undefined when nothing was dropped.
      */
     droppedFields?: OptionalField[];
+    /**
+     * Additional files written beyond the main config (e.g. a Claude Code
+     * permissions settings file for auto-approval). Surfaced so the CLI can
+     * report them and include them in `--gitignore`.
+     */
+    extraPaths?: string[];
 }
 
 declare const agents: Record<AgentType, AgentConfig>;

package/dist/lib.js

@@ -10,7 +10,7 @@ import {
   listInstalledServers,
   readConfig,
   removeServerFromConfig
-} from "./chunk-2OCTBM45.js";
+} from "./chunk-3ZFFEEQJ.js";
 
 // src/lib.ts
 import { existsSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-mcp",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Add MCP servers to your favorite coding agents with a single command.",
   "author": "Andre Landgraf <andre@neon.tech>",
   "license": "Apache-2.0",