mlgym-deploy 2.2.0 → 2.3.1

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.1.0';
+const CURRENT_VERSION = '2.3.1';
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -49,18 +49,7 @@ async function checkForUpdates() {
 
     lastVersionCheck = Date.now();
 
-    // Log to stderr if update available (visible in Cursor logs)
-    if (isUpdateAvailable) {
-      console.error(`\n╔════════════════════════════════════════════════════════════════╗`);
-      console.error(`║ MLGym MCP Server Update Available!                                ║`);
-      console.error(`║                                                                    ║`);
-      console.error(`║ Current version: ${CURRENT_VERSION.padEnd(49)} ║`);
-      console.error(`║ Latest version:  ${latestVersion.padEnd(49)} ║`);
-      console.error(`║                                                                    ║`);
-      console.error(`║ To update, run: npm install -g ${PACKAGE_NAME}@latest              ║`);
-      console.error(`╚════════════════════════════════════════════════════════════════╝\n`);
-    }
-
+    // Don't log here since we'll block execution in main()
     return versionCheckResult;
   } catch (error) {
     // Silent fail - don't disrupt normal operation
@@ -411,9 +400,29 @@ const TOOLS = [
       }
     }
   },
+  {
+    name: 'mlgym_auth_check',
+    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 (ask for this FIRST)',
+          pattern: '^[^@]+@[^@]+\\.[^@]+$'
+        },
+        password: {
+          type: 'string',
+          description: 'Password (ONLY ask if account exists)',
+          minLength: 8
+        }
+      },
+      required: ['email']
+    }
+  },
   {
     name: 'mlgym_user_create',
-    description: 'Create a new user with GitLab, Coolify, and SSH key setup. IMPORTANT: You must explicitly ask the user for their email, full name, password, and terms acceptance.',
+    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: {
@@ -434,15 +443,20 @@ const TOOLS = [
         },
         accept_terms: {
           type: 'boolean',
-          description: 'User must explicitly accept terms and conditions (REQUIRED: must be true)'
+          description: 'User must explicitly accept terms and conditions (REQUIRED for new users)'
+        },
+        setup_ssh_only: {
+          type: 'boolean',
+          description: 'Set to true to only setup SSH keys for existing user (skip user creation)',
+          default: false
         }
       },
-      required: ['email', 'name', 'password', 'accept_terms']
+      required: ['email', 'password']  // Only email and password are always required
     }
   },
   {
     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: {
@@ -1181,6 +1195,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     case 'mlgym_version_check':
       return await versionCheck(args);
 
+    case 'mlgym_auth_check':
+      return await checkUserExists(args);
+
     case 'mlgym_user_create':
       return await createUser(args);
 
@@ -1700,11 +1717,216 @@ async function configureGit(args) {
   };
 }
 
-// Tool implementation: Create User
+// Tool implementation: Check if User Exists
+async function checkUserExists(args) {
+  const { email, password } = args;
+
+  if (!email) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Email is required'
+        }, null, 2)
+      }]
+    };
+  }
+
+  console.error(`Checking if user exists: ${email}`);
+
+  // If password provided, try to login
+  if (password) {
+    try {
+      const loginResult = await apiRequest('POST', '/api/v1/auth/login', {
+        email,
+        password
+      }, false);
+
+      if (loginResult.success) {
+        // Save auth token
+        if (loginResult.data.token) {
+          await saveAuth(email, loginResult.data.token);
+        }
+
+        // Check SSH keys
+        const keysResult = await apiRequest('GET', '/api/v1/keys', null, true);
+        const sshKeys = keysResult.success ? keysResult.data : [];
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'success',
+              exists: true,
+              authenticated: true,
+              email: email,
+              user_id: loginResult.data.user?.user_id,
+              gitlab_username: loginResult.data.user?.gitlab_username,
+              ssh_keys_count: sshKeys.length,
+              has_ssh_keys: sshKeys.length > 0,
+              ssh_keys: sshKeys.map(key => ({
+                id: key.id,
+                title: key.title,
+                created_at: key.created_at
+              })),
+              message: 'User exists and authenticated successfully'
+            }, null, 2)
+          }]
+        };
+      }
+    } catch (err) {
+      // Login failed, but user might exist
+    }
+  }
+
+  // Try to check if email exists without password (will fail but gives info)
+  try {
+    const result = await apiRequest('POST', '/api/v1/auth/login', {
+      email,
+      password: 'dummy_check'
+    }, false);
+
+    // If we get here, it means the endpoint is accessible
+    // The error message will tell us if user exists
+    if (result.error && result.error.includes('Invalid credentials')) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'success',
+            exists: true,
+            authenticated: false,
+            email: email,
+            message: 'User exists but needs password to authenticate',
+            next_step: 'Please provide password to check SSH keys'
+          }, null, 2)
+        }]
+      };
+    }
+  } catch (err) {
+    // Network or other error
+  }
+
+  // User doesn't exist
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify({
+        status: 'success',
+        exists: false,
+        email: email,
+        message: 'User does not exist. You can create a new account.',
+        next_step: 'Use mlgym_user_create to create a new account'
+      }, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Create User or Setup SSH Keys
 async function createUser(args) {
-  let { email, name, password, accept_terms } = args;
+  let { email, name, password, accept_terms, setup_ssh_only = false } = args;
+
+  // Check if this is SSH setup for existing user
+  if (setup_ssh_only) {
+    if (!email || !password) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'error',
+            message: 'Email and password required for SSH key setup',
+            required_fields: {
+              email: email ? '✓ provided' : '✗ missing',
+              password: password ? '✓ provided' : '✗ missing'
+            }
+          }, null, 2)
+        }]
+      };
+    }
+
+    console.error(`Setting up SSH keys for existing user: ${email}`);
+
+    // Login first
+    try {
+      const loginResult = await apiRequest('POST', '/api/v1/auth/login', {
+        email,
+        password
+      }, false);
+
+      if (!loginResult.success) {
+        return {
+          content: [{
+            type: 'text',
+            text: `Failed to authenticate: ${loginResult.error}`
+          }]
+        };
+      }
 
-  // Validate all required fields are provided
+      // Save auth token
+      if (loginResult.data.token) {
+        await saveAuth(email, loginResult.data.token);
+      }
+
+      // Generate SSH key
+      console.error('Generating SSH key pair...');
+      const { publicKey, privateKeyPath } = await generateSSHKeyPair(email);
+      const publicKeyPath = privateKeyPath + '.pub';
+      console.error(`SSH key generated: ${privateKeyPath}`);
+
+      // Add SSH key
+      const keyTitle = `mlgym-${new Date().toISOString().split('T')[0]}`;
+      const keyResult = await apiRequest('POST', '/api/v1/keys', {
+        title: keyTitle,
+        key: publicKey
+      }, true);
+
+      if (keyResult.success) {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'success',
+              message: 'SSH key added successfully',
+              email: email,
+              ssh_key_path: privateKeyPath,
+              ssh_key_id: keyResult.data.id,
+              next_steps: [
+                `SSH key generated at: ${privateKeyPath}`,
+                `Add to SSH agent: ssh-add "${privateKeyPath}"`,
+                'Wait 10-15 seconds for SSH key to propagate to GitLab',
+                'You can now push code to GitLab repositories'
+              ]
+            }, null, 2)
+          }]
+        };
+      } else {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              status: 'error',
+              message: 'Failed to add SSH key',
+              error: keyResult.error,
+              manual_steps: [
+                `SSH key generated at: ${publicKeyPath}`,
+                'Manually add it at: https://git.mlgym.io/-/user_settings/ssh_keys'
+              ]
+            }, null, 2)
+          }]
+        };
+      }
+    } catch (err) {
+      return {
+        content: [{
+          type: 'text',
+          text: `Error setting up SSH keys: ${err.message}`
+        }]
+      };
+    }
+  }
+
+  // Regular user creation - validate all required fields
   if (!email || !name || !password || accept_terms !== true) {
     return {
       content: [{
@@ -6105,14 +6327,33 @@ 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 (don't block startup)
-  setTimeout(async () => {
-    await checkForUpdates();
-  }, 2000); // Check after 2 seconds
 }
 
 main().catch((error) => {

package/package.json

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