imcp 0.0.10 → 0.0.12

package/dist/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');
     }
 }

package/dist/web/public/js/notifications.js

@@ -30,28 +30,26 @@ function showToast(message, type = 'success') {
     });
 }
 
-// Function to show a Bootstrap confirmation dialog
-function showConfirm(message) {
+// Function to show a confirmation dialog using custom modal system
+function showConfirm(title, message) {
     return new Promise((resolve) => {
         const modalId = `confirm-modal-${Date.now()}`;
         const modalHtml = `
-            <div class="modal fade" id="${modalId}" tabindex="-1" aria-labelledby="${modalId}-label" aria-hidden="true">
-                <div class="modal-dialog">
-                    <div class="modal-content">
-                        <div class="modal-header">
-                            <h5 class="modal-title" id="${modalId}-label">Confirm Action</h5>
-                            <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                        </div>
-                        <div class="modal-body">
-                            ${message}
-                        </div>
-                        <div class="modal-footer">
-                            <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
-                            <button type="button" class="btn btn-primary confirm-action">
-                                <span class="spinner-border spinner-border-sm d-none me-2" role="status" aria-hidden="true"></span>
-                                Confirm
-                            </button>
-                        </div>
+            <div id="${modalId}" class="modal">
+                <div class="modal-content" style="max-width: 400px; margin: 15% auto;">
+                    <div class="modal-header">
+                        <h3 class="text-lg font-semibold text-gray-700">${title}</h3>
+                    </div>
+                    <div style="margin: 1rem 0;">
+                        ${message}
+                    </div>
+                    <div style="display: flex; justify-content: flex-end; gap: 0.5rem; margin-top: 1rem;">
+                        <button type="button" class="cancel-button px-4 py-2 text-gray-600 hover:text-gray-800 font-medium rounded-lg hover:bg-gray-100 transition-colors">
+                            Cancel
+                        </button>
+                        <button type="button" class="confirm-button submit-button">
+                            Confirm
+                        </button>
                     </div>
                 </div>
             </div>
@@ -60,29 +58,30 @@ function showConfirm(message) {
         document.body.insertAdjacentHTML('beforeend', modalHtml);
         
         const modalElement = document.getElementById(modalId);
-        const modal = new bootstrap.Modal(modalElement);
+        modalElement.style.display = 'block';
         
         // Handle confirm button click
-        modalElement.querySelector('.confirm-action').addEventListener('click', (event) => {
-            const button = event.currentTarget;
-            const spinner = button.querySelector('.spinner-border');
-            button.disabled = true;
-            spinner.classList.remove('d-none');
-            
-            // Add small delay to show the loading state
-            setTimeout(() => {
-                modal.hide();
-                resolve(true);
-            }, 300);
+        modalElement.querySelector('.confirm-button').addEventListener('click', () => {
+            modalElement.style.display = 'none';
+            modalElement.remove();
+            resolve(true);
         });
         
-        // Handle modal hidden event
-        modalElement.addEventListener('hidden.bs.modal', () => {
+        // Handle cancel button click
+        modalElement.querySelector('.cancel-button').addEventListener('click', () => {
+            modalElement.style.display = 'none';
             modalElement.remove();
             resolve(false);
         });
-        
-        modal.show();
+
+        // Handle click outside modal
+        modalElement.addEventListener('click', (event) => {
+            if (event.target === modalElement) {
+                modalElement.style.display = 'none';
+                modalElement.remove();
+                resolve(false);
+            }
+        });
     });
 }
 

package/dist/web/server.js

@@ -110,13 +110,24 @@ app.post('/api/categories/:categoryName/uninstall', async (req, res) => {
     try {
         const { categoryName } = req.params;
         const { serverList } = req.body;
-        if (!Array.isArray(serverList) || serverList.length === 0) {
+        if (!serverList || Object.keys(serverList).length === 0) {
             return res.status(400).json({
                 success: false,
                 error: 'Invalid tool list provided'
             });
         }
-        const results = await Promise.all(serverList.map(serverName => serverService.uninstallMcpServer(categoryName, serverName)));
+        const { options } = req.body;
+        if (!options?.targets || options.targets.length === 0) {
+            return res.status(400).json({
+                success: false,
+                error: 'No target clients specified'
+            });
+        }
+        const results = await Promise.all(Object.entries(serverList).map(([serverName, serverOptions]) => serverService.uninstallMcpServer(categoryName, serverName, {
+            ...serverOptions,
+            targets: options.targets,
+            removeData: options.removeData ?? serverOptions.removeData
+        })));
         const { success, messages } = serverService.formatOperationResults(results);
         const response = {
             success,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imcp",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Node.js SDK for Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli/commands/serve.ts

@@ -8,21 +8,22 @@ export function createServeCommand(): Command {
   return new Command('serve')
     .description('Serve local web interface')
     .option('-p, --port <port>', 'Port to run the server on', '3000')
+    .option('-f, --feed-file <filepath>', 'Path to a custom feed configuration file')
     .action(async (options) => {
       try {
         // Sync feeds before start the local UI
         await mcpManager.syncFeeds();
 
         // Ensure MCP manager is initialized before starting the web server
-        await mcpManager.initialize();
-        
+        await mcpManager.initialize(options.feedFile);
+
         const port = parseInt(options.port, 10);
         if (isNaN(port) || port < 1 || port > 65535) {
           throw new Error('Invalid port number');
         }
 
         await startWebServer(port);
-        
+
         // The server is running, keep the process alive
         process.on('SIGINT', () => {
           console.log('\nShutting down server...');

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/ConfigurationLoader.ts

@@ -177,25 +177,46 @@ export class ConfigurationLoader {
     /**
      * Loads feed configurations into the MCP configuration
      */
-    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration): Promise<MCPConfiguration> {
+    static async loadFeedsIntoConfiguration(configuration: MCPConfiguration, feedFile?: string): Promise<MCPConfiguration> {
         try {
             await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+            const feeds: Record<string, FeedConfiguration> = {};
+
+            // Load provided feed file if specified
+            if (feedFile) {
+                try {
+                    const content = await fs.readFile(feedFile, 'utf8');
+                    const config = JSON.parse(content) as FeedConfiguration;
+                    if (config && config.name) {
+                        feeds[config.name] = config;
+                        console.log(`Loaded feed configuration from provided file: ${feedFile}`);
+                    }
+                } catch (error) {
+                    console.log(`Error loading feed configuration from provided file ${feedFile}:`, error);
+                }
+            }
+
+            // Load feeds from LOCAL_FEEDS_DIR
             const files = await fs.readdir(LOCAL_FEEDS_DIR);
             const jsonFiles = files.filter(file => file.endsWith('.json'));
 
-            if (jsonFiles.length === 0) {
+            if (jsonFiles.length === 0 && !feedFile) {
                 console.log(`No feed configuration files found in ${LOCAL_FEEDS_DIR}`);
                 return configuration;
             }
 
-            const feeds: Record<string, FeedConfiguration> = {};
             for (const file of jsonFiles) {
                 try {
                     const filePath = path.join(LOCAL_FEEDS_DIR, file);
                     const content = await fs.readFile(filePath, 'utf8');
                     const config = JSON.parse(content) as FeedConfiguration;
                     if (config && config.name) {
-                        feeds[config.name] = config;
+                        // If feed exists from provided file, skip the local one
+                        if (!feeds[config.name]) {
+                            feeds[config.name] = config;
+                        } else {
+                            console.log(`Skipping local feed ${config.name} as it was provided via --feed-file`);
+                        }
                     }
                 } catch (error) {
                     console.warn(`Error loading feed configuration from ${file}:`, error);

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';
 
@@ -57,7 +58,7 @@ export class ConfigurationProvider {
         }
     }
 
-    async initialize(): Promise<void> {
+    async initialize(feedFile?: string): Promise<void> {
         await this.withLock(async () => {
             const configDir = path.dirname(this.configPath);
             await fs.mkdir(configDir, { recursive: true });
@@ -75,7 +76,7 @@ export class ConfigurationProvider {
                 }
 
                 // Always load feeds and client settings, whether file existed or not
-                await this.loadFeedsIntoConfiguration();
+                await this.loadFeedsIntoConfiguration(feedFile);
                 await this.loadClientMCPSettings();
             } catch (error) {
                 Logger.error('Error during initialization', error);
@@ -340,8 +341,8 @@ export class ConfigurationProvider {
         });
     }
 
-    private async loadFeedsIntoConfiguration(): Promise<void> {
-        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration);
+    private async loadFeedsIntoConfiguration(feedFile?: string): Promise<void> {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile);
         await this.saveConfiguration();
     }
 
@@ -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,8 +9,7 @@ import {
   ServerCategoryListOptions,
   ServerOperationResult,
   ServerUninstallOptions,
-  InstallationStatus,
-  UpdateRequirementOptions
+  InstallationStatus
 } from './types.js';
 import path from 'path';
 
@@ -28,9 +27,9 @@ export class MCPManager extends EventEmitter {
     await this.configProvider.syncFeeds();
   }
 
-  async initialize(): Promise<void> {
+  async initialize(feedFile?: string): Promise<void> {
     try {
-      await this.configProvider.initialize();
+      await this.configProvider.initialize(feedFile);
     } catch (error) {
       console.error("Error during MCPManager initialization:", error);
       throw error;
@@ -95,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 {