@compass-ai/nova 1.0.73 → 1.0.74

package/dist/services/mcp-config-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-config-manager.d.ts","sourceRoot":"","sources":["../../src/services/mcp-config-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,EACL,eAAe,EAEf,QAAQ,EAER,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EAQb,MAAM,iBAAiB,CAAC;AAuCzB;;GAEG;AACH,cAAM,gBAAgB;IACpB,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,cAAc,CAAyC;IAC/D,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,iBAAiB,CAAqB;;IAM9C;;OAEG;IACG,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC/C;;OAEG;YACW,cAAc;IAyB5B;;OAEG;YACW,iBAAiB;IA0B/B;;OAEG;YACW,cAAc;IA0B5B;;OAEG;YACW,iBAAiB;IAa/B;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,mBAAmB,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA2DhG;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiC1B;;OAEG;YACW,mBAAmB;IAajC;;OAEG;YACW,sBAAsB;IAoBpC;;OAEG;YACW,oBAAoB;IAkBlC;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAiDnF;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAwC1E;;OAEG;IACH,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE;IAsEtD;;OAEG;IACG,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,KAAK,GAAE,QAAkB,EACzB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,kBAAkB,CAAC;IAgC9B;;OAEG;IACH,qBAAqB,CAAC,YAAY,EAAE,qBAAqB,GAAG,IAAI;IAKhE;;OAEG;IACH,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOjD;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAI9C;;OAEG;IACG,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3D;;OAEG;IACH,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAYzE;;OAEG;IACG,wBAAwB,CAC5B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IAsBhB;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;IAKnD;;OAEG;IACH,OAAO,CAAC,aAAa;IA6CrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAchD;;OAEG;IACH,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,EAAE;CAqBpE;AAKD;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAKtD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/services/mcp-config-manager.js

@@ -0,0 +1,678 @@
+/**
+ * MCP Configuration Manager Service.
+ *
+ * This service manages MCP server configurations across three scopes:
+ * - Local: Private to user in current project (~/.compass.json under project paths)
+ * - Project: Shared via .mcp.json file at project root
+ * - User: Available across all projects (~/.compass.json)
+ *
+ * Features:
+ * - Configuration loading from all scopes with precedence handling
+ * - Environment variable expansion (${VAR} and ${VAR:-default} syntax)
+ * - Project approval tracking for .mcp.json servers
+ * - Plugin MCP server support
+ */
+import { safeReadFile, safeWriteFile, pathExists, ensureDir } from '../utils/file-system.js';
+import { getGlobalCompassDir } from '../utils/path.js';
+import { logger } from '../utils/logger.js';
+import { createHash } from 'crypto';
+import { isValidMCPServerConfig, isMCPHttpConfig, isMCPSseConfig, isMCPStdioConfig, normalizeServerConfig, } from '../types/mcp.js';
+/**
+ * Built-in MCP servers that are always available.
+ */
+const BUILTIN_MCP_SERVERS = {
+    fetch: {
+        type: 'stdio',
+        command: 'uvx',
+        args: ['mcp-server-fetch'],
+        enabled: true,
+        description: 'Fetch webpages',
+    },
+    compass: {
+        type: 'sse',
+        url: 'https://k-mcp.compassap.ai/sse',
+        timeout: 180000,
+        headers: {},
+        enabled: true,
+        requiresCompassApiKey: true,
+        description: 'Compass MCP server - provides Compass API tools (requires Compass API key)',
+    },
+};
+/**
+ * MCP Configuration Manager class.
+ */
+class MCPConfigManager {
+    userConfig = {};
+    projectConfigs = new Map();
+    pluginConfigs = [];
+    configPath;
+    loaded = false;
+    loadedProjectRoot;
+    constructor() {
+        this.configPath = `${getGlobalCompassDir()}/config.json`;
+    }
+    /**
+     * Loads all MCP configurations.
+     */
+    async load(projectRoot) {
+        // Skip if already loaded with the same project root
+        if (this.loaded && this.loadedProjectRoot === projectRoot) {
+            logger.debug('MCP configurations already loaded, skipping reload');
+            return;
+        }
+        try {
+            logger.debug('Loading MCP configurations...');
+            // Load user/local config from ~/.compass/config.json
+            await this.loadUserConfig();
+            // Load project config from .mcp.json if projectRoot provided
+            if (projectRoot) {
+                logger.debug(`Loading project MCP config from: ${projectRoot}`);
+                await this.loadProjectConfig(projectRoot);
+            }
+            else {
+                logger.debug('No project root provided, skipping project MCP config');
+            }
+            this.loaded = true;
+            this.loadedProjectRoot = projectRoot;
+            const allServers = this.getAllServers(projectRoot);
+            logger.debug(`MCP configurations loaded. Total servers available: ${allServers.length}`);
+            if (allServers.length > 0) {
+                logger.debug(`Server names: ${allServers.map(s => s.name).join(', ')}`);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to load MCP configurations', error);
+            throw error;
+        }
+    }
+    /**
+     * Loads user-scoped configuration from ~/.compass/config.json
+     */
+    async loadUserConfig() {
+        try {
+            if (await pathExists(this.configPath)) {
+                logger.debug(`Loading user MCP config from: ${this.configPath}`);
+                const content = await safeReadFile(this.configPath);
+                const parsed = JSON.parse(content || '{}');
+                this.userConfig = {
+                    mcpServers: parsed.mcpServers || {},
+                    mcpServersByProject: parsed.mcpServersByProject || {},
+                    mcpProjectApprovals: parsed.mcpProjectApprovals || [],
+                    trustedMCPProjects: parsed.trustedMCPProjects || [],
+                };
+                const userServerCount = Object.keys(this.userConfig.mcpServers || {}).length;
+                const localProjectCount = Object.keys(this.userConfig.mcpServersByProject || {}).length;
+                logger.debug(`User MCP config loaded: ${userServerCount} user-scoped server(s), ${localProjectCount} project(s) with local servers`);
+            }
+            else {
+                logger.debug(`No user MCP config found at: ${this.configPath}`);
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to load user MCP config, using defaults', error);
+            this.userConfig = {};
+        }
+    }
+    /**
+     * Loads project-scoped configuration from .mcp.json
+     */
+    async loadProjectConfig(projectRoot) {
+        const mcpJsonPath = `${projectRoot}/.mcp.json`;
+        try {
+            if (await pathExists(mcpJsonPath)) {
+                logger.info(`MCP config file found at: ${mcpJsonPath}`);
+                const content = await safeReadFile(mcpJsonPath);
+                const parsed = JSON.parse(content || '{}');
+                const serverCount = parsed.mcpServers ? Object.keys(parsed.mcpServers).length : 0;
+                if (serverCount > 0) {
+                    logger.debug(`Loading ${serverCount} MCP server(s) from ${mcpJsonPath}`);
+                    logger.debug(`Server names: ${Object.keys(parsed.mcpServers || {}).join(', ')}`);
+                }
+                else {
+                    logger.debug(`MCP config file found but contains no servers: ${mcpJsonPath}`);
+                }
+                this.projectConfigs.set(projectRoot, parsed);
+            }
+            else {
+                logger.debug(`No .mcp.json file found at: ${mcpJsonPath}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to load project MCP config from ${mcpJsonPath}`, error);
+        }
+    }
+    /**
+     * Saves user-scoped configuration to ~/.compass/config.json
+     */
+    async saveUserConfig() {
+        try {
+            await ensureDir(getGlobalCompassDir());
+            let existingConfig = {};
+            if (await pathExists(this.configPath)) {
+                const content = await safeReadFile(this.configPath);
+                existingConfig = JSON.parse(content || '{}');
+            }
+            const updatedConfig = {
+                ...existingConfig,
+                mcpServers: this.userConfig.mcpServers,
+                mcpServersByProject: this.userConfig.mcpServersByProject,
+                mcpProjectApprovals: this.userConfig.mcpProjectApprovals,
+                trustedMCPProjects: this.userConfig.trustedMCPProjects,
+            };
+            await safeWriteFile(this.configPath, JSON.stringify(updatedConfig, null, 2));
+            logger.debug('Saved user MCP config');
+        }
+        catch (error) {
+            logger.error('Failed to save user MCP config', error);
+            throw error;
+        }
+    }
+    /**
+     * Saves project-scoped configuration to .mcp.json
+     */
+    async saveProjectConfig(projectRoot) {
+        const mcpJsonPath = `${projectRoot}/.mcp.json`;
+        const config = this.projectConfigs.get(projectRoot) || { mcpServers: {} };
+        try {
+            await safeWriteFile(mcpJsonPath, JSON.stringify(config, null, 2));
+            logger.debug(`Saved project MCP config to ${mcpJsonPath}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save project MCP config to ${mcpJsonPath}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Adds a new MCP server configuration.
+     */
+    async addServer(options, projectRoot) {
+        if (!this.loaded) {
+            await this.load(projectRoot);
+        }
+        const scope = options.scope || 'local';
+        const serverConfig = this.createServerConfig(options);
+        if (!isValidMCPServerConfig(serverConfig)) {
+            return {
+                success: false,
+                message: 'Invalid server configuration',
+                error: 'Configuration validation failed',
+            };
+        }
+        try {
+            switch (scope) {
+                case 'user':
+                    await this.addUserScopedServer(options.name, serverConfig);
+                    break;
+                case 'project':
+                    if (!projectRoot) {
+                        return {
+                            success: false,
+                            message: 'Project root required for project scope',
+                            error: 'No project root provided',
+                        };
+                    }
+                    await this.addProjectScopedServer(projectRoot, options.name, serverConfig);
+                    break;
+                case 'local':
+                default:
+                    if (!projectRoot) {
+                        return {
+                            success: false,
+                            message: 'Project root required for local scope',
+                            error: 'No project root provided',
+                        };
+                    }
+                    await this.addLocalScopedServer(projectRoot, options.name, serverConfig);
+                    break;
+            }
+            return {
+                success: true,
+                message: `Added MCP server '${options.name}' with ${scope} scope`,
+                data: serverConfig,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                message: `Failed to add server '${options.name}'`,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Creates a server configuration from add options.
+     */
+    createServerConfig(options) {
+        const base = {
+            name: options.name,
+            env: options.env,
+            scope: options.scope || 'local',
+        };
+        if (options.transport === 'http') {
+            return {
+                ...base,
+                type: 'http',
+                url: options.urlOrCommand,
+                headers: options.headers,
+            };
+        }
+        if (options.transport === 'sse') {
+            return {
+                ...base,
+                type: 'sse',
+                url: options.urlOrCommand,
+                headers: options.headers,
+            };
+        }
+        return {
+            ...base,
+            type: 'stdio',
+            command: options.urlOrCommand,
+            args: options.args,
+        };
+    }
+    /**
+     * Adds a server to user scope.
+     */
+    async addUserScopedServer(name, config) {
+        if (!this.userConfig.mcpServers) {
+            this.userConfig.mcpServers = {};
+        }
+        const { name: _name, ...configWithoutName } = config;
+        this.userConfig.mcpServers[name] = configWithoutName;
+        await this.saveUserConfig();
+    }
+    /**
+     * Adds a server to project scope.
+     */
+    async addProjectScopedServer(projectRoot, name, config) {
+        let projectConfig = this.projectConfigs.get(projectRoot);
+        if (!projectConfig) {
+            projectConfig = { mcpServers: {} };
+            this.projectConfigs.set(projectRoot, projectConfig);
+        }
+        if (!projectConfig.mcpServers) {
+            projectConfig.mcpServers = {};
+        }
+        const { name: _name, ...configWithoutName } = config;
+        projectConfig.mcpServers[name] = configWithoutName;
+        await this.saveProjectConfig(projectRoot);
+    }
+    /**
+     * Adds a server to local scope.
+     */
+    async addLocalScopedServer(projectRoot, name, config) {
+        if (!this.userConfig.mcpServersByProject) {
+            this.userConfig.mcpServersByProject = {};
+        }
+        if (!this.userConfig.mcpServersByProject[projectRoot]) {
+            this.userConfig.mcpServersByProject[projectRoot] = {};
+        }
+        const { name: _name, ...configWithoutName } = config;
+        this.userConfig.mcpServersByProject[projectRoot][name] = configWithoutName;
+        await this.saveUserConfig();
+    }
+    /**
+     * Removes an MCP server configuration.
+     */
+    async removeServer(name, projectRoot) {
+        if (!this.loaded) {
+            await this.load(projectRoot);
+        }
+        let removed = false;
+        let scope;
+        // Try local scope first
+        if (projectRoot && this.userConfig.mcpServersByProject?.[projectRoot]?.[name]) {
+            delete this.userConfig.mcpServersByProject[projectRoot][name];
+            await this.saveUserConfig();
+            removed = true;
+            scope = 'local';
+        }
+        // Try project scope
+        if (!removed && projectRoot) {
+            const projectConfig = this.projectConfigs.get(projectRoot);
+            if (projectConfig?.mcpServers?.[name]) {
+                delete projectConfig.mcpServers[name];
+                await this.saveProjectConfig(projectRoot);
+                removed = true;
+                scope = 'project';
+            }
+        }
+        // Try user scope
+        if (!removed && this.userConfig.mcpServers?.[name]) {
+            delete this.userConfig.mcpServers[name];
+            await this.saveUserConfig();
+            removed = true;
+            scope = 'user';
+        }
+        if (removed) {
+            return {
+                success: true,
+                message: `Removed MCP server '${name}' from ${scope} scope`,
+            };
+        }
+        return {
+            success: false,
+            message: `MCP server '${name}' not found`,
+            error: 'Server not found in any scope',
+        };
+    }
+    /**
+     * Gets a specific MCP server configuration.
+     */
+    getServer(name, projectRoot) {
+        // Precedence: local > project > user > builtin
+        if (projectRoot) {
+            // Check local scope
+            const localConfig = this.userConfig.mcpServersByProject?.[projectRoot]?.[name];
+            if (localConfig) {
+                const normalized = normalizeServerConfig({ ...localConfig, name, scope: 'local', source: 'local' });
+                return this.expandEnvVars(normalized);
+            }
+            // Check project scope
+            const projectConfig = this.projectConfigs.get(projectRoot)?.mcpServers?.[name];
+            if (projectConfig) {
+                const normalized = normalizeServerConfig({ ...projectConfig, name, scope: 'project', source: 'project' });
+                return this.expandEnvVars(normalized);
+            }
+        }
+        // Check user scope
+        const userConfig = this.userConfig.mcpServers?.[name];
+        if (userConfig) {
+            const normalized = normalizeServerConfig({ ...userConfig, name, scope: 'user', source: 'user' });
+            return this.expandEnvVars(normalized);
+        }
+        // Check built-in servers (lowest precedence)
+        const builtinConfig = BUILTIN_MCP_SERVERS[name];
+        if (builtinConfig) {
+            const normalized = normalizeServerConfig({
+                ...builtinConfig,
+                name,
+                scope: 'user',
+                source: 'builtin',
+            });
+            return this.expandEnvVars(normalized);
+        }
+        return undefined;
+    }
+    /**
+     * Gets all MCP server configurations for the given context.
+     */
+    getAllServers(projectRoot) {
+        const servers = new Map();
+        // Add built-in servers (lowest precedence)
+        for (const [name, config] of Object.entries(BUILTIN_MCP_SERVERS)) {
+            servers.set(name, this.expandEnvVars({
+                ...config,
+                name,
+                scope: 'user',
+                source: 'builtin',
+            }));
+        }
+        // Add user-scoped servers
+        if (this.userConfig.mcpServers) {
+            for (const [name, config] of Object.entries(this.userConfig.mcpServers)) {
+                servers.set(name, this.expandEnvVars({
+                    ...config,
+                    name,
+                    scope: 'user',
+                    source: 'user',
+                }));
+            }
+        }
+        if (projectRoot) {
+            // Add project-scoped servers (middle precedence)
+            const projectConfig = this.projectConfigs.get(projectRoot);
+            if (projectConfig?.mcpServers) {
+                for (const [name, config] of Object.entries(projectConfig.mcpServers)) {
+                    servers.set(name, this.expandEnvVars({
+                        ...config,
+                        name,
+                        scope: 'project',
+                        source: 'project',
+                    }));
+                }
+            }
+            // Add local-scoped servers (highest precedence)
+            const localServers = this.userConfig.mcpServersByProject?.[projectRoot];
+            if (localServers) {
+                for (const [name, config] of Object.entries(localServers)) {
+                    servers.set(name, this.expandEnvVars({
+                        ...config,
+                        name,
+                        scope: 'local',
+                        source: 'local',
+                    }));
+                }
+            }
+        }
+        // Add plugin-provided servers
+        for (const pluginConfig of this.pluginConfigs) {
+            for (const [name, config] of Object.entries(pluginConfig.servers)) {
+                if (!servers.has(name)) {
+                    servers.set(name, this.expandPluginEnvVars({
+                        ...config,
+                        name,
+                        source: 'plugin',
+                        pluginName: pluginConfig.pluginName,
+                    }, pluginConfig.pluginRoot));
+                }
+            }
+        }
+        return Array.from(servers.values());
+    }
+    /**
+     * Adds server configuration from JSON string.
+     */
+    async addServerFromJson(name, jsonConfig, scope = 'local', projectRoot) {
+        try {
+            const parsed = JSON.parse(jsonConfig);
+            const config = { ...parsed, name };
+            if (!isValidMCPServerConfig(config)) {
+                return {
+                    success: false,
+                    message: 'Invalid JSON configuration',
+                    error: 'Configuration does not match expected schema',
+                };
+            }
+            return this.addServer({
+                transport: config.type,
+                name,
+                urlOrCommand: isMCPStdioConfig(config) ? config.command : config.url,
+                args: isMCPStdioConfig(config) ? config.args : undefined,
+                headers: isMCPHttpConfig(config) || isMCPSseConfig(config) ? config.headers : undefined,
+                env: config.env,
+                scope,
+            }, projectRoot);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                message: 'Failed to parse JSON configuration',
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Registers plugin-provided MCP servers.
+     */
+    registerPluginServers(pluginConfig) {
+        this.pluginConfigs.push(pluginConfig);
+        logger.debug(`Registered MCP servers from plugin: ${pluginConfig.pluginName}`);
+    }
+    /**
+     * Unregisters plugin-provided MCP servers.
+     */
+    unregisterPluginServers(pluginName) {
+        this.pluginConfigs = this.pluginConfigs.filter((config) => config.pluginName !== pluginName);
+        logger.debug(`Unregistered MCP servers from plugin: ${pluginName}`);
+    }
+    /**
+     * Checks if a project is fully trusted (all servers auto-approved).
+     */
+    isProjectTrusted(projectRoot) {
+        return this.userConfig.trustedMCPProjects?.includes(projectRoot) ?? false;
+    }
+    /**
+     * Marks a project as trusted (all current and future servers auto-approved).
+     */
+    async setProjectTrusted(projectRoot) {
+        if (!this.userConfig.trustedMCPProjects) {
+            this.userConfig.trustedMCPProjects = [];
+        }
+        if (!this.userConfig.trustedMCPProjects.includes(projectRoot)) {
+            this.userConfig.trustedMCPProjects.push(projectRoot);
+            await this.saveUserConfig();
+        }
+    }
+    /**
+     * Checks if a project server has been approved.
+     */
+    isProjectServerApproved(projectRoot, serverName) {
+        // If the project is trusted, all servers are approved
+        if (this.isProjectTrusted(projectRoot)) {
+            return true;
+        }
+        const approval = this.userConfig.mcpProjectApprovals?.find((a) => a.projectPath === projectRoot && a.serverName === serverName && a.approved);
+        return !!approval;
+    }
+    /**
+     * Records a project server approval decision.
+     */
+    async setProjectServerApproval(projectRoot, serverName, approved, configHash) {
+        if (!this.userConfig.mcpProjectApprovals) {
+            this.userConfig.mcpProjectApprovals = [];
+        }
+        // Remove existing approval for this server
+        this.userConfig.mcpProjectApprovals = this.userConfig.mcpProjectApprovals.filter((a) => !(a.projectPath === projectRoot && a.serverName === serverName));
+        // Add new approval
+        this.userConfig.mcpProjectApprovals.push({
+            projectPath: projectRoot,
+            serverName,
+            approved,
+            decidedAt: new Date(),
+            configHash,
+        });
+        await this.saveUserConfig();
+    }
+    /**
+     * Resets all project approval choices.
+     */
+    async resetProjectApprovals() {
+        this.userConfig.mcpProjectApprovals = [];
+        await this.saveUserConfig();
+    }
+    /**
+     * Generates a hash of server configuration for change detection.
+     */
+    generateConfigHash(config) {
+        const { name: _name, source: _source, ...rest } = config;
+        return createHash('sha256').update(JSON.stringify(rest)).digest('hex').substring(0, 16);
+    }
+    /**
+     * Expands environment variables in a configuration.
+     */
+    expandEnvVars(config) {
+        const expandString = (str) => {
+            return str.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+                const match = expr.match(/^([^:-]+)(?::-(.*))?$/);
+                if (!match)
+                    return str;
+                const [, varName, defaultValue] = match;
+                const value = process.env[varName];
+                if (value !== undefined) {
+                    return value;
+                }
+                if (defaultValue !== undefined) {
+                    return defaultValue;
+                }
+                logger.warn(`Environment variable ${varName} is not set and has no default`);
+                return '';
+            });
+        };
+        const expandObject = (obj) => {
+            if (typeof obj === 'string') {
+                return expandString(obj);
+            }
+            if (Array.isArray(obj)) {
+                return obj.map(expandObject);
+            }
+            if (obj && typeof obj === 'object') {
+                const result = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    result[key] = expandObject(value);
+                }
+                return result;
+            }
+            return obj;
+        };
+        return expandObject(config);
+    }
+    /**
+     * Expands environment variables in plugin configuration, including COMPASS_PLUGIN_ROOT.
+     */
+    expandPluginEnvVars(config, pluginRoot) {
+        // First expand COMPASS_PLUGIN_ROOT
+        const configWithPluginRoot = JSON.parse(JSON.stringify(config).replace(/\$\{COMPASS_PLUGIN_ROOT\}/g, pluginRoot));
+        // Then expand other env vars
+        return this.expandEnvVars(configWithPluginRoot);
+    }
+    /**
+     * Parses environment variable reference from string.
+     */
+    parseEnvVarRef(str) {
+        const match = str.match(/^\$\{([^}]+)\}$/);
+        if (!match)
+            return null;
+        const expr = match[1];
+        const parts = expr.match(/^([^:-]+)(?::-(.*))?$/);
+        if (!parts)
+            return null;
+        return {
+            name: parts[1],
+            defaultValue: parts[2],
+        };
+    }
+    /**
+     * Gets servers that need project approval.
+     */
+    getUnapprovedProjectServers(projectRoot) {
+        const projectConfig = this.projectConfigs.get(projectRoot);
+        if (!projectConfig?.mcpServers) {
+            return [];
+        }
+        const unapproved = [];
+        for (const [name, config] of Object.entries(projectConfig.mcpServers)) {
+            if (!this.isProjectServerApproved(projectRoot, name)) {
+                unapproved.push({
+                    ...config,
+                    name,
+                    scope: 'project',
+                    source: 'project',
+                });
+            }
+        }
+        return unapproved;
+    }
+}
+// Singleton instance
+let mcpConfigManagerInstance = null;
+/**
+ * Gets the singleton MCPConfigManager instance.
+ */
+export function getMCPConfigManager() {
+    if (!mcpConfigManagerInstance) {
+        mcpConfigManagerInstance = new MCPConfigManager();
+    }
+    return mcpConfigManagerInstance;
+}
+/**
+ * Creates a new MCPConfigManager instance.
+ */
+export function createMCPConfigManager() {
+    return new MCPConfigManager();
+}
+export { MCPConfigManager };
+//# sourceMappingURL=mcp-config-manager.js.map