feat: auto-discover MCP servers from external AI tool configs

.gitignore

@@ -7,6 +7,7 @@ __pycache__
 .idea
 .vscode
 .codex
+.claude
 *~
 playground
 tmp

.opencode/command/discover-and-add-mcps.md

@@ -0,0 +1,19 @@
+---
+description: "Discover MCP servers from external AI tool configs and add them permanently"
+---
+
+Discover MCP servers configured in other AI tools (VS Code, Cursor, GitHub Copilot, Claude Code, Gemini CLI) and add them to the altimate-code config.
+
+## Instructions
+
+1. First, call the `mcp_discover` tool with `action: "list"` to see what's available.
+
+2. Show the user the results — which servers are new and which are already configured.
+
+3. If there are new servers, ask the user which ones they want to add and what scope (project or global).
+
+4. Call `mcp_discover` with `action: "add"`, the chosen `scope`, and the selected `servers` array.
+
+5. Report what was added and where.
+
+If $ARGUMENTS contains `--scope global`, use `scope: "global"`. Otherwise default to `scope: "project"`.

.opencode/opencode.jsonc

@@ -15,4 +15,7 @@
  "github-triage": false,
  "github-pr-search": false,
  },
+ "experimental": {
+ "auto_mcp_discovery": false,
+ },
 }

docs/docs/configure/tools.md

@@ -110,3 +110,41 @@ When [LSP servers](lsp.md) are configured, the `lsp` tool provides:
 - Go-to-definition
 - Hover information
 - Completions
+
+### MCP Discover Tool
+
+The `mcp_discover` tool finds MCP servers configured in other AI coding tools and can add them to your altimate-code config permanently.
+
+**Supported sources:**
+
+| Tool | Config Path | Key |
+|------|------------|-----|
+| VS Code / Copilot | `.vscode/mcp.json` | `servers` |
+| Cursor | `.cursor/mcp.json` | `mcpServers` |
+| GitHub Copilot | `.github/copilot/mcp.json` | `mcpServers` |
+| Claude Code | `.mcp.json`, `~/.claude.json` | `mcpServers` |
+| Gemini CLI | `.gemini/settings.json` | `mcpServers` |
+
+**Actions:**
+
+- `mcp_discover(action: "list")` — Show discovered servers and which are already in your config
+- `mcp_discover(action: "add", scope: "project")` — Write new servers to `.altimate-code/altimate-code.json`
+- `mcp_discover(action: "add", scope: "global")` — Write to the global config dir (`~/.config/opencode/`)
+
+**Auto-discovery:** At startup, altimate-code discovers external MCP servers and shows a toast notification. Servers from your home directory (`~/.claude.json`, `~/.gemini/settings.json`) are auto-enabled since they're user-owned. Servers from project-level files (`.vscode/mcp.json`, `.mcp.json`, `.cursor/mcp.json`) are discovered but **disabled by default** for security — run `/discover-and-add-mcps` to review and enable them.
+
+!!! tip
+ Home-directory MCP servers (from `~/.claude.json`, `~/.gemini/settings.json`) are loaded automatically. Project-scoped servers require explicit approval via `/discover-and-add-mcps` or `mcp_discover(action: "add")`.
+
+!!! warning "Security: untrusted repositories"
+ Project-level MCP configs (`.vscode/mcp.json`, `.mcp.json`, `.cursor/mcp.json`) are discovered but not auto-connected. This prevents malicious repositories from executing arbitrary commands. You must explicitly approve project-scoped servers before they run.
+
+To disable auto-discovery, set in your config:
+
+```json
+{
+ "experimental": {
+ "auto_mcp_discovery": false
+ }
+}
+```

packages/opencode/src/altimate/telemetry/index.ts

@@ -260,6 +260,14 @@ export namespace Telemetry {
  tool_count: number
  resource_count: number
  }
+ | {
+ type: "mcp_discovery"
+ timestamp: number
+ session_id: string
+ server_count: number
+ server_names: string[]
+ sources: string[]
+ }
  | {
  type: "memory_operation"
  timestamp: number

packages/opencode/src/altimate/tools/mcp-discover.ts

@@ -0,0 +1,120 @@
+import z from "zod"
+import { Tool } from "../../tool/tool"
+import { discoverExternalMcp } from "../../mcp/discover"
+import { resolveConfigPath, addMcpToConfig, findAllConfigPaths, listMcpInConfig } from "../../mcp/config"
+import { Instance } from "../../project/instance"
+import { Global } from "../../global"
+
+/**
+ * Check which MCP server names are permanently configured on disk
+ * (as opposed to ephemeral auto-discovered servers in memory).
+ */
+async function getPersistedMcpNames(): Promise<Set<string>> {
+ const configPaths = await findAllConfigPaths(Instance.worktree, Global.Path.config)
+ const names = new Set<string>()
+ for (const p of configPaths) {
+ for (const name of await listMcpInConfig(p)) {
+ names.add(name)
+ }
+ }
+ return names
+}
+
+/** Redact server details for safe display — show type and name only, not commands/URLs */
+function safeDetail(server: { type: string } & Record<string, any>): string {
+ if (server.type === "remote") return "(remote)"
+ if (server.type === "local" && Array.isArray(server.command) && server.command.length > 0) {
+ // Show only the executable name, not args (which may contain credentials)
+ return `(local: ${server.command[0]})`
+ }
+ return `(${server.type})`
+}
+
+export const McpDiscoverTool = Tool.define("mcp_discover", {
+ description:
+ "Discover MCP servers from external AI tool configs (VS Code, Cursor, Claude Code, Copilot, Gemini) and optionally add them to altimate-code config permanently.",
+ parameters: z.object({
+ action: z
+ .enum(["list", "add"])
+ .describe('"list" to show discovered servers, "add" to write them to config'),
+ scope: z
+ .enum(["project", "global"])
+ .optional()
+ .default("project")
+ .describe('Where to write when action is "add". "project" = .altimate-code/altimate-code.json, "global" = ~/.config/opencode/'),
+ servers: z
+ .array(z.string())
+ .optional()
+ .describe('Server names to add. If omitted with action "add", adds all new servers.'),
+ }),
+ async execute(args, ctx) {
+ const { servers: discovered } = await discoverExternalMcp(Instance.worktree)
+ const discoveredNames = Object.keys(discovered)
+
+ if (discoveredNames.length === 0) {
+ return {
+ title: "MCP Discover: none found",
+ metadata: { discovered: 0, new: 0, existing: 0, added: 0 },
+ output:
+ "No MCP servers found in external configs.\nChecked: .vscode/mcp.json, .cursor/mcp.json, .github/copilot/mcp.json, .mcp.json (project + home), .gemini/settings.json (project + home), ~/.claude.json",
+ }
+ }
+
+ // Check what's actually persisted on disk, NOT the merged in-memory config
+ const persistedNames = await getPersistedMcpNames()
+ const newServers = discoveredNames.filter((n) => !persistedNames.has(n))
+ const alreadyAdded = discoveredNames.filter((n) => persistedNames.has(n))
+
+ // Build discovery report — redact details for security (no raw commands/URLs)
+ const lines: string[] = []
+ if (newServers.length > 0) {
+ lines.push(`New servers (not yet in config):`)
+ for (const name of newServers) {
+ lines.push(` - ${name} ${safeDetail(discovered[name])}`)
+ }
+ }
+ if (alreadyAdded.length > 0) {
+ lines.push(`\nAlready in config: ${alreadyAdded.join(", ")}`)
+ }
+
+ if (args.action === "list") {
+ return {
+ title: `MCP Discover: ${newServers.length} new, ${alreadyAdded.length} existing`,
+ metadata: { discovered: discoveredNames.length, new: newServers.length, existing: alreadyAdded.length, added: 0 },
+ output: lines.join("\n"),
+ }
+ }
+
+ // action === "add"
+ const toAdd = args.servers
+ ? args.servers.filter((n) => newServers.includes(n))
+ : newServers
+
+ if (toAdd.length === 0) {
+ return {
+ title: "MCP Discover: nothing to add",
+ metadata: { discovered: discoveredNames.length, new: newServers.length, existing: alreadyAdded.length, added: 0 },
+ output: lines.join("\n") + "\n\nNo matching servers to add.",
+ }
+ }
+
+ const useGlobal = args.scope === "global"
+ const configPath = await resolveConfigPath(
+ useGlobal ? Global.Path.config : Instance.worktree,
+ useGlobal,
+ )
+
+ for (const name of toAdd) {
+ await addMcpToConfig(name, discovered[name], configPath)
+ }
+
+ lines.push(`\nAdded ${toAdd.length} server(s) to ${configPath}: ${toAdd.join(", ")}`)
+ lines.push("These servers are already active in the current session via auto-discovery.")
+
+ return {
+ title: `MCP Discover: added ${toAdd.length} server(s)`,
+ metadata: { discovered: discoveredNames.length, new: newServers.length, existing: alreadyAdded.length, added: toAdd.length },
+ output: lines.join("\n"),
+ }
+ },
+})

packages/opencode/src/config/config.ts

@@ -264,6 +264,24 @@ export namespace Config {
 
  result.plugin = deduplicatePlugins(result.plugin ?? [])
 
+ // altimate_change start — auto-discover MCP servers from external AI tool configs
+ if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG && result.experimental?.auto_mcp_discovery !== false) {
+ const { discoverExternalMcp, setDiscoveryResult } = await import("../mcp/discover")
+ const { servers: externalMcp, sources } = await discoverExternalMcp(Instance.worktree)
+ if (Object.keys(externalMcp).length > 0) {
+ result.mcp ??= {}
+ const added: string[] = []
+ for (const [name, server] of Object.entries(externalMcp)) {
+ if (!(name in result.mcp)) {
+ result.mcp[name] = server
+ added.push(name)
+ }
+ }
+ setDiscoveryResult(added, sources)
+ }
+ }
+ // altimate_change end
+
  return {
  config: result,
  directories,
@@ -1273,6 +1291,12 @@ export namespace Config {
  .optional()
  .describe("Use environment fingerprint to select relevant skills once per session (default: false). Set to true to enable LLM-based skill filtering."),
  // altimate_change end
+ // altimate_change start - auto MCP discovery toggle
+ auto_mcp_discovery: z
+ .boolean()
+ .optional()
+ .describe("Auto-discover MCP servers from VS Code, Claude Code, Copilot, and Gemini configs at startup (default: true). Set to false to disable."),
+ // altimate_change end
  })
  .optional(),
  })