@aws/lsp-codewhisperer 0.0.66 → 0.0.67

package/out/language-server/agenticChat/tools/mcp/mcpEventHandler.js

@@ -16,6 +16,8 @@ class McpEventHandler {
     #newlyAddedServers = new Set();
     #fileWatcher;
     #isProgrammaticChange = false;
+    #debounceTimer = null;
+    #lastProgrammaticState = false;
     constructor(features, telemetryService) {
         this.#features = features;
         this.#eventListenerRegistered = false;
@@ -53,6 +55,7 @@ class McpEventHandler {
      * Handles the list MCP servers event
      */
     async onListMcpServers(params) {
+        this.#currentEditingServerName = undefined;
         const mcpManager = mcpManager_1.McpManager.instance;
         // Check for errors in loading MCP config files
         const configLoadErrors = mcpManager.getConfigLoadErrors();
@@ -85,36 +88,39 @@ class McpEventHandler {
         // Transform server configs into DetailedListItem objects
         const activeItems = [];
         const disabledItems = [];
-        const builtInItems = [];
         // Get built-in tools programmatically
         const allTools = this.#features.agent.getTools({ format: 'bedrock' });
-        const mcpToolNames = new Set(mcpManager.getAllTools().map(tool => tool.toolName));
+        const builtInToolNames = new Set(this.#features.agent.getBuiltInToolNames());
         const builtInTools = allTools
-            .filter(tool => !mcpToolNames.has(tool.toolSpecification.name))
+            .filter(tool => {
+            return builtInToolNames.has(tool.toolSpecification.name) && tool.toolSpecification.name !== 'fsReplace';
+        })
             .map(tool => ({
             name: tool.toolSpecification.name,
-            description: tool.toolSpecification.description || `${tool.toolSpecification.name} tool`,
+            description: this.#getBuiltInToolDescription(tool.toolSpecification.name) ||
+                tool.toolSpecification.description ||
+                `${tool.toolSpecification.name} tool`,
         }));
         // Add built-in tools as a server in the active items
-        // activeItems.push({
-        //     title: 'Built-in',
-        //     description: `${builtInTools.length} tools`,
-        //     children: [
-        //         {
-        //             groupName: 'serverInformation',
-        //             children: [
-        //                 {
-        //                     title: 'status',
-        //                     description: 'ENABLED',
-        //                 },
-        //                 {
-        //                     title: 'toolcount',
-        //                     description: `${builtInTools.length}`,
-        //                 },
-        //             ],
-        //         },
-        //     ],
-        // })
+        activeItems.push({
+            title: 'Built-in',
+            description: `${builtInTools.length} tools`,
+            children: [
+                {
+                    groupName: 'serverInformation',
+                    children: [
+                        {
+                            title: 'status',
+                            description: 'ENABLED',
+                        },
+                        {
+                            title: 'toolcount',
+                            description: `${builtInTools.length}`,
+                        },
+                    ],
+                },
+            ],
+        });
         Array.from(mcpManagerServerConfigs.entries()).forEach(([serverName, config]) => {
             const toolsWithPermissions = mcpManager.getAllToolsWithPermissions(serverName);
             const toolsCount = toolsWithPermissions.length;
@@ -140,15 +146,13 @@ class McpEventHandler {
                     },
                 ],
             };
-            if (mcpManager.isServerDisabled(serverName)) {
-                disabledItems.push(item);
-            }
-            else {
-                activeItems.push({
-                    ...item,
-                    description: `${toolsCount}`,
-                });
-            }
+            // if (mcpManager.isServerDisabled(serverName)) {
+            //     disabledItems.push(item)
+            // } else {
+            activeItems.push({
+                ...item,
+                description: `${toolsCount}`,
+            });
         });
         // Create the groups
         const groups = [];
@@ -172,7 +176,7 @@ class McpEventHandler {
         }
         // Return the result in the expected format
         const header = {
-            title: 'MCP Servers',
+            title: 'MCP Servers and Built-in Tools',
             description: "Add MCP servers to extend Q's capabilities.",
             // only  show error on list mcp server page if unable to read mcp.json file
             status: configLoadErrors
@@ -214,7 +218,7 @@ class McpEventHandler {
         return {
             id,
             header: {
-                title: 'MCP Servers',
+                title: 'MCP Servers and Built-in Tools',
                 status: {},
                 description: `Add MCP servers to extend Q's capabilities.`,
                 actions: [],
@@ -260,12 +264,16 @@ class McpEventHandler {
             const serverName = existingValues.name;
             const sanitizedServerName = (0, mcpUtils_1.sanitizeName)(serverName);
             const serverState = mcpManager_1.McpManager.instance.getAllServerConfigs().get(sanitizedServerName);
-            if (!serverState ||
-                serverState?.__configPath__ === (0, mcpUtils_1.getGlobalMcpConfigPath)(this.#features.workspace.fs.getUserHomeDir())) {
-                existingValues.scope = 'global';
+            // Check if the server exists in McpManager
+            const mcpManager = mcpManager_1.McpManager.instance;
+            const serverConfig = mcpManager.getAllServerConfigs().get(sanitizedServerName);
+            if (serverConfig) {
+                // Use the helper method to determine if the server is global
+                existingValues.scope = mcpManager.isServerGlobal(sanitizedServerName) ? 'global' : 'workspace';
             }
             else {
-                existingValues.scope = 'workspace';
+                // Default to global scope for new servers
+                existingValues.scope = 'global';
             }
         }
         const serverStatusError = this.#getServerStatusError(existingValues.name) || {};
@@ -440,7 +448,10 @@ class McpEventHandler {
         else {
             if (checkExistingServerName) {
                 const existingServers = mcpManager_1.McpManager.instance.getAllServerConfigs();
-                if (existingServers.has(values.name) && values.name !== originalServerName) {
+                const serverState = mcpManager_1.McpManager.instance.getServerState(values.name);
+                if (existingServers.has(values.name) &&
+                    values.name !== originalServerName &&
+                    serverState?.status === mcpTypes_1.McpServerStatus.ENABLED) {
                     errors.push(`Server name "${values.name}" already exists`);
                 }
             }
@@ -539,22 +550,11 @@ class McpEventHandler {
             env,
             timeout: timeoutInMs,
         };
-        let configPath = (0, mcpUtils_1.getGlobalMcpConfigPath)(this.#features.workspace.fs.getUserHomeDir());
-        let personaPath = await this.#getPersonaPath();
-        if (params.optionsValues['scope'] !== 'global') {
-            // Get workspace folders and convert to paths
-            const workspaceFolders = this.#features.workspace.getAllWorkspaceFolders();
-            // Extract paths from workspace folders - uri is already a string
-            const workspacePaths = workspaceFolders.map(folder => folder.uri);
-            // Get the first path from the result or fall back to configPath
-            const workspaceMcpPaths = (0, mcpUtils_1.getWorkspaceMcpConfigPaths)(workspacePaths);
-            configPath =
-                Array.isArray(workspaceMcpPaths) && workspaceMcpPaths.length > 0
-                    ? (0, mcpUtils_1.normalizePathFromUri)(workspaceMcpPaths[0], this.#features.logging)
-                    : configPath;
-            // Get the appropriate persona path using our helper method
-            personaPath = await this.#getPersonaPath();
-        }
+        // Get agent path based on scope
+        const isGlobal = params.optionsValues['scope'] === 'global';
+        const agentPath = await this.#getAgentPath(isGlobal);
+        // We still need a configPath for backward compatibility, but it's not used anymore
+        const configPath = '';
         // needs to false BEFORE changing any server state, to prevent going to list servers page after clicking save button
         this.#shouldDisplayListMCPServers = false;
         // Set flag to ignore file changes during server operations
@@ -562,17 +562,16 @@ class McpEventHandler {
         try {
             if (isEditMode && originalServerName) {
                 await mcpManager_1.McpManager.instance.removeServer(originalServerName);
-                await mcpManager_1.McpManager.instance.addServer(serverName, config, configPath, personaPath);
+                await mcpManager_1.McpManager.instance.addServer(serverName, config, agentPath);
             }
             else {
                 // Create new server
-                await mcpManager_1.McpManager.instance.addServer(serverName, config, configPath, personaPath);
+                await mcpManager_1.McpManager.instance.addServer(serverName, config, agentPath);
                 this.#newlyAddedServers.add(serverName);
             }
         }
-        finally {
-            // Reset flag after operations
-            this.#isProgrammaticChange = false;
+        catch (error) {
+            this.#features.logging.error(`Failed to enable MCP server: ${error}`);
         }
         this.#currentEditingServerName = undefined;
         // need to check server state now, as there is possibility of error during server initialization
@@ -588,12 +587,12 @@ class McpEventHandler {
             languageServerVersion: this.#features.runtime.serverInfo.version,
         });
         if (serverStatusError) {
-            // Error case: remove config from config file only if it's a newly added server
+            await mcpManager_1.McpManager.instance.removeServerFromConfigFile(serverName);
             if (this.#newlyAddedServers.has(serverName)) {
-                await mcpManager_1.McpManager.instance.removeServerFromConfigFile(serverName);
                 this.#newlyAddedServers.delete(serverName);
             }
             // Stay on add/edit page and show error to user
+            // Keep isProgrammaticChange true during error handling to prevent file watcher triggers
             if (isEditMode) {
                 params.id = 'edit-mcp';
                 params.title = sanitizedServerName;
@@ -609,6 +608,7 @@ class McpEventHandler {
             if (this.#newlyAddedServers.has(serverName)) {
                 this.#newlyAddedServers.delete(serverName);
             }
+            this.#isProgrammaticChange = false;
             // Go to tools permissions page
             return this.#handleOpenMcpServer({ id: 'open-mcp-server', title: sanitizedServerName });
         }
@@ -626,16 +626,20 @@ class McpEventHandler {
         if (serverName === 'Built-in') {
             // Handle Built-in server specially
             const allTools = this.#features.agent.getTools({ format: 'bedrock' });
-            const mcpToolNames = new Set(mcpManager_1.McpManager.instance.getAllTools().map(tool => tool.toolName));
+            const builtInToolNames = new Set(this.#features.agent.getBuiltInToolNames());
+            // combine fsWrite and fsReplace into fsWrite
             const builtInTools = allTools
-                .filter(tool => !mcpToolNames.has(tool.toolSpecification.name))
+                .filter(tool => {
+                return (builtInToolNames.has(tool.toolSpecification.name) && tool.toolSpecification.name !== 'fsReplace');
+            })
                 .map(tool => {
-                // Set default permission based on tool name
-                const permission = 'alwaysAllow';
+                const permission = mcpManager_1.McpManager.instance.getToolPerm(serverName, tool.toolSpecification.name);
                 return {
                     tool: {
                         toolName: tool.toolSpecification.name,
-                        description: tool.toolSpecification.description || `${tool.toolSpecification.name} tool`,
+                        description: this.#getBuiltInToolDescription(tool.toolSpecification.name) ||
+                            tool.toolSpecification.description ||
+                            `${tool.toolSpecification.name} tool`,
                     },
                     permission,
                 };
@@ -646,6 +650,7 @@ class McpEventHandler {
                 header: {
                     title: serverName,
                     status: serverStatusError || {},
+                    description: 'TOOLS',
                     actions: [],
                 },
                 list: [],
@@ -689,12 +694,12 @@ class McpEventHandler {
         if (!serverName) {
             return { id: params.id };
         }
-        // Get the appropriate persona path
-        const personaPath = await this.#getPersonaPath();
+        // Get the appropriate agent path
+        const agentPath = await this.#getAgentPath();
         const perm = {
             enabled: true,
             toolPerms: {},
-            __configPath__: personaPath,
+            __configPath__: agentPath,
         };
         // Set flag to ignore file changes during permission update
         this.#isProgrammaticChange = true;
@@ -705,10 +710,7 @@ class McpEventHandler {
         catch (error) {
             this.#features.logging.error(`Failed to enable MCP server: ${error}`);
         }
-        finally {
-            // Reset flag after operations
-            this.#isProgrammaticChange = false;
-        }
+        this.#isProgrammaticChange = false;
         return { id: params.id };
     }
     /**
@@ -719,12 +721,12 @@ class McpEventHandler {
         if (!serverName) {
             return { id: params.id };
         }
-        // Get the appropriate persona path
-        const personaPath = await this.#getPersonaPath();
+        // Get the appropriate agent path
+        const agentPath = await this.#getAgentPath();
         const perm = {
             enabled: false,
             toolPerms: {},
-            __configPath__: personaPath,
+            __configPath__: agentPath,
         };
         // Set flag to ignore file changes during permission update
         this.#isProgrammaticChange = true;
@@ -735,10 +737,7 @@ class McpEventHandler {
         catch (error) {
             this.#features.logging.error(`Failed to disable MCP server: ${error}`);
         }
-        finally {
-            // Reset flag after operations
-            this.#isProgrammaticChange = false;
-        }
+        this.#isProgrammaticChange = false;
         return { id: params.id };
     }
     /**
@@ -753,23 +752,24 @@ class McpEventHandler {
         this.#isProgrammaticChange = true;
         try {
             await mcpManager_1.McpManager.instance.removeServer(serverName);
+            return { id: params.id };
         }
         catch (error) {
             this.#features.logging.error(`Failed to delete MCP server: ${error}`);
-        }
-        finally {
-            // Reset flag after operations
             this.#isProgrammaticChange = false;
+            return { id: params.id };
         }
-        return { id: params.id };
     }
     /**
      * Handles edit MCP configuration
      */
     async #handleEditMcpServer(params, error) {
+        // Set programmatic change flag to true to prevent file watcher triggers
+        this.#isProgrammaticChange = true;
         await this.#handleSavePermissionChange({ id: 'save-mcp-permission' });
         const serverName = params.title;
         if (!serverName) {
+            this.#isProgrammaticChange = false;
             return { id: params.id };
         }
         this.#currentEditingServerName = serverName;
@@ -822,16 +822,21 @@ class McpEventHandler {
         // Add tool select options
         toolsWithPermissions.forEach(item => {
             const toolName = item.tool.toolName;
-            const currentPermission = this.#getCurrentPermission(item.permission);
             // For Built-in server, use a special function that doesn't include the 'Deny' option
-            const permissionOptions = this.#buildPermissionOptions(item.permission);
+            let permissionOptions = this.#buildPermissionOptions(item.permission);
+            if (serverName === 'Built-in') {
+                permissionOptions = this.#buildBuiltInPermissionOptions(item.permission);
+            }
             filterOptions.push({
                 type: 'select',
                 id: `${toolName}`,
                 title: toolName,
                 description: item.tool.description,
-                placeholder: currentPermission,
                 options: permissionOptions,
+                ...(toolName === 'fsWrite'
+                    ? { disabled: true, selectTooltip: 'Permission for this tool is not configurable yet' }
+                    : {}),
+                ...{ value: item.permission, boldTitle: true, mandatory: true, hideMandatoryIcon: true },
             });
         });
         return filterOptions;
@@ -855,41 +860,65 @@ class McpEventHandler {
      */
     #buildPermissionOptions(currentPermission) {
         const permissionOptions = [];
-        if (currentPermission !== mcpTypes_1.McpPermissionType.alwaysAllow) {
-            permissionOptions.push({ label: 'Always allow', value: mcpTypes_1.McpPermissionType.alwaysAllow });
-        }
-        if (currentPermission !== mcpTypes_1.McpPermissionType.ask) {
-            permissionOptions.push({ label: 'Ask', value: mcpTypes_1.McpPermissionType.ask });
-        }
-        if (currentPermission !== mcpTypes_1.McpPermissionType.deny) {
-            permissionOptions.push({ label: 'Deny', value: mcpTypes_1.McpPermissionType.deny });
-        }
+        permissionOptions.push({
+            label: 'Ask',
+            value: mcpTypes_1.McpPermissionType.ask,
+            description: 'Ask for your approval each time this tool is run',
+        });
+        permissionOptions.push({
+            label: 'Always allow',
+            value: mcpTypes_1.McpPermissionType.alwaysAllow,
+            description: 'Always allow this tool to run without asking for approval',
+        });
+        permissionOptions.push({ label: 'Deny', value: mcpTypes_1.McpPermissionType.deny, description: 'Never run this tool' });
         return permissionOptions;
     }
     /**
      * Builds permission options for Built-in tools (no 'Disable' option)
      */
-    // #buildBuiltInPermissionOptions(currentPermission: string) {
-    //     const permissionOptions: PermissionOption[] = []
-    //     if (currentPermission !== 'alwaysAllow') {
-    //         permissionOptions.push({
-    //             label: 'Always run',
-    //             value: 'alwaysAllow',
-    //         })
-    //     }
-    //     if (currentPermission !== 'ask') {
-    //         permissionOptions.push({
-    //             label: 'Ask to run',
-    //             value: 'ask',
-    //         })
-    //     }
-    //     return permissionOptions
-    // }
+    #buildBuiltInPermissionOptions(currentPermission) {
+        const permissionOptions = [];
+        permissionOptions.push({
+            label: 'Ask',
+            value: 'ask',
+            description: 'Ask for your approval each time this tool is run',
+        });
+        permissionOptions.push({
+            label: 'Always Allow',
+            value: 'alwaysAllow',
+            description: 'Always allow this tool to run without asking for approval',
+        });
+        return permissionOptions;
+    }
+    #getBuiltInToolDescription(toolName) {
+        switch (toolName) {
+            case 'fsRead':
+                return 'Read the content of files.';
+            case 'listDirectory':
+                return 'List the structure of a directory and its subdirectories.';
+            case 'fileSearch':
+                return 'Search for files and directories using fuzzy name matching.';
+            case 'executeBash':
+                return 'Run shell or powershell commands.\n\nNote: read-only commands are auto-run';
+            case 'fsWrite':
+            case 'fsReplace':
+                return 'Create or edit files.';
+            case 'qCodeReview':
+                return 'Review tool analyzes code for security vulnerabilities, quality issues, and best practices across multiple programming languages.';
+            default:
+                return '';
+        }
+    }
     /**
      * Handles MCP permission change events to update the pending permission config without applying changes
      */
     async #handleMcpPermissionChange(params) {
         const serverName = params.title;
+        // combine fsWrite and fsReplace into fsWrite
+        if (serverName === 'Built-in' && params.optionsValues?.fsWrite) {
+            // add fsReplace along
+            params.optionsValues.fsReplace = params.optionsValues.fsWrite;
+        }
         const updatedPermissionConfig = params.optionsValues;
         if (!serverName || !updatedPermissionConfig) {
             return { id: params.id };
@@ -941,8 +970,8 @@ class McpEventHandler {
                     command: serverConfig.command,
                     enabled: true,
                     numTools: mcpManager_1.McpManager.instance.getAllToolsWithPermissions(serverName).length,
-                    scope: serverConfig?.__configPath__ ===
-                        (0, mcpUtils_1.getGlobalMcpConfigPath)(this.#features.workspace.fs.getUserHomeDir())
+                    scope: serverConfig.__configPath__ ===
+                        (0, mcpUtils_1.getGlobalAgentConfigPath)(this.#features.workspace.fs.getUserHomeDir())
                         ? 'global'
                         : 'workspace',
                     transportType: 'stdio',
@@ -952,24 +981,24 @@ class McpEventHandler {
             // Clear the pending permission config after applying
             this.#pendingPermissionConfig = undefined;
             this.#features.logging.info(`Applied permission changes for server: ${serverName}`);
+            this.#isProgrammaticChange = false;
             return { id: params.id };
         }
         catch (error) {
             this.#features.logging.error(`Failed to save MCP permissions: ${error}`);
-            return { id: params.id };
-        }
-        finally {
-            // Reset flag after operations
             this.#isProgrammaticChange = false;
+            return { id: params.id };
         }
     }
     #emitMCPConfigEvent() {
         // Emit MCP config event after reinitialization
         const mcpManager = mcpManager_1.McpManager.instance;
         const serverConfigs = mcpManager.getAllServerConfigs();
-        const activeServers = Array.from(serverConfigs.entries()).filter(([name, _]) => !mcpManager.isServerDisabled(name));
+        const activeServers = Array.from(serverConfigs.entries());
+        // Get the global agent path
+        const globalAgentPath = (0, mcpUtils_1.getGlobalAgentConfigPath)(this.#features.workspace.fs.getUserHomeDir());
         // Count global vs project servers
-        const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalMcpConfigPath)(this.#features.workspace.fs.getUserHomeDir())).length;
+        const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config.__configPath__ === globalAgentPath).length;
         const projectServers = serverConfigs.size - globalServers;
         // Count tools by permission
         let toolsAlwaysAllowed = 0;
@@ -995,20 +1024,16 @@ class McpEventHandler {
         });
         // Emit server initialize events for all active servers
         for (const [serverName, config] of serverConfigs.entries()) {
-            const enabled = !mcpManager.isServerDisabled(serverName);
-            if (enabled) {
-                this.#telemetryController?.emitMCPServerInitializeEvent({
-                    source: 'reload',
-                    command: config.command,
-                    enabled,
-                    numTools: mcpManager.getAllToolsWithPermissions(serverName).length,
-                    scope: config?.__configPath__ === (0, mcpUtils_1.getGlobalMcpConfigPath)(this.#features.workspace.fs.getUserHomeDir())
-                        ? 'global'
-                        : 'workspace',
-                    transportType: 'stdio',
-                    languageServerVersion: this.#features.runtime.serverInfo.version,
-                });
-            }
+            // const enabled = !mcpManager.isServerDisabled(serverName)
+            this.#telemetryController?.emitMCPServerInitializeEvent({
+                source: 'reload',
+                command: config.command,
+                enabled: true,
+                numTools: mcpManager.getAllToolsWithPermissions(serverName).length,
+                scope: config.__configPath__ === globalAgentPath ? 'global' : 'workspace',
+                transportType: 'stdio',
+                languageServerVersion: this.#features.runtime.serverInfo.version,
+            });
         }
     }
     /**
@@ -1039,50 +1064,43 @@ class McpEventHandler {
         }
     }
     /**
-     * Gets the appropriate persona path, checking workspace path first if it exists
-     * @returns The persona path to use (workspace if exists, otherwise global)
+     * Gets the appropriate agent path, checking workspace path first if it exists
+     * @returns The agent path to use (workspace if exists, otherwise global)
      */
-    async #getPersonaPath() {
-        const allPermissions = mcpManager_1.McpManager.instance.getAllPermissions();
-        for (const [, permission] of allPermissions) {
-            if (permission.__configPath__) {
-                return permission.__configPath__;
-            }
+    async #getAgentPath(isGlobal = true) {
+        if (isGlobal) {
+            return (0, mcpUtils_1.getGlobalAgentConfigPath)(this.#features.workspace.fs.getUserHomeDir());
         }
-        const globalPersonaPath = (0, mcpUtils_1.getGlobalPersonaConfigPath)(this.#features.workspace.fs.getUserHomeDir());
-        // Get workspace folders and check for workspace persona path
+        const globalAgentPath = (0, mcpUtils_1.getGlobalAgentConfigPath)(this.#features.workspace.fs.getUserHomeDir());
+        // Get workspace folders and check for workspace agent path
         const workspaceFolders = this.#features.workspace.getAllWorkspaceFolders();
         if (workspaceFolders && workspaceFolders.length > 0) {
             const workspacePaths = workspaceFolders.map(folder => folder.uri);
-            const workspacePersonaPaths = (0, mcpUtils_1.getWorkspacePersonaConfigPaths)(workspacePaths);
-            if (Array.isArray(workspacePersonaPaths) && workspacePersonaPaths.length > 0) {
+            const workspaceAgentPaths = (0, mcpUtils_1.getWorkspaceAgentConfigPaths)(workspacePaths);
+            if (Array.isArray(workspaceAgentPaths) && workspaceAgentPaths.length > 0) {
                 try {
                     // Convert URI format to filesystem path if needed using the utility function
-                    const personaPath = (0, mcpUtils_1.normalizePathFromUri)(workspacePersonaPaths[0], this.#features.logging);
-                    // Check if the workspace persona path exists
-                    const fileExists = await this.#features.workspace.fs.exists(personaPath);
-                    if (fileExists) {
-                        return personaPath;
-                    }
+                    const agentPath = (0, mcpUtils_1.normalizePathFromUri)(workspaceAgentPaths[0], this.#features.logging);
+                    return agentPath;
                 }
                 catch (e) {
-                    this.#features.logging.warn(`Failed to check if workspace persona path exists: ${e}`);
+                    this.#features.logging.warn(`Failed to check if workspace agent path exists: ${e}`);
                 }
             }
         }
         // Return global path if workspace path doesn't exist or there was an error
-        return globalPersonaPath;
+        return globalAgentPath;
     }
     /**
      * Processes permission updates from the UI
      */
     async #processPermissionUpdates(updatedPermissionConfig) {
-        // Get the appropriate persona path
-        const personaPath = await this.#getPersonaPath();
+        // Get the appropriate agent path
+        const agentPath = await this.#getAgentPath();
         const perm = {
             enabled: true,
             toolPerms: {},
-            __configPath__: personaPath,
+            __configPath__: agentPath,
         };
         // Process each tool permission setting
         for (const [key, val] of Object.entries(updatedPermissionConfig)) {
@@ -1142,26 +1160,46 @@ class McpEventHandler {
         catch (e) {
             this.#features.logging.warn(`Failed to get user home directory: ${e}`);
         }
-        const configPaths = [
-            ...(0, mcpUtils_1.getWorkspaceMcpConfigPaths)(wsUris),
-            ...(homeDir ? [(0, mcpUtils_1.getGlobalMcpConfigPath)(homeDir)] : []),
+        // Only watch agent config files
+        const agentPaths = [
+            ...(0, mcpUtils_1.getWorkspaceAgentConfigPaths)(wsUris),
+            ...(homeDir ? [(0, mcpUtils_1.getGlobalAgentConfigPath)(homeDir)] : []),
         ];
-        const personaPaths = [
-            ...(0, mcpUtils_1.getWorkspacePersonaConfigPaths)(wsUris),
-            ...(homeDir ? [(0, mcpUtils_1.getGlobalPersonaConfigPath)(homeDir)] : []),
-        ];
-        const allPaths = [...configPaths, ...personaPaths];
-        this.#fileWatcher.watchPaths(allPaths, async () => {
-            if (this.#isProgrammaticChange) {
-                return;
+        const allPaths = [...agentPaths];
+        this.#fileWatcher.watchPaths(allPaths, () => {
+            // Store the current programmatic state when the event is triggered
+            this.#lastProgrammaticState = this.#isProgrammaticChange;
+            // Log the values for debugging
+            this.#features.logging.info(`File watcher triggered - isProgrammaticChange: ${this.#isProgrammaticChange}, ` +
+                `lastProgrammaticState: ${this.#lastProgrammaticState}`);
+            // Clear any existing timer
+            if (this.#debounceTimer) {
+                clearTimeout(this.#debounceTimer);
             }
-            await this.#handleRefreshMCPList({ id: 'refresh-mcp-list' });
+            // Set a new timer with 2 second debounce
+            this.#debounceTimer = setTimeout(async () => {
+                // Log the values again when the timer fires
+                this.#features.logging.debug(`Debounce timer fired - lastProgrammaticState: ${this.#lastProgrammaticState}`);
+                // Only proceed if the stored state allows it
+                if (!this.#lastProgrammaticState) {
+                    await this.#handleRefreshMCPList({ id: 'refresh-mcp-list' });
+                }
+                else {
+                    this.#isProgrammaticChange = false;
+                    this.#features.logging.debug('Skipping refresh due to programmatic change');
+                }
+                this.#debounceTimer = null;
+            }, 2000);
         });
     }
     /**
      * Cleanup file watchers
      */
     dispose() {
+        if (this.#debounceTimer) {
+            clearTimeout(this.#debounceTimer);
+            this.#debounceTimer = null;
+        }
         this.#fileWatcher.close();
     }
 }