mlgym-deploy 2.10.0 → 3.0.1

package/index.js

@@ -17,7 +17,7 @@ import crypto from 'crypto';
 const execAsync = promisify(exec);
 
 // Current version of this MCP server - INCREMENT FOR WORKFLOW FIXES
-const CURRENT_VERSION = '2.10.0';  // Fixed SSH key handling: generate and include in user creation request
+const CURRENT_VERSION = '3.0.1';  // Restored legacy user creation and login tools
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -1107,6 +1107,529 @@ async function initProject(args) {
   };
 }
 
+// ============================================================================
+// LEGACY USER MANAGEMENT TOOLS (DISABLED - kept for reference)
+// ============================================================================
+
+// Create User (from v2.3.0 - ENABLED)
+async function createUser(args) {
+  let { email, name, password, accept_terms } = args;
+
+  // Validate all required fields
+  if (!email || !name || !password || accept_terms !== true) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'All fields are required: email, name, password, and accept_terms must be true',
+          required_fields: {
+            email: email ? '✓ provided' : '✗ missing',
+            name: name ? '✓ provided' : '✗ missing',
+            password: password ? '✓ provided' : '✗ missing',
+            accept_terms: accept_terms === true ? '✓ accepted' : '✗ must explicitly accept terms'
+          }
+        }, null, 2)
+      }]
+    };
+  }
+
+  console.error(`Creating user: ${email}`);
+
+  try {
+    // Generate SSH key pair
+    console.error('Generating SSH key pair...');
+    const { publicKey, privateKeyPath } = await generateSSHKeyPair(email);
+    const publicKeyPath = privateKeyPath + '.pub';
+    console.error(`SSH key generated: ${privateKeyPath}`);
+
+    // Create user via backend API with SSH key
+    const result = await apiRequest('POST', '/api/v1/users', {
+      email,
+      name,
+      password,
+      ssh_key: publicKey
+    }, false);
+
+    if (!result.success) {
+      return {
+        content: [{
+          type: 'text',
+          text: `Failed to create user: ${result.error}`
+        }]
+      };
+    }
+
+    // Save authentication token
+    if (result.data.token) {
+      await saveAuth(email, result.data.token);
+    }
+
+    const userData = result.data.user || {};
+    const sshKeyStatus = result.data.ssh_key_status || 'Unknown';
+    const sshKeyUploaded = sshKeyStatus === 'SSH key uploaded successfully';
+
+    const nextSteps = [
+      'Using your provided password',
+      `SSH key generated locally at: ${privateKeyPath}`
+    ];
+
+    if (sshKeyUploaded) {
+      nextSteps.push(`✅ SSH key uploaded to GitLab (ID: ${result.data.ssh_key_id || 'unknown'})`);
+      nextSteps.push(`Add to SSH agent: ssh-add "${privateKeyPath}"`);
+      nextSteps.push('You can now push code to GitLab repositories');
+    } else {
+      nextSteps.push(`⚠️ SSH key upload failed: ${sshKeyStatus}`);
+      nextSteps.push('You need to manually add the SSH key to GitLab:');
+      nextSteps.push(`cat ${publicKeyPath} # Copy this key`);
+      nextSteps.push('Then add it at: https://git.mlgym.io/-/user_settings/ssh_keys');
+    }
+
+    const response = {
+      user_id: userData.user_id || userData.UserID,
+      email: userData.email || email,
+      name: userData.name || name,
+      gitlab_username: userData.gitlab_username || userData.GitLabUsername,
+      ssh_key_path: privateKeyPath,
+      ssh_key_status: sshKeyStatus,
+      ssh_key_uploaded: sshKeyUploaded,
+      token: result.data.token,
+      message: result.data.message || 'User created successfully',
+      next_steps: nextSteps
+    };
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(response, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Failed to create user: ${error.message}`
+      }]
+    };
+  }
+}
+
+// Login User (from v2.3.0 - ENABLED)
+async function loginUser(args) {
+  const { email, password } = args;
+
+  if (!email || !password) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Email and password are required'
+        }, null, 2)
+      }]
+    };
+  }
+
+  console.error(`Logging in user: ${email}`);
+
+  try {
+    const result = await apiRequest('POST', '/api/v1/auth/login', {
+      email,
+      password
+    }, false);
+
+    if (!result.success) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'error',
+            message: result.error || 'Login failed',
+            details: 'Invalid email or password'
+          }, null, 2)
+        }]
+      };
+    }
+
+    // Save authentication token
+    if (result.data.token) {
+      await saveAuth(email, result.data.token);
+    }
+
+    const userData = result.data.user || {};
+    const response = {
+      status: 'success',
+      token: result.data.token,
+      user: {
+        user_id: userData.user_id || userData.UserID,
+        email: userData.email || email,
+        name: userData.name || userData.Name,
+        gitlab_username: userData.gitlab_username || userData.GitLabUsername
+      },
+      expires_at: result.data.expires_at || new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+      message: 'Login successful',
+      next_steps: [
+        'You can now create and manage projects',
+        'Use mlgym_project_init or mlgym_deploy to create a new project',
+        'Token will expire in 24 hours'
+      ]
+    };
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(response, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: `Login failed: ${error.message}`
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// ============================================================================
+// MONOLITHIC DEPLOYMENT WORKFLOW CLASS (v3.0.0)
+// ============================================================================
+class DeploymentWorkflow {
+  constructor() {
+    this.currentStep = null;
+    this.authToken = null;
+    this.projectAnalysis = null;
+    this.gitlabProject = null;
+    this.steps = [];
+  }
+
+  addStep(stepName, status = 'pending', result = null) {
+    this.steps.push({ step: stepName, status, result, timestamp: new Date().toISOString() });
+  }
+
+  updateLastStep(status, result = null) {
+    if (this.steps.length > 0) {
+      this.steps[this.steps.length - 1].status = status;
+      if (result) this.steps[this.steps.length - 1].result = result;
+    }
+  }
+
+  async ensureAuth(email, password) {
+    this.currentStep = 'authentication';
+    this.addStep('authentication', 'running');
+
+    // Check if already authenticated
+    const auth = await loadAuth();
+    if (auth.token) {
+      this.authToken = auth.token;
+      this.updateLastStep('completed', 'Using cached authentication');
+      return { authenticated: true, cached: true };
+    }
+
+    // Need credentials
+    if (!email || !password) {
+      this.updateLastStep('failed', 'Email and password required');
+      throw new Error('Authentication required. Please provide email and password.');
+    }
+
+    // Authenticate using existing function
+    const authResult = await authenticate({ email, password, create_if_not_exists: false });
+
+    // Parse the result
+    const resultData = JSON.parse(authResult.content[0].text);
+
+    if (resultData.status === 'success' || resultData.authenticated) {
+      this.authToken = (await loadAuth()).token;
+      this.updateLastStep('completed', 'Authentication successful');
+      return { authenticated: true, cached: false };
+    } else {
+      this.updateLastStep('failed', resultData.message);
+      throw new Error(`Authentication failed: ${resultData.message}`);
+    }
+  }
+
+  async analyzeProject(local_path) {
+    this.currentStep = 'analysis';
+    this.addStep('project_analysis', 'running');
+
+    try {
+      this.projectAnalysis = await analyzeProject(local_path);
+      this.updateLastStep('completed', {
+        type: this.projectAnalysis.project_type,
+        framework: this.projectAnalysis.framework
+      });
+      return this.projectAnalysis;
+    } catch (error) {
+      this.updateLastStep('failed', error.message);
+      throw error;
+    }
+  }
+
+  async checkExisting(local_path) {
+    this.currentStep = 'check_existing';
+    this.addStep('check_existing_project', 'running');
+
+    try {
+      const existing = await checkExistingProject(local_path);
+
+      if (existing.exists) {
+        this.updateLastStep('completed', 'Project already configured');
+        return existing;
+      } else {
+        this.updateLastStep('completed', 'No existing project found');
+        return null;
+      }
+    } catch (error) {
+      this.updateLastStep('failed', error.message);
+      throw error;
+    }
+  }
+
+  async prepareProject(projectType, framework, packageManager) {
+    this.currentStep = 'preparation';
+    this.addStep('prepare_project', 'running');
+
+    try {
+      // Check if Dockerfile exists
+      const analysis = this.projectAnalysis || await analyzeProject('.');
+
+      if (analysis.has_dockerfile) {
+        this.updateLastStep('skipped', 'Dockerfile already exists');
+        return { skipped: true, reason: 'Dockerfile already exists' };
+      }
+
+      // Generate Dockerfile
+      const prepResult = await prepareProject({
+        local_path: '.',
+        project_type: projectType || analysis.project_type,
+        framework: framework || analysis.framework,
+        package_manager: packageManager || 'npm'
+      });
+
+      this.updateLastStep('completed', prepResult.actions);
+      return prepResult;
+    } catch (error) {
+      this.updateLastStep('failed', error.message);
+      throw error;
+    }
+  }
+
+  async createAndDeployProject(params) {
+    this.currentStep = 'project_creation';
+    this.addStep('create_gitlab_project', 'running');
+
+    const { name, description, hostname, local_path } = params;
+
+    try {
+      // Create project using existing function
+      const initResult = await initProject({
+        name,
+        description,
+        enable_deployment: true,
+        hostname: hostname || name,
+        local_path: local_path || '.'
+      });
+
+      // Parse result
+      const resultData = JSON.parse(initResult.content[0].text);
+
+      if (resultData.status === 'success') {
+        this.gitlabProject = resultData.project;
+        this.updateLastStep('completed', resultData.project);
+        return resultData;
+      } else {
+        this.updateLastStep('failed', resultData.error || resultData.message);
+        throw new Error(resultData.error || resultData.message);
+      }
+    } catch (error) {
+      this.updateLastStep('failed', error.message);
+      throw error;
+    }
+  }
+
+  getRecoverySuggestion(error) {
+    const errorMsg = error.message.toLowerCase();
+
+    if (errorMsg.includes('authentication') || errorMsg.includes('token')) {
+      return 'Please provide valid email and password credentials';
+    }
+    if (errorMsg.includes('project') && errorMsg.includes('exists')) {
+      return 'Project already exists. Use mlgym_status to check existing configuration';
+    }
+    if (errorMsg.includes('hostname')) {
+      return 'Please provide a valid hostname (lowercase letters, numbers, and hyphens only)';
+    }
+    if (errorMsg.includes('ssh')) {
+      return 'SSH key generation failed. Check SSH configuration';
+    }
+
+    return 'Check the error message and try again with corrected parameters';
+  }
+}
+
+// ============================================================================
+// MONOLITHIC DEPLOY FUNCTION
+// ============================================================================
+async function deployProject(args) {
+  const workflow = new DeploymentWorkflow();
+
+  const {
+    email,
+    password,
+    project_name,
+    project_description,
+    hostname,
+    local_path = '.',
+    project_type,
+    framework,
+    package_manager = 'npm'
+  } = args;
+
+  try {
+    // Step 1: Ensure authenticated
+    await workflow.ensureAuth(email, password);
+
+    // Step 2: Check if project already exists
+    const existing = await workflow.checkExisting(local_path);
+    if (existing && existing.exists) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'already_exists',
+            message: 'Project already configured in this directory',
+            project: {
+              name: existing.name,
+              namespace: existing.namespace,
+              git_remote: `git@git.mlgym.io:${existing.namespace}/${existing.name}.git`
+            },
+            next_steps: [
+              'Project is already set up',
+              'To update: git push mlgym main',
+              'To check status: use mlgym_status tool'
+            ],
+            workflow_steps: workflow.steps
+          }, null, 2)
+        }]
+      };
+    }
+
+    // Step 3: Analyze project (auto-detect type and framework)
+    const analysis = await workflow.analyzeProject(local_path);
+
+    // Step 4: Prepare project (generate Dockerfile if needed)
+    await workflow.prepareProject(project_type, framework, package_manager);
+
+    // Step 5: Create GitLab project and deploy
+    const deployResult = await workflow.createAndDeployProject({
+      name: project_name,
+      description: project_description,
+      hostname: hostname || project_name,
+      local_path
+    });
+
+    // Success response
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          message: 'Project deployed successfully',
+          project: deployResult.project,
+          deployment: deployResult.deployment,
+          url: deployResult.project.deployment_url,
+          analysis: {
+            detected_type: analysis.project_type,
+            detected_framework: analysis.framework
+          },
+          next_steps: deployResult.next_steps,
+          workflow_steps: workflow.steps
+        }, null, 2)
+      }]
+    };
+
+  } catch (error) {
+    console.error('Deployment workflow failed:', error);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Deployment failed',
+          error: error.message,
+          failed_at_step: workflow.currentStep,
+          recovery_suggestion: workflow.getRecoverySuggestion(error),
+          workflow_steps: workflow.steps
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// ============================================================================
+// SIMPLIFIED STATUS CHECK
+// ============================================================================
+async function getStatus(args) {
+  const local_path = args.local_path || '.';
+
+  try {
+    // Check authentication
+    const auth = await loadAuth();
+    const authenticated = !!auth.token;
+
+    // Check existing project
+    const projectStatus = await checkExistingProject(local_path);
+
+    // Analyze project if directory exists
+    let analysis = null;
+    try {
+      analysis = await analyzeProject(local_path);
+    } catch (e) {
+      analysis = { error: 'Could not analyze project' };
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'ok',
+          authentication: {
+            authenticated,
+            email: auth.email || null
+          },
+          project: projectStatus.exists ? {
+            configured: true,
+            name: projectStatus.name,
+            namespace: projectStatus.namespace,
+            git_remote: `git@git.mlgym.io:${projectStatus.namespace}/${projectStatus.name}.git`
+          } : {
+            configured: false
+          },
+          analysis: analysis.project_type ? {
+            type: analysis.project_type,
+            framework: analysis.framework,
+            has_dockerfile: analysis.has_dockerfile
+          } : null
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+}
+
 // Create the MCP server
 const server = new Server(
   {
@@ -1124,157 +1647,128 @@ const server = new Server(
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return {
     tools: [
+      // ========== NEW MONOLITHIC TOOLS (v3.0.0) ==========
       {
-        name: 'mlgym_auth_status',
-        description: 'ALWAYS CALL THIS FIRST! Check authentication status before any other operation.',
-        inputSchema: {
-          type: 'object',
-          properties: {}
-        }
-      },
-      {
-        name: 'mlgym_authenticate',
-        description: 'PHASE 1: Authentication ONLY. Get email, password, and existing account status in ONE interaction. Never ask for project details here!',
+        name: 'mlgym_deploy',
+        description: 'RECOMMENDED: Complete deployment workflow in one call. Automatically authenticates (uses cached token if available), analyzes project, creates GitLab repo, and deploys to Coolify. Just provide project details - the server handles everything else internally.',
         inputSchema: {
           type: 'object',
           properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project name (lowercase alphanumeric with hyphens, e.g., "my-app")',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            project_description: {
+              type: 'string',
+              description: 'Brief project description (min 10 characters)',
+              minLength: 10
+            },
             email: {
               type: 'string',
-              description: 'Email address',
+              description: 'Email for authentication (optional if already authenticated)',
               pattern: '^[^@]+@[^@]+\\.[^@]+$'
             },
             password: {
               type: 'string',
-              description: 'Password (min 8 characters)',
+              description: 'Password (optional if already authenticated, min 8 characters)',
               minLength: 8
             },
-            create_if_not_exists: {
-              type: 'boolean',
-              description: 'If true and login fails, attempt to create new account',
-              default: false
-            },
-            full_name: {
+            hostname: {
               type: 'string',
-              description: 'Full name (required only for new account creation)',
-              minLength: 2
+              description: 'Deployment hostname/subdomain (optional, defaults to project_name). Will be accessible at https://<hostname>.ezb.net',
+              pattern: '^[a-z][a-z0-9-]*[a-z0-9]$',
+              minLength: 3,
+              maxLength: 63
             },
-            accept_terms: {
-              type: 'boolean',
-              description: 'Accept terms and conditions (required only for new account creation)',
-              default: false
-            }
-          },
-          required: ['email', 'password']
-        }
-      },
-      {
-        name: 'mlgym_project_analyze',
-        description: 'PHASE 2: Analyze project to detect type, framework, and configuration. Call BEFORE creating project.',
-        inputSchema: {
-          type: 'object',
-          properties: {
             local_path: {
               type: 'string',
-              description: 'Local directory path (defaults to current directory)',
+              description: 'Local project directory path (optional, defaults to current directory)',
               default: '.'
+            },
+            project_type: {
+              type: 'string',
+              description: 'Override auto-detected project type (optional)',
+              enum: ['nodejs', 'python', 'static', 'go']
+            },
+            framework: {
+              type: 'string',
+              description: 'Override auto-detected framework (optional)',
+              enum: ['nextjs', 'express', 'react', 'vue', 'flask', 'fastapi', 'html']
+            },
+            package_manager: {
+              type: 'string',
+              description: 'Package manager for Node.js projects (optional, defaults to npm)',
+              enum: ['npm', 'yarn'],
+              default: 'npm'
             }
-          }
+          },
+          required: ['project_name', 'project_description']
         }
       },
       {
-        name: 'mlgym_project_status',
-        description: 'PHASE 2: Check if MLGym project exists in current directory.',
+        name: 'mlgym_status',
+        description: 'Check current authentication status and project configuration. Read-only operation that shows what is already set up.',
         inputSchema: {
           type: 'object',
           properties: {
             local_path: {
               type: 'string',
-              description: 'Local directory path (defaults to current directory)',
+              description: 'Local directory path to check (defaults to current directory)',
               default: '.'
             }
           }
         }
       },
+      // ========== LEGACY TOOLS (Re-enabled for specific use cases) ==========
       {
-        name: 'mlgym_project_init',
-        description: 'PHASE 2: Create project ONLY after checking project status. Never ask for email/password here - only project details!',
+        name: 'mlgym_user_create',
+        description: 'Create a new MLGym user account. All fields required: email, name, password, and accept_terms=true.',
         inputSchema: {
           type: 'object',
           properties: {
-            name: {
+            email: {
               type: 'string',
-              description: 'Project name (lowercase alphanumeric with hyphens)',
-              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
-              minLength: 3
+              description: 'User email address',
+              pattern: '^[^@]+@[^@]+\\.[^@]+$'
             },
-            description: {
+            name: {
               type: 'string',
-              description: 'Project description',
-              minLength: 10
-            },
-            enable_deployment: {
-              type: 'boolean',
-              description: 'Enable automatic deployment via Coolify',
-              default: true
+              description: 'User full name',
+              minLength: 2
             },
-            hostname: {
+            password: {
               type: 'string',
-              description: 'Hostname for deployment (required if deployment enabled, will be subdomain)',
-              pattern: '^[a-z][a-z0-9-]*[a-z0-9]$',
-              minLength: 3,
-              maxLength: 63
+              description: 'User password (minimum 8 characters)',
+              minLength: 8
             },
-            local_path: {
-              type: 'string',
-              description: 'Local directory path (defaults to current directory)',
-              default: '.'
+            accept_terms: {
+              type: 'boolean',
+              description: 'User must explicitly accept terms and conditions (must be true)'
             }
           },
-          required: ['name', 'description']
+          required: ['email', 'name', 'password', 'accept_terms']
         }
       },
       {
-        name: 'mlgym_project_prepare',
-        description: 'PHASE 2: Prepare project for deployment by generating Dockerfile and config files.',
+        name: 'mlgym_auth_login',
+        description: 'Login with existing user credentials to get authentication token.',
         inputSchema: {
           type: 'object',
           properties: {
-            local_path: {
-              type: 'string',
-              description: 'Local directory path (defaults to current directory)',
-              default: '.'
-            },
-            project_type: {
-              type: 'string',
-              description: 'Project type from analysis',
-              enum: ['nodejs', 'python', 'static', 'go', 'unknown']
-            },
-            framework: {
+            email: {
               type: 'string',
-              description: 'Framework from analysis',
-              enum: ['nextjs', 'express', 'react', 'vue', 'flask', 'fastapi', 'html', null]
+              description: 'Email address',
+              pattern: '^[^@]+@[^@]+\\.[^@]+$'
             },
-            package_manager: {
-              type: 'string',
-              description: 'Package manager for Node.js projects',
-              enum: ['npm', 'yarn'],
-              default: 'npm'
-            }
-          }
-        }
-      },
-      {
-        name: 'mlgym_smart_deploy',
-        description: 'RECOMMENDED: Smart deployment workflow that automatically analyzes, prepares, and guides you through the entire deployment process. Use this for new projects!',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            local_path: {
+            password: {
               type: 'string',
-              description: 'Local directory path (defaults to current directory)',
-              default: '.'
+              description: 'Password',
+              minLength: 8
             }
-          }
+          },
+          required: ['email', 'password']
         }
       }
     ]
@@ -1285,51 +1779,24 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
-  console.error(`Tool called: ${name}`);
+  console.error(`Tool called: ${name} (MCP v${CURRENT_VERSION})`);
 
   try {
     switch (name) {
-      case 'mlgym_auth_status':
-        return await checkAuthStatus();
-
-      case 'mlgym_authenticate':
-        return await authenticate(args);
-
-      case 'mlgym_project_analyze':
-        const analysis = await analyzeProject(args.local_path);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(analysis, null, 2)
-          }]
-        };
+      case 'mlgym_deploy':
+        return await deployProject(args);
 
-      case 'mlgym_project_status':
-        const projectStatus = await checkExistingProject(args.local_path);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(projectStatus, null, 2)
-          }]
-        };
-
-      case 'mlgym_project_init':
-        return await initProject(args);
+      case 'mlgym_status':
+        return await getStatus(args);
 
-      case 'mlgym_project_prepare':
-        const prepResult = await prepareProject(args);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(prepResult, null, 2)
-          }]
-        };
+      case 'mlgym_user_create':
+        return await createUser(args);
 
-      case 'mlgym_smart_deploy':
-        return await smartDeploy(args);
+      case 'mlgym_auth_login':
+        return await loginUser(args);
 
       default:
-        throw new Error(`Unknown tool: ${name}`);
+        throw new Error(`Unknown tool: ${name}. Available tools: mlgym_deploy, mlgym_status, mlgym_user_create, mlgym_auth_login`);
     }
   } catch (error) {
     console.error(`Tool execution failed:`, error);