mlgym-deploy 2.3.1 → 2.3.3

package/index.js

@@ -17,7 +17,7 @@ import crypto from 'crypto';
 const execAsync = promisify(exec);
 
 // Current version of this MCP server
-const CURRENT_VERSION = '2.3.1';
+const CURRENT_VERSION = '2.3.3';
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -25,6 +25,36 @@ let versionCheckResult = null;
 let lastVersionCheck = 0;
 const VERSION_CHECK_INTERVAL = 3600000; // Check once per hour
 
+// Helper to wrap tool response with update message if needed
+function wrapResponseWithUpdateMessage(response) {
+  if (versionCheckResult && versionCheckResult.updateAvailable) {
+    const updateMessage = `
+╔════════════════════════════════════════════════════════════════════╗
+║                  🔄 UPDATE AVAILABLE 🔄                              ║
+║                                                                        ║
+║  A newer version of MLGym MCP Server is available!                    ║
+║                                                                        ║
+║  Current version: ${CURRENT_VERSION.padEnd(52)} ║
+║  Latest version:  ${versionCheckResult.latest.padEnd(52)} ║
+║                                                                        ║
+║  To update in Cursor:                                                 ║
+║  1. Open a new terminal tab (Cmd/Ctrl + Shift + \`)                  ║
+║  2. Run: npm install -g ${PACKAGE_NAME}@latest                          ║
+║  3. Restart Cursor to use the updated MCP server                    ║
+║                                                                        ║
+║  ⚠️  Using outdated version may cause unexpected issues!              ║
+╚════════════════════════════════════════════════════════════════════╝
+`;
+
+    // Prepend update message to the response
+    if (response.content && response.content[0] && response.content[0].type === 'text') {
+      const originalText = response.content[0].text;
+      response.content[0].text = updateMessage + "\n" + originalText;
+    }
+  }
+  return response;
+}
+
 // Helper to check for updates
 async function checkForUpdates() {
   try {
@@ -1176,166 +1206,222 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
+  let response;
   switch (name) {
     case 'mlgym_git_configure':
-      return await configureGit(args);
+      response = await configureGit(args);
+      break;
 
     case 'mlgym_debug_last_error':
-      return await debugLastError(args);
+      response = await debugLastError(args);
+      break;
 
     case 'mlgym_debug_status':
-      return await debugStatus(args);
+      response = await debugStatus(args);
+      break;
 
     case 'mlgym_debug_logs':
-      return await debugLogs(args);
+      response = await debugLogs(args);
+      break;
 
     case 'mlgym_debug_deployment':
-      return await debugDeployment(args);
+      response = await debugDeployment(args);
+      break;
 
     case 'mlgym_version_check':
-      return await versionCheck(args);
+      response = await versionCheck(args);
+      break;
 
     case 'mlgym_auth_check':
-      return await checkUserExists(args);
+      response = await checkUserExists(args);
+      break;
 
     case 'mlgym_user_create':
-      return await createUser(args);
+      response = await createUser(args);
+      break;
 
     case 'mlgym_project_init':
-      return await initProject(args);
+      response = await initProject(args);
+      break;
 
     case 'mlgym_user_recover':
-      return await recoverUser(args);
+      response = await recoverUser(args);
+      break;
 
     case 'mlgym_auth_login':
-      return await loginUser(args);
+      response = await loginUser(args);
+      break;
 
     case 'mlgym_projects_list':
-      return await listProjects(args);
+      response = await listProjects(args);
+      break;
 
     case 'mlgym_deployments_trigger':
-      return await triggerDeployment(args);
+      response = await triggerDeployment(args);
+      break;
 
     case 'mlgym_deployments_get_status':
-      return await getDeploymentStatus(args);
+      response = await getDeploymentStatus(args);
+      break;
 
     case 'mlgym_auth_get_current_user':
-      return await getCurrentUser(args);
+      response = await getCurrentUser(args);
+      break;
 
     case 'mlgym_projects_get':
-      return await getProject(args);
+      response = await getProject(args);
+      break;
 
     case 'mlgym_projects_delete':
-      return await deleteProject(args);
+      response = await deleteProject(args);
+      break;
 
     case 'mlgym_keys_list':
-      return await listKeys(args);
+      response = await listKeys(args);
+      break;
 
     case 'mlgym_projects_update':
-      return await updateProject(args);
+      response = await updateProject(args);
+      break;
 
     case 'mlgym_deployments_list':
-      return await listDeployments(args);
+      response = await listDeployments(args);
+      break;
 
     case 'mlgym_deployments_get_logs':
-      return await getDeploymentLogs(args);
+      response = await getDeploymentLogs(args);
+      break;
 
     case 'mlgym_keys_add':
-      return await addKey(args);
+      response = await addKey(args);
+      break;
 
     case 'mlgym_keys_delete':
-      return await deleteKey(args);
+      response = await deleteKey(args);
+      break;
 
     case 'mlgym_regions_list':
-      return await listRegions(args);
+      response = await listRegions(args);
+      break;
 
     case 'mlgym_regions_get_status':
-      return await getRegionStatus(args);
+      response = await getRegionStatus(args);
+      break;
 
     case 'mlgym_pools_list':
-      return await listPools(args);
+      response = await listPools(args);
+      break;
 
     case 'mlgym_pools_get_stats':
-      return await getPoolStats(args);
+      response = await getPoolStats(args);
+      break;
 
     case 'mlgym_pools_select_optimal':
-      return await selectOptimalPool(args);
+      response = await selectOptimalPool(args);
+      break;
 
     case 'mlgym_regions_select_isp':
-      return await selectISP(args);
+      response = await selectISP(args);
+      break;
 
     case 'mlgym_health_get_report':
-      return await getHealthReport(args);
+      response = await getHealthReport(args);
+      break;
 
     case 'mlgym_health_check_pool':
-      return await checkPoolHealth(args);
+      response = await checkPoolHealth(args);
+      break;
 
     case 'mlgym_health_check_node':
-      return await checkNodeHealth(args);
+      response = await checkNodeHealth(args);
+      break;
 
     case 'mlgym_metrics_get_deployment_metrics':
-      return await getDeploymentMetrics(args);
+      response = await getDeploymentMetrics(args);
+      break;
 
     case 'mlgym_metrics_get_pool_utilization':
-      return await getPoolUtilization(args);
+      response = await getPoolUtilization(args);
+      break;
 
     case 'mlgym_git_get_remote_url':
-      return await getGitRemoteUrl(args);
+      response = await getGitRemoteUrl(args);
+      break;
 
     case 'mlgym_git_setup_push':
-      return await setupGitPush(args);
+      response = await setupGitPush(args);
+      break;
 
     case 'mlgym_git_get_clone_command':
-      return await getGitCloneCommand(args);
+      response = await getGitCloneCommand(args);
+      break;
 
     case 'mlgym_deployments_rollback':
-      return await rollbackDeployment(args);
+      response = await rollbackDeployment(args);
+      break;
 
     case 'mlgym_deployments_scale':
-      return await scaleDeployment(args);
+      response = await scaleDeployment(args);
+      break;
 
     case 'mlgym_auth_logout':
-      return await logoutUser(args);
+      response = await logoutUser(args);
+      break;
 
     case 'mlgym_auth_refresh_token':
-      return await refreshToken(args);
+      response = await refreshToken(args);
+      break;
 
     case 'mlgym_auth_login_to_isp':
-      return await loginToISP(args);
+      response = await loginToISP(args);
+      break;
 
     case 'mlgym_keys_generate_pair':
-      return await generateKeyPair(args);
+      response = await generateKeyPair(args);
+      break;
 
     case 'mlgym_config_set_environment':
-      return await setEnvironment(args);
+      response = await setEnvironment(args);
+      break;
 
     case 'mlgym_config_get_endpoints':
-      return await getEndpoints(args);
+      response = await getEndpoints(args);
+      break;
 
     case 'mlgym_config_set_default_pool':
-      return await setDefaultPool(args);
+      response = await setDefaultPool(args);
+      break;
 
     case 'mlgym_webhooks_setup':
-      return await setupWebhook(args);
+      response = await setupWebhook(args);
+      break;
 
     case 'mlgym_webhooks_test':
-      return await testWebhook(args);
+      response = await testWebhook(args);
+      break;
 
     case 'mlgym_webhooks_get_logs':
-      return await getWebhookLogs(args);
+      response = await getWebhookLogs(args);
+      break;
 
     case 'mlgym_federation_get_status':
-      return await getFederationStatus(args);
+      response = await getFederationStatus(args);
+      break;
 
     case 'mlgym_federation_list_peers':
-      return await listFederationPeers(args);
+      response = await listFederationPeers(args);
+      break;
 
     case 'mlgym_federation_replicate_project':
-      return await replicateProject(args);
+      response = await replicateProject(args);
+      break;
 
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
+
+  // Wrap response with update message if an update is available
+  return wrapResponseWithUpdateMessage(response);
 });
 
 // Helper to generate SSH key pair
@@ -6327,33 +6413,14 @@ async function replicateProject(args) {
 
 // Start the server
 async function main() {
-  // Check for updates BEFORE starting the server
-  const updateCheck = await checkForUpdates();
-
-  if (updateCheck.updateAvailable) {
-    // Block execution and show update required message
-    console.error(`\n╔════════════════════════════════════════════════════════════════════╗`);
-    console.error(`║                    🚫 UPDATE REQUIRED 🚫                              ║`);
-    console.error(`║                                                                        ║`);
-    console.error(`║  The MLGym MCP Server is out of date and cannot run.                  ║`);
-    console.error(`║                                                                        ║`);
-    console.error(`║  Current version: ${CURRENT_VERSION.padEnd(52)} ║`);
-    console.error(`║  Required version: ${updateCheck.latest.padEnd(51)} ║`);
-    console.error(`║                                                                        ║`);
-    console.error(`║  Please update before continuing:                                     ║`);
-    console.error(`║                                                                        ║`);
-    console.error(`║    npm install -g ${PACKAGE_NAME}@latest                                  ║`);
-    console.error(`║                                                                        ║`);
-    console.error(`║  Then restart your IDE or MCP client.                                ║`);
-    console.error(`╚════════════════════════════════════════════════════════════════════════╝\n`);
-
-    // Exit with error code to prevent MCP from starting
-    process.exit(1);
-  }
-
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error(`GitLab Backend MCP Server v${CURRENT_VERSION} started`);
+
+  // Check for updates in the background
+  setTimeout(async () => {
+    await checkForUpdates();
+  }, 1000);
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlgym-deploy",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "MCP server for GitLab Backend - User creation and project deployment",
   "main": "index.js",
   "type": "module",