imcp 0.0.11 → 0.0.12

package/src/cli/commands/uninstall.ts

@@ -6,19 +6,27 @@ export function createUninstallCommand(): Command {
     .description('Uninstall specific MCP servers')
     .requiredOption(
       '--category <category>',
+      'Server category'
+    )
+    .requiredOption(
       '--names <names>',
       'Server names (semicolon separated)'
     )
+    .requiredOption(
+      '--targets <targets>',
+      'Target clients to uninstall from (semicolon separated)'
+    )
     .option(
       '--remove-data',
       'Remove all associated data',
-      false
+      true  // Change default to true to ensure cleanup happens
     )
     .action(async (options) => {
       try {
         const serverNames = options.names.split(';').map((name: string) => name.trim());
 
-        if (!serverService.validateServerName(options.category, serverNames)) {
+        const validNames = await serverService.validateServerName(options.category, serverNames);
+        if (!validNames) {
           console.error('Invalid server names provided');
           process.exit(1);
         }
@@ -26,11 +34,13 @@ export function createUninstallCommand(): Command {
         console.log(`Uninstalling servers: ${serverNames.join(', ')}`);
 
         const results = await Promise.all(
-          serverNames.map((serverName: string) =>
-            serverService.uninstallMcpServer(options.category, serverName, {
+          serverNames.map((serverName: string) => {
+            const targets = options.targets ? options.targets.split(';').map((t: string) => t.trim()) : [];
+            return serverService.uninstallMcpServer(options.category, serverName, {
               removeData: options.removeData,
-            })
-          )
+              targets: targets
+            });
+          })
         );
 
         const { success, messages } = serverService.formatOperationResults(results);

package/src/core/ConfigurationProvider.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
-import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR } from './constants.js';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from './constants.js';
 import { Logger } from '../utils/logger.js';
 import { checkGithubAuth } from '../utils/githubAuth.js';
 import {
@@ -13,7 +13,8 @@ import {
     InstallationStatus,
     RequirementStatus,
     MCPServerStatus,
-    OperationStatus
+    OperationStatus,
+    ClientSettings
 } from './types.js';
 import { ConfigurationLoader } from './ConfigurationLoader.js';
 
@@ -356,6 +357,74 @@ export class ConfigurationProvider {
             await this.loadClientMCPSettings();
         });
     }
+
+    async removeServerFromClientMCPSettings(serverName: string, target?: string): Promise<void> {
+        return await this.withLock(async () => {
+            // Load utils in async context to avoid circular dependencies
+            const { readJsonFile, writeJsonFile } = await import('../utils/clientUtils.js');
+            
+            // Filter clients if target is specified
+            const clientEntries = Object.entries(SUPPORTED_CLIENTS as Record<string, ClientSettings>);
+            const targetClients = target
+                ? clientEntries.filter(([clientName]) => clientName === target)
+                : clientEntries;
+
+            for (const [clientName, clientSettings] of targetClients) {
+                const settingPath = process.env.CODE_INSIDERS
+                    ? clientSettings.codeInsiderSettingPath
+                    : clientSettings.codeSettingPath;
+                
+                try {
+                    const content = await readJsonFile(settingPath, true);
+                    let modified = false;
+                    
+                    // Handle GitHub Copilot's different structure
+                    if (clientName === 'GithubCopilot' && content.mcp?.servers?.[serverName]) {
+                        delete content.mcp.servers[serverName];
+                        modified = true;
+                    } else if (content.mcpServers?.[serverName]) {
+                        delete content.mcpServers[serverName];
+                        modified = true;
+                    }
+                    
+                    // Only write if we actually modified the content
+                    if (modified) {
+                        await writeJsonFile(settingPath, content);
+                        Logger.debug(`Removed server ${serverName} from client ${clientName} settings`);
+                    }
+                } catch (error) {
+                    Logger.error(`Failed to remove server ${serverName} from client ${clientName} settings:`, error);
+                }
+            }
+            
+            // Also update our in-memory configuration
+            if (this.configuration.clientMCPSettings) {
+                if (target) {
+                    // Only update settings for the target client
+                    const clientSettings = this.configuration.clientMCPSettings[target];
+                    if (clientSettings) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) {  // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                } else {
+                    // Update all clients if no target specified
+                    for (const clientSettings of Object.values(this.configuration.clientMCPSettings)) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) {  // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                }
+                await this.saveConfiguration();
+            }
+        });
+    }
 }
 
 // Export a singleton instance

package/src/core/MCPManager.ts

@@ -9,6 +9,7 @@ import {
   ServerCategoryListOptions,
   ServerOperationResult,
   ServerUninstallOptions,
+  InstallationStatus
 } from './types.js';
 import path from 'path';
 
@@ -93,18 +94,44 @@ export class MCPManager extends EventEmitter {
         };
       }
 
-      // Clear installation status
+      const { targets = [], removeData = false } = options;
+
+      // Clear installation status for specified targets
+      const currentStatus: InstallationStatus = serverCategory.installationStatus || {
+        requirementsStatus: {},
+        serversStatus: {},
+        lastUpdated: new Date().toISOString()
+      };
+      const serversStatus = currentStatus.serversStatus || {};
+      const serverStatus = serversStatus[serverName] || { installedStatus: {}, name: serverName };
+
+      // Only reset installedStatus for specified targets
+      for (const target of targets) {
+        if (serverStatus.installedStatus) {
+          delete serverStatus.installedStatus[target];
+        }
+      }
+      if (removeData) {
+        for (const target of targets) {
+          await this.configProvider.removeServerFromClientMCPSettings(serverName, target);
+        }
+      }
+
+      // Update server status
+      serversStatus[serverName] = serverStatus;
+
+      // Update status keeping requirements
       await this.configProvider.updateInstallationStatus(
         categoryName,
-        {},
-        {}
+        currentStatus.requirementsStatus || {},
+        serversStatus
       );
 
-      this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName });
+      this.emit(MCPEvent.SERVER_UNINSTALLED, { serverName, targets });
 
       return {
         success: true,
-        message: `Successfully uninstalled ${serverName}`,
+        message: `Successfully uninstalled ${serverName} from ${targets.join(', ')}`,
       };
     } catch (error) {
       return {

package/src/core/constants.ts

@@ -58,8 +58,18 @@ const CODE_INSIDER_STRORAGE_DIR = (() => {
  * Value: Client-specific settings or configuration details.
  * TODO: Define actual client settings structure.
  */
-export const SUPPORTED_CLIENTS: Record<string, any> = {
-  'MSRooCode': { /* MSROO specific settings */
+export const SUPPORTED_CLIENTS: Record<string, {
+  extension: {
+    extensionId: string;
+    leastVersion?: string;
+    repository?: string;
+    assetName?: string;
+    private?: boolean;
+  };
+  codeSettingPath: string;
+  codeInsiderSettingPath: string;
+}> = {
+  'MSRooCode': {
 
     extension: {
       extensionId: 'microsoftai.ms-roo-cline',

package/src/core/installers/clients/ExtensionInstaller.ts

@@ -140,6 +140,9 @@ export class ExtensionInstaller {
                 } else {
                     // Install private extension from GitHub release using latest version
                     try {
+                        if (!repository || !assetName) {
+                            throw new Error(`Missing repository or assetName for private extension ${extensionId}`);
+                        }
                         const { resolvedPath } = await handleGitHubRelease(
                             { name: extensionId, version: 'latest', type: 'extension' },
                             { repository, assetName }

package/src/core/types.ts

@@ -84,6 +84,7 @@ export interface UpdateRequirementOptions {
 
 export interface ServerUninstallOptions {
   removeData?: boolean;
+  targets?: string[];  // List of client targets to uninstall from
 }
 
 // Types related to server feed configuration (e.g., ai-coder-tools.json)
@@ -150,6 +151,11 @@ export interface FeedConfiguration {
   mcpServers: McpConfig[];
 }
 
+export interface ClientSettings {
+  codeSettingPath: string;
+  codeInsiderSettingPath: string;
+}
+
 // Events that can be emitted by the SDK
 export enum MCPEvent {
   SERVER_INSTALLED = 'server:installed',
@@ -161,7 +167,7 @@ export enum MCPEvent {
 
 export interface MCPEventData {
   [MCPEvent.SERVER_INSTALLED]: { server: MCPServerCategory };
-  [MCPEvent.SERVER_UNINSTALLED]: { serverName: string };
+  [MCPEvent.SERVER_UNINSTALLED]: { serverName: string; targets?: string[] };
   [MCPEvent.SERVER_STARTED]: { server: MCPServerCategory };
   [MCPEvent.SERVER_STOPPED]: { serverName: string };
   [MCPEvent.CONFIG_CHANGED]: { configuration: MCPConfiguration };

package/src/services/ServerService.ts

@@ -147,19 +147,34 @@ export class ServerService {
    * Installs a specific mcp tool for a server.
    * TODO: This might require enhancing MCPManager to handle category-specific installs.
    */
+  /**
+   * Uninstall MCP server from specified client targets
+   * @param category The server category
+   * @param serverName The server name to uninstall
+   * @param options Uninstall options including target clients and data removal flags
+   */
   async uninstallMcpServer(
     category: string,
     serverName: string,
-    options: ServerUninstallOptions = {} // Reuse ServerInstallOptions for env etc.
+    options: ServerUninstallOptions = {}
   ): Promise<ServerOperationResult> {
-    return mcpManager.uninstallServer(category, serverName, options);
+    Logger.debug(`Uninstalling MCP server: ${JSON.stringify({ category, serverName, options })}`);
+    try {
+      const result = await mcpManager.uninstallServer(category, serverName, options);
+      Logger.debug(`Uninstallation result: ${JSON.stringify(result)}`);
+      return result;
+    } catch (error) {
+      Logger.error(`Failed to uninstall MCP server: ${serverName}`, error);
+      throw error;
+    }
   }
 
   /**
    * Validates server names
    */
-  async validateServerName(category: string, name: string): Promise<boolean> {
-    Logger.debug(`Validating server name: ${JSON.stringify({ category, name })}`);
+  async validateServerName(category: string, names: string | string[]): Promise<boolean> {
+    const serverNames = Array.isArray(names) ? names : [names];
+    Logger.debug(`Validating server names: ${JSON.stringify({ category, names: serverNames })}`);
 
     // Check if category exists in feeds
     const feedConfig = await mcpManager.getFeedConfiguration(category);
@@ -168,10 +183,13 @@ export class ServerService {
       return false;
     }
 
-    // Check if server exists in the category's mcpServers
-    const serverExists = feedConfig.mcpServers.some(server => server.name === name);
-    if (!serverExists) {
-      Logger.debug(`Validation failed: Server "${name}" not found in category "${category}"`);
+    // Check if all servers exist in the category's mcpServers
+    const invalidServers = serverNames.filter(name =>
+      !feedConfig.mcpServers.some(server => server.name === name)
+    );
+
+    if (invalidServers.length > 0) {
+      Logger.debug(`Validation failed: Servers "${invalidServers.join(', ')}" not found in category "${category}"`);
       return false;
     }
 

package/src/utils/osUtils.ts

@@ -273,7 +273,7 @@ export function getPythonPackagePath(pythonExecutablePath: string): string {
         // Virtual environment structure on Windows: <venv>/Scripts/python.exe
         const venvRoot = path.dirname(dir);
         return path.join(venvRoot, 'Lib', 'site-packages');
-      } else if (dir.toLowerCase().includes('python')) {
+      } else {
         // System Python or Conda on Windows
         return path.join(dir, 'Lib', 'site-packages');
       }

package/src/web/public/css/modal.css

@@ -160,6 +160,15 @@ body {
     transition: all 0.2s ease;
     cursor: pointer;
     user-select: none;
+    gap: 0.5rem;
+}
+
+/* Client actions container */
+.client-actions {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-left: auto;
 }
 
 .client-item:hover {
@@ -180,6 +189,14 @@ body {
     gap: 0.75rem;
 }
 
+/* Status container */
+.status-container {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-left: auto;
+}
+
 /* Status badges */
 .status-badge {
     display: inline-flex;
@@ -227,6 +244,31 @@ body {
     background-color: #fef3c7;
 }
 
+/* Uninstall button styling */
+.uninstall-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 28px;
+    height: 28px;
+    border-radius: 6px;
+    border: 1px solid transparent;
+    background: transparent;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    padding: 0;
+}
+
+.uninstall-btn:hover {
+    background-color: #fee2e2;
+    border-color: #ef4444;
+    transform: scale(1.05);
+}
+
+.uninstall-btn i {
+    font-size: 1.25rem;
+}
+
 /* Environment variables section */
 #modalEnvInputs input {
     width: 100%;

package/src/web/public/js/modal.js

@@ -141,14 +141,16 @@ function _appendInstallLoadingMessage(message) {
 /**
  * Display the installation loading modal and prepare it for messages.
  */
-function showInstallLoadingModal() {
+function showInstallLoadingModal(operation = 'Installing') {
     const loadingModal = document.getElementById('installLoadingModal');
     const loadingMsg = document.getElementById('installLoadingMessage');
-    if (loadingModal && loadingMsg) {
+    const loadingTitle = document.querySelector('.loading-title');
+    if (loadingModal && loadingMsg && loadingTitle) {
         loadingModal.style.display = 'block';
         loadingMsg.innerHTML = '';
+        loadingTitle.textContent = `${operation}...`;
     } else {
-        console.error('[LoadingModal] Required elements not found: installLoadingModal or installLoadingMessage');
+        console.error('[LoadingModal] Required elements not found: installLoadingModal, installLoadingMessage, or loading-title');
     }
 }
 
@@ -330,17 +332,55 @@ async function showInstallModal(categoryName, serverName, callback) {
             // Add elements to client info
             clientInfo.appendChild(clientName);
 
-            // Add client info (name) to the item first
+            // Add elements to client item
             clientItem.appendChild(clientInfo);
 
+            // Status container for badge and uninstall button
+            const statusContainer = document.createElement('div');
+            statusContainer.className = 'status-container';
+
             // Status badge - only show if we have status text
             if (statusText) {
                 const statusBadge = document.createElement('span');
                 statusBadge.className = `status-badge ${statusClass}`;
                 statusBadge.textContent = statusText;
-                clientItem.appendChild(statusBadge);
+                statusContainer.appendChild(statusBadge);
+
+                // Add uninstall button right after status badge if installed
+                if (operationStatus.status === 'completed' && operationStatus.type === 'install') {
+                    const uninstallBtn = document.createElement('button');
+                    uninstallBtn.className = 'uninstall-btn text-red-600 hover:text-red-800 ml-2';
+                    uninstallBtn.innerHTML = '<i class="bx bx-trash"></i>';
+                    uninstallBtn.title = 'Uninstall from this client';
+                    uninstallBtn.onclick = async (e) => {
+                        e.stopPropagation(); // Prevent item selection
+                        e.preventDefault(); // Prevent form submission
+                        const confirmed = await showConfirm('Uninstall Confirmation', `Are you sure you want to uninstall ${serverName} from ${target}?`);
+                        if (confirmed) {
+                            // Add target to selectedClients for uninstallation
+                            window.selectedClients = [target];
+                            showInstallLoadingModal('Uninstalling');
+                            const serverList = {
+                                [serverName]: {
+                                    removeData: true // Include removal of associated data
+                                }
+                            };
+                            try {
+                                delayedAppendInstallLoadingMessage(`Uninstalling ${serverName} from ${target}...`);
+                                await uninstallTools(categoryName, serverList, [target]);
+                            } catch (error) {
+                                delayedAppendInstallLoadingMessage(`Error: ${error.message}`);
+                                throw error; // Re-throw to trigger error handling in uninstallTools
+                            }
+                        }
+                        return false; // Prevent form submission
+                    };
+                    statusContainer.appendChild(uninstallBtn);
+                }
             }
 
+            clientItem.appendChild(statusContainer);
+
             // Add client item to target div
             targetDiv.appendChild(clientItem);
         });
@@ -641,34 +681,40 @@ async function showInstallModal(categoryName, serverName, callback) {
                 });
             });
 
-            // Get selected clients
-            const selectedTargets = window.selectedClients.length > 0 ?
-                window.selectedClients :
-                Array.from(document.querySelectorAll('.client-item.selected'))
-                    .map(item => item.dataset.target);
-
             // Check if we have any requirements selected for update
             const hasRequirementsToUpdate = requirementsToUpdate.length > 0;
 
-            // Only require client selection if we don't have any requirements to update
-            if (selectedTargets.length === 0 && !hasRequirementsToUpdate) {
-                showToast('Please select at least one client to configure.', 'error');
-                return;
+            // Only proceed if this isn't an uninstall operation
+            const uninstallBtn = document.querySelector('.uninstall-btn');
+            if (!uninstallBtn || !uninstallBtn.matches(':active')) {
+                // Get selected clients
+                const selectedTargets = window.selectedClients.length > 0 ?
+                    window.selectedClients :
+                    Array.from(document.querySelectorAll('.client-item.selected'))
+                        .map(item => item.dataset.target);
+
+                console.log('Selected targets:', selectedTargets);
+                console.log('Requirements to update:', requirementsToUpdate);
+                if (selectedTargets.length === 0 && !hasRequirementsToUpdate) {
+                    showToast('Please select at least one client to configure.', 'error');
+                    return;
+                }
+                window.selectedClients = selectedTargets;
             }
 
             // Call install function with selected targets
             // Find installing message for the first selected target
             let installingMessage = "Starting installation...";
             const serverStatus = serverStatuses[serverName] || { installedStatus: {} };
-            if (selectedTargets.length > 0) {
-                const target = selectedTargets[0];
+            if (window.selectedClients.length > 0) {
+                const target = window.selectedClients[0];
                 const msg = serverStatus.installedStatus?.[target]?.message;
                 if (msg) installingMessage = msg;
             }
 
             // Add requirements to update to serverInstallOptions if any
             const serverInstallOptions = {
-                targetClients: selectedTargets,
+                targetClients: window.selectedClients,
                 env: envVars,
                 args: args,
                 settings: pythonEnv ? { pythonEnv } : undefined
@@ -679,7 +725,9 @@ async function showInstallModal(categoryName, serverName, callback) {
                 serverInstallOptions.requirements = requirementsToUpdate;
             }
 
-            handleBulkClientInstall(categoryName, serverName, selectedTargets, envVars, installingMessage, serverData, serverInstallOptions);
+            // For installation, use the selectedTargets from the validation above
+            const targetsToUse = document.querySelector('.uninstall-btn:hover') ? [] : window.selectedClients;
+            handleBulkClientInstall(categoryName, serverName, targetsToUse, envVars, installingMessage, serverData, serverInstallOptions);
         };
 
     } catch (error) {
@@ -893,23 +941,35 @@ async function pollInstallStatus(categoryName, serverName, targets, interval = 2
 
 // Function to handle client uninstallation for multiple targets
 async function uninstallTools(categoryName, serverList, targets) {
-    if (!Array.isArray(targets)) {
-        targets = [targets]; // Convert single target to array for backward compatibility
-    }
-
-    const confirmed = await showConfirm(`Are you sure you want to uninstall this server for ${targets.length} client(s)?`);
-    if (!confirmed) {
+    // Get selected targets from window.selectedClients or the provided targets
+    const selectedTargets = window.selectedClients || (Array.isArray(targets) ? targets : [targets]);
+    
+    // Validate selected targets
+    if (!selectedTargets || selectedTargets.length === 0) {
+        showToast('Please select at least one client to uninstall.', 'error');
         return;
     }
 
     try {
+        delayedAppendInstallLoadingMessage('Starting uninstallation...');
+
+        // Ensure serverList is an object where each key is a server name
+        if (Array.isArray(serverList)) {
+            const formattedServerList = {};
+            serverList.forEach(server => {
+                formattedServerList[server] = { removeData: true };
+            });
+            serverList = formattedServerList;
+        }
+
         const response = await fetch(`/api/categories/${categoryName}/uninstall`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
-                toolList: serverList,
+                serverList: serverList,
                 options: {
-                    targets: targets
+                    targets: selectedTargets,
+                    removeData: true
                 }
             })
         });
@@ -924,10 +984,14 @@ async function uninstallTools(categoryName, serverList, targets) {
             throw new Error(result.error || 'Uninstallation failed');
         }
 
-        showToast(`Successfully uninstalled for ${targets.length} client(s).`, 'success');
-        location.reload(); // Refresh the page to update the UI
+        // Add completion message and trigger completion UI
+        delayedAppendInstallLoadingMessage(`Successfully uninstalled from ${selectedTargets.join(', ')}`, true);
+        
+        // Clear selected clients after successful uninstall
+        window.selectedClients = [];
     } catch (error) {
         console.error('Error uninstalling tools:', error);
+        delayedAppendInstallLoadingMessage(`Error: ${error.message}`, true);
         showToast(`Error uninstalling tools: ${error.message}`, 'error');
     }
 }