@aws/lsp-codewhisperer 0.0.69 → 0.0.71

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

@@ -18,6 +18,7 @@ class McpEventHandler {
     #isProgrammaticChange = false;
     #debounceTimer = null;
     #lastProgrammaticState = false;
+    #serverNameBeforeUpdate;
     constructor(features, telemetryService) {
         this.#features = features;
         this.#eventListenerRegistered = false;
@@ -186,11 +187,15 @@ class McpEventHandler {
      * Handles MCP server click events
      */
     async onMcpServerClick(params) {
-        this.#features.logging.log(`[VSCode Server] onMcpServerClick event with params: ${JSON.stringify(params)}`);
+        this.#features.logging.log(`onMcpServerClick event with params: ${JSON.stringify(params)}`);
         // Use a map of handlers for different action types
         const handlers = {
-            'add-new-mcp': () => this.#handleAddNewMcp(params),
+            'add-new-mcp': () => {
+                this.#currentEditingServerName = undefined;
+                return this.#handleAddNewMcp(params);
+            },
             'save-mcp': () => this.#handleSaveMcp(params),
+            'change-transport': () => this.#handleChangeTransport(params),
             'open-mcp-server': () => this.#handleOpenMcpServer(params),
             'edit-mcp': () => this.#handleEditMcpServer(params),
             'mcp-permission-change': () => this.#handleMcpPermissionChange(params),
@@ -225,27 +230,19 @@ class McpEventHandler {
     }
     async #handleAddNewMcp(params, error) {
         const existingValues = params.optionsValues || {};
-        let argsValue = [
-            {
-                persistent: true,
-                value: { arg_key: '' },
-            },
-        ];
+        // Arguments (stdio)
+        let argsValue = [{ persistent: true, value: { arg_key: '' } }];
         if (existingValues.args && Array.isArray(existingValues.args)) {
             argsValue = existingValues.args.map((arg, index) => ({
                 persistent: index === 0,
-                value: {
-                    arg_key: arg.arg_key || '',
-                },
+                value: { arg_key: arg.arg_key || '' },
             }));
         }
+        // Environment variables (stdio)
         let envVarsValue = [
             {
                 persistent: true,
-                value: {
-                    env_var_name: '',
-                    env_var_value: '',
-                },
+                value: { env_var_name: '', env_var_value: '' },
             },
         ];
         if (existingValues.env_variables && Array.isArray(existingValues.env_variables)) {
@@ -257,6 +254,17 @@ class McpEventHandler {
                 },
             }));
         }
+        // Headers (http)
+        let headersValue = [];
+        if (existingValues.headers && Array.isArray(existingValues.headers)) {
+            headersValue = existingValues.headers.map(hdr => ({
+                persistent: false, // allow every row to be deleted
+                value: {
+                    key: hdr.key || '',
+                    value: hdr.value || '',
+                },
+            }));
+        }
         if (existingValues.name) {
             const serverName = existingValues.name;
             const sanitizedServerName = (0, mcpUtils_1.sanitizeName)(serverName);
@@ -274,114 +282,116 @@ class McpEventHandler {
             }
         }
         const serverStatusError = this.#getServerStatusError(existingValues.name) || {};
+        // Determine which transport is selected (default to stdio)
+        const selectedTransport = existingValues.transport || 'stdio';
         return {
             id: params.id,
             header: {
                 title: 'Add MCP Server',
-                status: error
-                    ? {
-                        title: error,
-                        icon: 'cancel-circle',
-                        status: 'error',
-                    }
-                    : serverStatusError,
+                status: error ? { title: error, icon: 'cancel-circle', status: 'error' } : serverStatusError,
                 actions: [],
             },
             list: [],
             filterActions: [
-                {
-                    id: 'cancel-mcp',
-                    text: 'Cancel',
-                },
-                {
-                    id: 'save-mcp',
-                    text: 'Save',
-                    status: error ? 'error' : 'primary',
-                },
+                { id: 'cancel-mcp', text: 'Cancel' },
+                { id: 'save-mcp', text: 'Save', status: error ? 'error' : 'primary' },
             ],
-            filterOptions: [
-                {
-                    type: 'radiogroup',
-                    id: 'scope',
-                    title: 'Scope',
-                    options: [
+            filterOptions: (() => {
+                const common = [
+                    {
+                        type: 'radiogroup',
+                        id: 'scope',
+                        title: 'Scope',
+                        options: [
+                            { label: 'Global - Used globally.', value: 'global' },
+                            { label: 'This workspace - Only used in this workspace.', value: 'workspace' },
+                        ],
+                        value: existingValues.scope || 'global',
+                    },
+                    {
+                        type: 'textinput',
+                        id: 'name',
+                        title: 'Name',
+                        value: existingValues.name || '',
+                        mandatory: true,
+                    },
+                    {
+                        type: 'select',
+                        id: 'transport',
+                        title: 'Transport',
+                        mandatory: true,
+                        options: [
+                            { label: 'stdio', value: 'stdio' },
+                            { label: 'http', value: 'http' },
+                        ],
+                        value: selectedTransport,
+                    },
+                ];
+                if (selectedTransport === 'http') {
+                    return [
+                        ...common,
                         {
-                            label: `Global - Used globally.`,
-                            value: 'global',
+                            type: 'textinput',
+                            id: 'url',
+                            title: 'URL',
+                            value: existingValues.url || '',
+                            mandatory: true,
                         },
                         {
-                            label: `This workspace - Only used in this workspace.`,
-                            value: 'workspace',
+                            type: 'list',
+                            id: 'headers',
+                            title: 'Headers - optional',
+                            items: [
+                                { id: 'key', title: 'Key', type: 'textinput' },
+                                { id: 'value', title: 'Value', type: 'textinput' },
+                            ],
+                            ...(headersValue.length > 0 ? { value: headersValue } : {}),
                         },
-                    ],
-                    value: existingValues.scope || 'global',
-                },
-                {
-                    type: 'textinput',
-                    id: 'name',
-                    title: 'Name',
-                    value: existingValues.name || '',
-                    mandatory: true,
-                },
-                {
-                    type: 'select',
-                    id: 'transport',
-                    title: 'Transport',
-                    mandatory: true,
-                    options: [
                         {
-                            label: 'stdio',
-                            value: 'yes',
+                            type: 'numericinput',
+                            id: 'timeout',
+                            title: 'Timeout - use 0 to disable',
+                            value: existingValues.timeout || 60,
                         },
-                    ],
-                },
-                {
-                    type: 'textinput',
-                    id: 'command',
-                    title: 'Command',
-                    value: existingValues.command || '',
-                    mandatory: true,
-                },
-                {
-                    type: 'list',
-                    id: 'args',
-                    title: 'Arguments - optional',
-                    mandatory: false,
-                    items: [
+                    ];
+                }
+                else {
+                    // stdio transport
+                    return [
+                        ...common,
                         {
-                            id: 'arg_key',
                             type: 'textinput',
+                            id: 'command',
+                            title: 'Command',
+                            value: existingValues.command || '',
+                            mandatory: true,
                         },
-                    ],
-                    value: argsValue,
-                },
-                {
-                    type: 'list',
-                    id: 'env_variables',
-                    title: 'Environment variables - optional',
-                    mandatory: false,
-                    items: [
                         {
-                            id: 'env_var_name',
-                            title: 'Name',
-                            type: 'textinput',
+                            type: 'list',
+                            id: 'args',
+                            title: 'Arguments - optional',
+                            items: [{ id: 'arg_key', type: 'textinput' }],
+                            value: argsValue,
                         },
                         {
-                            id: 'env_var_value',
-                            title: 'Value',
-                            type: 'textinput',
+                            type: 'list',
+                            id: 'env_variables',
+                            title: 'Environment variables - optional',
+                            items: [
+                                { id: 'env_var_name', title: 'Name', type: 'textinput' },
+                                { id: 'env_var_value', title: 'Value', type: 'textinput' },
+                            ],
+                            value: envVarsValue,
                         },
-                    ],
-                    value: envVarsValue,
-                },
-                {
-                    type: 'numericinput',
-                    id: 'timeout',
-                    title: 'Timeout - use 0 to disable',
-                    value: existingValues.timeout || 60, // Default to 60 seconds in UI
-                    mandatory: false,
-                },
-            ],
+                        {
+                            type: 'numericinput',
+                            id: 'timeout',
+                            title: 'Timeout - use 0 to disable',
+                            value: existingValues.timeout || 60,
+                        },
+                    ];
+                }
+            })(),
         };
     }
     /**
@@ -404,6 +414,8 @@ class McpEventHandler {
                 timeout: config.timeout?.toString() || '',
                 env: config.env,
                 args: config.args,
+                url: config.url,
+                headers: config.headers,
             };
             const validation = this.#validateMcpServerForm(values, false);
             if (!validation.isValid) {
@@ -453,8 +465,18 @@ class McpEventHandler {
                 }
             }
         }
-        if (!values.command || values.command.trim() === '') {
-            errors.push('Command is required for stdio transport');
+        const transport = values.transport;
+        const command = values.command?.trim() || '';
+        const url = values.url?.trim() || '';
+        // Basic validation for command/url presence and exclusivity
+        if (!command && !url) {
+            errors.push('Either command or url is required');
+        }
+        else if (command && url) {
+            errors.push('Provide either command OR url, not both');
+        }
+        else if (transport && ((transport === 'stdio' && !command) || (transport !== 'stdio' && !url))) {
+            errors.push(`${transport === 'stdio' ? 'Command' : 'URL'} is required for ${transport} transport`);
         }
         if (values.timeout && values.timeout.trim() !== '') {
             const timeoutNum = Number(values.timeout.trim());
@@ -478,6 +500,20 @@ class McpEventHandler {
                 errors.push('Environment variable value cannot be empty when name is provided');
             }
         }
+        if (Array.isArray(values.headers)) {
+            const hdrs = values.headers;
+            const invalidHeaders = hdrs.find(h => {
+                const key = h.key?.trim() || '';
+                const value = h.value?.trim() || '';
+                return (key === '' && value !== '') || (key !== '' && value === '');
+            });
+            if (invalidHeaders) {
+                const hasKey = invalidHeaders.key?.trim();
+                errors.push(hasKey
+                    ? 'Header value cannot be empty when key is provided'
+                    : 'Header key cannot be empty when value is provided');
+            }
+        }
         return {
             isValid: errors.length === 0,
             errors,
@@ -490,6 +526,7 @@ class McpEventHandler {
         if (!params.optionsValues) {
             return this.#getDefaultMcpResponse(params.id);
         }
+        const selectedTransport = params.optionsValues.transport;
         const serverName = params.optionsValues.name;
         const sanitizedServerName = (0, mcpUtils_1.sanitizeName)(serverName);
         const originalServerName = this.#currentEditingServerName;
@@ -498,55 +535,75 @@ class McpEventHandler {
         const validation = this.#validateMcpServerForm(params.optionsValues, true, isEditMode ? originalServerName : undefined);
         if (!validation.isValid) {
             const error = validation.errors[0];
-            if (isEditMode) {
-                params.id = 'edit-mcp';
-                params.title = originalServerName;
-                return this.#handleEditMcpServer(params, error);
-            }
-            else {
-                params.id = 'add-new-mcp';
-                return this.#handleAddNewMcp(params, error);
-            }
+            params.id = isEditMode ? 'edit-mcp' : 'add-new-mcp';
+            return isEditMode
+                ? this.#handleEditMcpServer({ ...params, title: originalServerName }, error)
+                : this.#handleAddNewMcp(params, error);
         }
-        // Process args to string[]
+        // stdio‑specific parsing
         let args = [];
-        const argsValue = params.optionsValues.args;
-        // Handle the case where argsValue might be a direct array or another type
-        try {
-            // Try to safely access and process the value
-            const argsArray = Array.isArray(argsValue) ? argsValue : [];
-            args = argsArray
-                .map((item) => {
-                return typeof item === 'object' && item !== null && 'arg_key' in item ? String(item.arg_key) : '';
-            })
-                .filter(Boolean);
-        }
-        catch (e) {
-            this.#features.logging.warn(`Failed to process args: ${e}`);
-        }
-        // Process env_variables to Record<string, string>
         let env = {};
-        const envValue = params.optionsValues.env_variables;
-        try {
-            const envArray = Array.isArray(envValue) ? envValue : [];
-            env = envArray.reduce((acc, item) => {
-                if (item && typeof item === 'object' && 'env_var_name' in item && 'env_var_value' in item) {
-                    acc[String(item.env_var_name)] = String(item.env_var_value);
-                }
-                return acc;
-            }, {});
+        if (selectedTransport === 'stdio') {
+            try {
+                args = (Array.isArray(params.optionsValues.args) ? params.optionsValues.args : [])
+                    .map((item) => item && typeof item === 'object' && 'arg_key' in item ? String(item.arg_key) : '')
+                    .filter(Boolean);
+            }
+            catch (e) {
+                this.#features.logging.warn(`MCP: Failed to process args: ${e}`);
+            }
+            try {
+                env = (Array.isArray(params.optionsValues.env_variables) ? params.optionsValues.env_variables : []).reduce((acc, item) => {
+                    if (item && 'env_var_name' in item && 'env_var_value' in item) {
+                        acc[String(item.env_var_name)] = String(item.env_var_value);
+                    }
+                    return acc;
+                }, {});
+            }
+            catch (e) {
+                this.#features.logging.warn(`MCP: Failed to process env variables: ${e}`);
+            }
         }
-        catch (e) {
-            this.#features.logging.warn(`Failed to process env variables: ${e}`);
+        // http‑specific parsing
+        let headers = {};
+        if (selectedTransport === 'http') {
+            try {
+                const raw = Array.isArray(params.optionsValues.headers) ? params.optionsValues.headers : [];
+                headers = raw.reduce((acc, item) => {
+                    const k = item.key?.toString().trim() ?? '';
+                    const v = item.value?.toString().trim() ?? '';
+                    // both empty → skip
+                    if (k === '' && v === '') {
+                        return acc;
+                    }
+                    // otherwise keep (validation layer handles partial-empty cases)
+                    acc[k] = item.value ?? '';
+                    return acc;
+                }, {});
+            }
+            catch (e) {
+                this.#features.logging.warn(`MCP: Failed to process headers: ${e}`);
+            }
         }
         // Config file requires timeout in milliseconds
         const timeoutInMs = (parseInt(params.optionsValues.timeout) ?? 60) * 1000;
-        const config = {
-            command: params.optionsValues.command,
-            args,
-            env,
-            timeout: timeoutInMs,
-        };
+        // build final config (no transport field persisted)
+        let config;
+        if (selectedTransport === 'http') {
+            config = {
+                url: params.optionsValues.url,
+                headers,
+                timeout: timeoutInMs,
+            };
+        }
+        else {
+            config = {
+                command: params.optionsValues.command,
+                args,
+                env,
+                timeout: timeoutInMs,
+            };
+        }
         // Get agent path based on scope
         const isGlobal = params.optionsValues['scope'] === 'global';
         const agentPath = await this.#getAgentPath(isGlobal);
@@ -558,7 +615,8 @@ class McpEventHandler {
         this.#isProgrammaticChange = true;
         try {
             if (isEditMode && originalServerName) {
-                await mcpManager_1.McpManager.instance.removeServer(originalServerName);
+                const serverToRemove = this.#serverNameBeforeUpdate || originalServerName;
+                await mcpManager_1.McpManager.instance.removeServer(serverToRemove);
                 await mcpManager_1.McpManager.instance.addServer(serverName, config, agentPath);
             }
             else {
@@ -573,14 +631,14 @@ class McpEventHandler {
         this.#currentEditingServerName = undefined;
         // need to check server state now, as there is possibility of error during server initialization
         const serverStatusError = this.#getServerStatusError(serverName);
-        // Emit telemetry event regardless of success/failure
         this.#telemetryController?.emitMCPServerInitializeEvent({
             source: isEditMode ? 'updateServer' : 'addServer',
-            command: config.command,
+            command: selectedTransport === 'stdio' ? params.optionsValues.command : undefined,
+            url: selectedTransport === 'http' ? params.optionsValues.url : undefined,
             enabled: true,
             numTools: mcpManager_1.McpManager.instance.getAllToolsWithPermissions(serverName).length,
             scope: params.optionsValues['scope'] === 'global' ? 'global' : 'workspace',
-            transportType: 'stdio',
+            transportType: selectedTransport,
             languageServerVersion: this.#features.runtime.serverInfo.version,
         });
         if (serverStatusError) {
@@ -780,18 +838,28 @@ class McpEventHandler {
                 list: [],
             };
         }
+        // Respect a user flip first; otherwise fall back to what the stored configuration implies.
+        const transport = params.optionsValues?.transport ?? (config.url ? 'http' : 'stdio');
+        // Convert stored structures to UI‑friendly lists
+        const argsList = (config.args ?? []).map(a => ({ arg_key: a })); // for stdio
+        const envList = Object.entries(config.env ?? {}).map(([k, v]) => ({
+            env_var_name: k,
+            env_var_value: v,
+        })); // for stdio
+        const headersList = Object.entries(config.headers ?? {}).map(([k, v]) => ({
+            key: k,
+            value: v,
+        })); // for http
         // UI must display timeout to user in seconds
         const timeoutInSeconds = params.optionsValues?.timeout || Math.floor((config.timeout ?? 60000) / 1000).toString();
         const existingValues = {
             name: params.optionsValues?.name || serverName,
-            transport: 'stdio',
+            transport,
             command: params.optionsValues?.command || config.command,
-            args: params.optionsValues?.args || (config.args ?? []).map(a => ({ arg_key: a })),
-            env_variables: params.optionsValues?.env_variables ||
-                Object.entries(config.env ?? {}).map(([k, v]) => ({
-                    env_var_name: k,
-                    env_var_value: v,
-                })),
+            args: params.optionsValues?.args || argsList,
+            env_variables: params.optionsValues?.env_variables || envList,
+            url: params.optionsValues?.url || config.url,
+            headers: params.optionsValues?.headers || headersList,
             timeout: timeoutInSeconds,
             scope: params.optionsValues?.scope,
         };
@@ -828,6 +896,30 @@ class McpEventHandler {
         });
         return filterOptions;
     }
+    async #handleChangeTransport(params) {
+        const { optionsValues, title } = params;
+        const editingServerName = this.#currentEditingServerName;
+        // Clean up transport-specific fields
+        if (optionsValues) {
+            const transport = optionsValues.transport ?? 'stdio'; // Maintain default to 'stdio'
+            const fieldsToDelete = transport === 'http' ? ['command', 'args', 'env_variables'] : ['url', 'headers'];
+            fieldsToDelete.forEach(field => delete optionsValues[field]);
+        }
+        // Handle server name change in edit mode
+        if (editingServerName && title && editingServerName !== title) {
+            const servers = mcpManager_1.McpManager.instance.getAllServerConfigs();
+            const existingConfig = servers.get(editingServerName);
+            if (existingConfig) {
+                const updatedServers = new Map(servers);
+                updatedServers.delete(editingServerName);
+                updatedServers.set(title, existingConfig);
+                await mcpManager_1.McpManager.instance.updateServerMap(updatedServers);
+            }
+            this.#serverNameBeforeUpdate = editingServerName;
+        }
+        params.id = editingServerName ? 'edit-mcp' : 'add-new-mcp';
+        return editingServerName ? this.#handleEditMcpServer(params) : this.#handleAddNewMcp(params);
+    }
     /**
      * Gets the current permission setting for a tool
      */
@@ -888,13 +980,13 @@ class McpEventHandler {
         }
         try {
             // Skip server config check for Built-in server
+            const serverConfig = mcpManager_1.McpManager.instance.getAllServerConfigs().get(serverName);
             if (serverName !== 'Built-in') {
-                const serverConfig = mcpManager_1.McpManager.instance.getAllServerConfigs().get(serverName);
                 if (!serverConfig) {
                     throw new Error(`Server '${serverName}' not found`);
                 }
             }
-            const mcpServerPermission = await this.#processPermissionUpdates(updatedPermissionConfig);
+            const mcpServerPermission = await this.#processPermissionUpdates(updatedPermissionConfig, serverConfig?.__configPath__);
             // Store the permission config instead of applying it immediately
             this.#pendingPermissionConfig = {
                 serverName,
@@ -928,23 +1020,24 @@ class McpEventHandler {
             const serverConfig = mcpManager_1.McpManager.instance.getAllServerConfigs().get(serverName);
             if (serverConfig) {
                 // Emit server initialize event after permission change
+                const transportType = serverConfig.command ? 'stdio' : 'http';
                 this.#telemetryController?.emitMCPServerInitializeEvent({
                     source: 'updatePermission',
-                    command: serverConfig.command,
+                    command: transportType === 'stdio' ? serverConfig.command : undefined,
+                    url: transportType === 'http' ? serverConfig.url : undefined,
                     enabled: true,
                     numTools: mcpManager_1.McpManager.instance.getAllToolsWithPermissions(serverName).length,
                     scope: serverConfig.__configPath__ ===
                         (0, mcpUtils_1.getGlobalAgentConfigPath)(this.#features.workspace.fs.getUserHomeDir())
                         ? 'global'
                         : 'workspace',
-                    transportType: 'stdio',
+                    transportType: transportType,
                     languageServerVersion: this.#features.runtime.serverInfo.version,
                 });
             }
             // 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) {
@@ -987,10 +1080,12 @@ class McpEventHandler {
         });
         // Emit server initialize events for all active servers
         for (const [serverName, config] of serverConfigs.entries()) {
+            const transportType = config.command ? 'stdio' : 'http';
             // const enabled = !mcpManager.isServerDisabled(serverName)
             this.#telemetryController?.emitMCPServerInitializeEvent({
                 source: 'reload',
-                command: config.command,
+                command: transportType === 'stdio' ? config.command : undefined,
+                url: transportType === 'http' ? config.url : undefined,
                 enabled: true,
                 numTools: mcpManager.getAllToolsWithPermissions(serverName).length,
                 scope: config.__configPath__ === globalAgentPath ? 'global' : 'workspace',
@@ -1057,9 +1152,7 @@ class McpEventHandler {
     /**
      * Processes permission updates from the UI
      */
-    async #processPermissionUpdates(updatedPermissionConfig) {
-        // Get the appropriate agent path
-        const agentPath = await this.#getAgentPath();
+    async #processPermissionUpdates(updatedPermissionConfig, agentPath) {
         const perm = {
             enabled: true,
             toolPerms: {},