mlgym-deploy 2.1.0 → 2.3.0

package/index-v2.js

@@ -964,25 +964,44 @@ async function deployProject(sessionId, args) {
     description: `Deployed via MLGym MCP from ${session.framework} project`,
     visibility: 'private',
     enable_deployment: true,
-    deployment_region: region,
     webhook_secret: crypto.randomBytes(16).toString('hex')
+    // Note: deployment_region is not used by backend, it uses random server selection
   };
 
+  console.error(`Creating project with deployment enabled for ${session.projectName} in region ${region}`);
   const result = await apiRequest('POST', '/api/v1/projects', projectData);
 
   if (!result.success) {
+    console.error(`Project creation failed: ${result.error}`);
+    // Provide more detailed error information
     return {
       content: [{
         type: 'text',
         text: JSON.stringify({
           status: 'error',
-          message: `Deployment failed: ${result.error}`
+          message: `Deployment failed: ${result.error}`,
+          details: {
+            project_name: session.projectName,
+            region: region,
+            framework: session.framework,
+            suggestion: 'Please ensure the backend and Coolify services are running properly'
+          }
         }, null, 2)
       }]
     };
   }
 
   const project = result.data;
+  console.error(`Project created successfully: ${project.name} (ID: ${project.id})`);
+  console.error(`SSH URL: ${project.ssh_url_to_repo}`);
+
+  // Check if deployment was actually created
+  const deploymentCreated = project.deployment_status || project.coolify_resource_id;
+  if (deploymentCreated) {
+    console.error(`Deployment resource created in Coolify`);
+  } else {
+    console.error(`Warning: Project created but deployment resource might not be set up`);
+  }
 
   // Initialize git repository
   const gitCommands = [
@@ -990,6 +1009,8 @@ async function deployProject(sessionId, args) {
     `git remote add origin ${project.ssh_url_to_repo}`,
     'git add .',
     'git commit -m "Initial deployment via MLGym"',
+    '# Wait 5-10 seconds for SSH key to propagate in GitLab',
+    'sleep 10',
     'git push -u origin main'
   ];
 
@@ -1014,6 +1035,7 @@ async function deployProject(sessionId, args) {
           ssl: 'auto-provisioned',
           cdn: 'enabled'
         },
+        important_note: '⚠️ SSH key propagation: Please wait 10 seconds before pushing to allow GitLab to activate your SSH key',
         next_steps: {
           message: 'Run these commands in your project directory:',
           commands: gitCommands

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.0';
 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: 'Check if a user account exists and whether SSH keys are configured. Use this BEFORE creating a new account to avoid duplicates.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: {
+          type: 'string',
+          description: 'Email address to check',
+          pattern: '^[^@]+@[^@]+\\.[^@]+$'
+        },
+        password: {
+          type: 'string',
+          description: 'Password (optional - only needed 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 a new user OR setup SSH keys for existing user. First use mlgym_auth_check to verify if account exists.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -434,10 +443,15 @@ 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
     }
   },
   {
@@ -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}`);
 
-  // Validate all required fields are provided
+    // 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}`
+          }]
+        };
+      }
+
+      // 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: [{
@@ -2019,10 +2241,47 @@ async function initProject(args) {
     namespace: project.namespace?.path || project.namespace || auth.email.split('@')[0]
   };
 
-  // If deployment was enabled, the backend has already created webhook and Coolify resources
+  // If deployment was enabled, create Dockerfile if not exists
   if (enable_deployment) {
     console.error('Deployment enabled - backend has set up webhook and Coolify resources automatically');
 
+    // Check if Dockerfile already exists
+    const dockerfilePath = path.join(local_path, 'Dockerfile');
+    let dockerfileCreated = false;
+
+    try {
+      await fs.access(dockerfilePath);
+      console.error('Dockerfile already exists in project');
+    } catch {
+      // Dockerfile doesn't exist, create one based on detected framework
+      console.error('No Dockerfile found, generating one...');
+
+      try {
+        const framework = await detectFramework(local_path);
+        console.error(`Detected framework: ${framework}`);
+
+        const dockerfileContent = generateDockerfile(framework, name);
+        await fs.writeFile(dockerfilePath, dockerfileContent, 'utf8');
+        dockerfileCreated = true;
+
+        console.error(`Created Dockerfile for ${framework} framework`);
+
+        // If React app, also create nginx.conf
+        if (framework === 'react') {
+          const nginxPath = path.join(local_path, 'nginx.conf');
+          try {
+            await fs.access(nginxPath);
+          } catch {
+            const nginxContent = generateNginxConf();
+            await fs.writeFile(nginxPath, nginxContent, 'utf8');
+            console.error('Created nginx.conf for React app');
+          }
+        }
+      } catch (err) {
+        console.error(`Failed to create Dockerfile: ${err.message}`);
+      }
+    }
+
     response.webhook = {
       secret: webhookSecret,
       status: 'created',
@@ -2032,7 +2291,8 @@ async function initProject(args) {
     response.deployment = {
       status: 'initialized',
       domain: `${name}.eu-central.mlgym.app`,
-      message: 'Coolify deployment ready - push to main branch to trigger deployment'
+      message: 'Coolify deployment ready - push to main branch to trigger deployment',
+      dockerfile: dockerfileCreated ? 'Generated automatically based on framework detection' : 'Using existing Dockerfile'
     };
   }
 
@@ -2075,6 +2335,180 @@ function generateWebhookSecret() {
   return secret;
 }
 
+// Generate Dockerfile based on detected framework
+function generateDockerfile(framework, projectName) {
+  const dockerfiles = {
+    nextjs: `# Next.js Production Dockerfile
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+ENV NODE_ENV=production
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/.next ./.next
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./package.json
+EXPOSE 3000
+ENV PORT=3000
+CMD ["npm", "start"]`,
+
+    react: `# React Production Dockerfile
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY --from=builder /app/build /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]`,
+
+    express: `# Express.js Dockerfile
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+EXPOSE 3000
+ENV PORT=3000
+CMD ["node", "index.js"]`,
+
+    django: `# Django Dockerfile
+FROM python:3.11-slim
+WORKDIR /app
+ENV PYTHONUNBUFFERED=1
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN python manage.py collectstatic --noinput
+EXPOSE 8000
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi:application"]`,
+
+    php: `# PHP Dockerfile
+FROM php:8.2-apache
+RUN docker-php-ext-install pdo pdo_mysql
+COPY . /var/www/html/
+RUN a2enmod rewrite
+EXPOSE 80`,
+
+    static: `# Static Site Dockerfile
+FROM nginx:alpine
+COPY . /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]`,
+
+    go: `# Go Dockerfile
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN go build -o main .
+
+FROM alpine:latest
+RUN apk --no-cache add ca-certificates
+WORKDIR /root/
+COPY --from=builder /app/main .
+EXPOSE 8080
+CMD ["./main"]`,
+
+    rust: `# Rust Dockerfile
+FROM rust:1.75 AS builder
+WORKDIR /app
+COPY Cargo.* ./
+COPY src ./src
+RUN cargo build --release
+
+FROM debian:bookworm-slim
+WORKDIR /app
+COPY --from=builder /app/target/release/${projectName} .
+EXPOSE 8080
+CMD ["./${projectName}"]`
+  };
+
+  return dockerfiles[framework] || dockerfiles.static;
+}
+
+// Generate nginx.conf for React apps
+function generateNginxConf() {
+  return `server {
+    listen 80;
+    location / {
+        root /usr/share/nginx/html;
+        index index.html index.htm;
+        try_files $uri $uri/ /index.html;
+    }
+}`;
+}
+
+// Detect project framework by analyzing files
+async function detectFramework(localPath) {
+  try {
+    // Check for package.json
+    const packagePath = path.join(localPath, 'package.json');
+    const packageData = await fs.readFile(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageData);
+
+    // Check dependencies
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+    if (deps.next) return 'nextjs';
+    if (deps.react && !deps.next) return 'react';
+    if (deps.express) return 'express';
+    if (deps.vue) return 'vue';
+    if (deps.angular) return 'angular';
+
+    // If has package.json but no recognized framework
+    return 'node';
+  } catch {
+    // No package.json, check for other files
+  }
+
+  // Check for Python
+  try {
+    await fs.access(path.join(localPath, 'requirements.txt'));
+    const content = await fs.readFile(path.join(localPath, 'requirements.txt'), 'utf8');
+    if (content.includes('django')) return 'django';
+    if (content.includes('flask')) return 'flask';
+    return 'python';
+  } catch {}
+
+  // Check for Go
+  try {
+    await fs.access(path.join(localPath, 'go.mod'));
+    return 'go';
+  } catch {}
+
+  // Check for Rust
+  try {
+    await fs.access(path.join(localPath, 'Cargo.toml'));
+    return 'rust';
+  } catch {}
+
+  // Check for PHP
+  try {
+    await fs.access(path.join(localPath, 'composer.json'));
+    return 'php';
+  } catch {}
+
+  // Check for index.php
+  try {
+    await fs.access(path.join(localPath, 'index.php'));
+    return 'php';
+  } catch {}
+
+  // Default to static site
+  return 'static';
+}
+
 // Tool implementation: Recover User
 async function recoverUser(args) {
   const { email, pin, new_password } = args;
@@ -5893,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.1.0",
+  "version": "2.3.0",
   "description": "MCP server for GitLab Backend - User creation and project deployment",
   "main": "index.js",
   "type": "module",