mlgym-deploy 2.10.0 → 3.0.0

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.0';  // Monolithic workflow: reduced AI complexity, server-side orchestration
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -1107,6 +1107,342 @@ async function initProject(args) {
   };
 }
 
+// ============================================================================
+// 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,154 +1460,75 @@ 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!',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            email: {
-              type: 'string',
-              description: 'Email address',
-              pattern: '^[^@]+@[^@]+\\.[^@]+$'
-            },
-            password: {
-              type: 'string',
-              description: 'Password (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: {
-              type: 'string',
-              description: 'Full name (required only for new account creation)',
-              minLength: 2
-            },
-            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)',
-              default: '.'
-            }
-          }
-        }
-      },
-      {
-        name: 'mlgym_project_status',
-        description: 'PHASE 2: Check if MLGym project exists in current directory.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            local_path: {
-              type: 'string',
-              description: 'Local directory path (defaults to current directory)',
-              default: '.'
-            }
-          }
-        }
-      },
-      {
-        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_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: {
-            name: {
+            project_name: {
               type: 'string',
-              description: 'Project name (lowercase alphanumeric with hyphens)',
+              description: 'Project name (lowercase alphanumeric with hyphens, e.g., "my-app")',
               pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
               minLength: 3
             },
-            description: {
+            project_description: {
               type: 'string',
-              description: 'Project description',
+              description: 'Brief project description (min 10 characters)',
               minLength: 10
             },
-            enable_deployment: {
-              type: 'boolean',
-              description: 'Enable automatic deployment via Coolify',
-              default: true
+            email: {
+              type: 'string',
+              description: 'Email for authentication (optional if already authenticated)',
+              pattern: '^[^@]+@[^@]+\\.[^@]+$'
+            },
+            password: {
+              type: 'string',
+              description: 'Password (optional if already authenticated, min 8 characters)',
+              minLength: 8
             },
             hostname: {
               type: 'string',
-              description: 'Hostname for deployment (required if deployment enabled, will be subdomain)',
+              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
             },
             local_path: {
               type: 'string',
-              description: 'Local directory path (defaults to current directory)',
-              default: '.'
-            }
-          },
-          required: ['name', 'description']
-        }
-      },
-      {
-        name: 'mlgym_project_prepare',
-        description: 'PHASE 2: Prepare project for deployment by generating Dockerfile and config files.',
-        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: 'Project type from analysis',
-              enum: ['nodejs', 'python', 'static', 'go', 'unknown']
+              description: 'Override auto-detected project type (optional)',
+              enum: ['nodejs', 'python', 'static', 'go']
             },
             framework: {
               type: 'string',
-              description: 'Framework from analysis',
-              enum: ['nextjs', 'express', 'react', 'vue', 'flask', 'fastapi', 'html', null]
+              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',
+              description: 'Package manager for Node.js projects (optional, defaults to npm)',
               enum: ['npm', 'yarn'],
               default: 'npm'
             }
-          }
+          },
+          required: ['project_name', 'project_description']
         }
       },
       {
-        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!',
+        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: '.'
             }
           }
@@ -1285,51 +1542,18 @@ 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_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_project_prepare':
-        const prepResult = await prepareProject(args);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(prepResult, null, 2)
-          }]
-        };
+      case 'mlgym_deploy':
+        return await deployProject(args);
 
-      case 'mlgym_smart_deploy':
-        return await smartDeploy(args);
+      case 'mlgym_status':
+        return await getStatus(args);
 
       default:
-        throw new Error(`Unknown tool: ${name}`);
+        throw new Error(`Unknown tool: ${name}. Available tools: mlgym_deploy, mlgym_status`);
     }
   } catch (error) {
     console.error(`Tool execution failed:`, error);