mlgym-deploy 2.3.0 → 2.3.2

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.0';
+const CURRENT_VERSION = '2.3.2';
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -25,6 +25,34 @@ 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 = `\n╔════════════════════════════════════════════════════════════════════╗
+║                  🔄 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. Close this terminal/tab                                          ║
+║  2. Run: npm install -g ${PACKAGE_NAME}@latest                          ║
+║  3. Restart Cursor to use the updated MCP server                    ║
+║                                                                        ║
+║  ⚠️  Using outdated version may cause issues!                         ║
+╚════════════════════════════════════════════════════════════════════╝\n`;
+
+    // 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 {
@@ -402,18 +430,18 @@ const TOOLS = [
   },
   {
     name: 'mlgym_auth_check',
-    description: 'Check if a user account exists and whether SSH keys are configured. Use this BEFORE creating a new account to avoid duplicates.',
+    description: '🚨 ALWAYS USE THIS FIRST when deploying! Check if user account exists BEFORE asking for other details. Start by ONLY asking for email.',
     inputSchema: {
       type: 'object',
       properties: {
         email: {
           type: 'string',
-          description: 'Email address to check',
+          description: 'Email address to check (ask for this FIRST)',
           pattern: '^[^@]+@[^@]+\\.[^@]+$'
         },
         password: {
           type: 'string',
-          description: 'Password (optional - only needed if account exists)',
+          description: 'Password (ONLY ask if account exists)',
           minLength: 8
         }
       },
@@ -422,7 +450,7 @@ const TOOLS = [
   },
   {
     name: 'mlgym_user_create',
-    description: 'Create a new user OR setup SSH keys for existing user. First use mlgym_auth_check to verify if account exists.',
+    description: 'Create new user or setup SSH. ⚠️ NEVER use this first! Always check with mlgym_auth_check before asking for full details.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -456,7 +484,7 @@ const TOOLS = [
   },
   {
     name: 'mlgym_project_init',
-    description: 'Initialize and deploy a project with GitLab repository and Coolify deployment. IMPORTANT: You must explicitly ask the user for project name, description, and deployment URL if deployment is enabled.',
+    description: 'Initialize project deployment. ⚠️ ONLY use AFTER authentication! Ask for project details AFTER user is logged in, not before.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1176,166 +1204,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 +6411,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.0",
+  "version": "2.3.2",
   "description": "MCP server for GitLab Backend - User creation and project deployment",
   "main": "index.js",
   "type": "module",