mlgym-deploy 3.0.7 → 3.2.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 = '3.0.7';  // Fixed Dockerfile generation path bug
+const CURRENT_VERSION = '3.2.0';  // Added mlgym_deploy_logs tool for viewing deployment history
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -705,25 +705,38 @@ CMD ["/bin/sh"]`;
 async function prepareProject(args) {
   const { local_path = '.', project_type, framework, package_manager } = args;
   const absolutePath = path.resolve(local_path);
+  log.info('MCP >>> [prepareProject-func] Called with local_path:', local_path);
+  log.debug('MCP >>> [prepareProject-func] Resolved absolutePath:', absolutePath);
+  log.debug('MCP >>> [prepareProject-func] project_type:', project_type, 'framework:', framework);
 
   const actions = [];
 
   try {
     // Check if Dockerfile exists
     const dockerfilePath = path.join(absolutePath, 'Dockerfile');
+    log.debug('MCP >>> [prepareProject-func] Dockerfile path:', dockerfilePath);
     let dockerfileExists = false;
 
     try {
       await fs.access(dockerfilePath);
       dockerfileExists = true;
+      log.info('MCP >>> [prepareProject-func] Dockerfile already exists at', dockerfilePath);
       actions.push('Dockerfile already exists - skipping generation');
-    } catch {}
+    } catch {
+      log.info('MCP >>> [prepareProject-func] Dockerfile does not exist, will generate');
+    }
 
     // Generate Dockerfile if missing
     if (!dockerfileExists && project_type !== 'unknown') {
+      log.info('MCP >>> [prepareProject-func] Generating Dockerfile...');
       const dockerfile = generateDockerfile(project_type, framework, package_manager);
+      log.debug('MCP >>> [prepareProject-func] Generated Dockerfile length:', dockerfile.length, 'bytes');
+      log.info('MCP >>> [prepareProject-func] Writing Dockerfile to:', dockerfilePath);
       await fs.writeFile(dockerfilePath, dockerfile);
+      log.success('MCP >>> [prepareProject-func] ✅ Dockerfile written successfully!');
       actions.push(`Generated Dockerfile for ${project_type}/${framework || 'generic'}`);
+    } else if (project_type === 'unknown') {
+      log.warning('MCP >>> [prepareProject-func] Project type is unknown, skipping Dockerfile generation');
     }
 
     // Check/create .gitignore
@@ -950,6 +963,145 @@ async function smartDeploy(args) {
   }
 }
 
+// Deployment Strategy Detection (matches CLI logic)
+async function detectDeploymentStrategy(projectPath) {
+  const dockerfilePath = path.join(projectPath, 'Dockerfile');
+  const composePathYML = path.join(projectPath, 'docker-compose.yml');
+  const composePathYAML = path.join(projectPath, 'docker-compose.yaml');
+
+  const hasDockerfile = await fileExists(dockerfilePath);
+  const hasComposeYML = await fileExists(composePathYML);
+  const hasComposeYAML = await fileExists(composePathYAML);
+  const hasCompose = hasComposeYML || hasComposeYAML;
+  const composePath = hasComposeYML ? composePathYML : composePathYAML;
+
+  log.info(`MCP >>> [detectDeploymentStrategy] Dockerfile: ${hasDockerfile}, docker-compose: ${hasCompose}`);
+
+  // Case 1: Only Dockerfile
+  if (hasDockerfile && !hasCompose) {
+    log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (Dockerfile only)');
+    return { type: 'dockerfile', reason: 'Dockerfile only' };
+  }
+
+  // Case 2: Only docker-compose
+  if (!hasDockerfile && hasCompose) {
+    log.info('MCP >>> [detectDeploymentStrategy] Strategy: docker-compose (compose only)');
+    return { type: 'docker-compose', reason: 'docker-compose.yml only' };
+  }
+
+  // Case 3: Both exist - analyze docker-compose to decide
+  if (hasDockerfile && hasCompose) {
+    log.info('MCP >>> [detectDeploymentStrategy] Both files found, analyzing compose...');
+
+    try {
+      const { webServiceCount, usesLocalDockerfile, totalServiceCount } = await analyzeComposeFile(composePath);
+
+      log.info(`MCP >>> [analyzeCompose] Total services: ${totalServiceCount}, Web services: ${webServiceCount}, Uses local Dockerfile: ${usesLocalDockerfile}`);
+
+      // SIMPLE: Only 1 web service, no other services, uses local Dockerfile
+      // → docker-compose is just convenience wrapper
+      if (totalServiceCount === 1 && webServiceCount === 1 && usesLocalDockerfile) {
+        log.info('MCP >>> [detectDeploymentStrategy] Strategy: dockerfile (single web service)');
+        return { type: 'dockerfile', reason: 'docker-compose.yml only has web service (convenience wrapper for Dockerfile)' };
+      }
+
+      // COMPLEX: Multiple services (web + database, etc.)
+      // → MUST use docker-compose for orchestration
+      log.info('MCP >>> [detectDeploymentStrategy] Strategy: docker-compose (multi-service)');
+      return { type: 'docker-compose', reason: 'Application requires multiple services (web + database/cache/etc)' };
+    } catch (err) {
+      log.error('MCP >>> [detectDeploymentStrategy] Analysis failed, defaulting to docker-compose:', err.message);
+      return { type: 'docker-compose', reason: 'Multiple deployment files found' };
+    }
+  }
+
+  // Case 4: No deployment files
+  log.info('MCP >>> [detectDeploymentStrategy] Strategy: none (no deployment files)');
+  return { type: 'none', reason: 'No Dockerfile or docker-compose.yml found' };
+}
+
+// Analyze docker-compose.yml to determine deployment strategy
+async function analyzeComposeFile(composePath) {
+  const content = await fs.readFile(composePath, 'utf-8');
+  const lines = content.split('\n');
+
+  let webServiceCount = 0;
+  let totalServiceCount = 0;
+  let usesLocalDockerfile = false;
+  let inServicesSection = false;
+  let currentService = '';
+  let currentServiceIsWeb = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Detect services section
+    if (trimmed.startsWith('services:')) {
+      inServicesSection = true;
+      continue;
+    }
+
+    if (!inServicesSection) continue;
+
+    // End of services section
+    if (trimmed && !line.startsWith(' ') && !line.startsWith('\t')) {
+      inServicesSection = false;
+      break;
+    }
+
+    // New service definition (at 2-space or 1-tab indentation level)
+    if ((line.startsWith('  ') || line.startsWith('\t')) &&
+        trimmed.includes(':') &&
+        !trimmed.startsWith('-') &&
+        !trimmed.includes('image:') &&
+        !trimmed.includes('build:') &&
+        !trimmed.includes('ports:') &&
+        !trimmed.includes('expose:')) {
+
+      if (currentService) {
+        totalServiceCount++;
+        if (currentServiceIsWeb) {
+          webServiceCount++;
+        }
+      }
+
+      currentService = trimmed.split(':')[0].trim();
+      currentServiceIsWeb = false;
+      continue;
+    }
+
+    // Check if current service exposes web ports
+    if (trimmed.startsWith('ports:') || trimmed.startsWith('expose:')) {
+      currentServiceIsWeb = true;
+    }
+
+    // Check if service uses local Dockerfile
+    if (trimmed === 'build: .' || trimmed === 'build: ./') {
+      usesLocalDockerfile = true;
+    }
+  }
+
+  // Count last service
+  if (currentService) {
+    totalServiceCount++;
+    if (currentServiceIsWeb) {
+      webServiceCount++;
+    }
+  }
+
+  return { webServiceCount, usesLocalDockerfile, totalServiceCount };
+}
+
+// Helper to check if file exists
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // Initialize Project (requires authentication)
 async function initProject(args) {
   let { name, description, enable_deployment = true, hostname, local_path = '.' } = args;
@@ -1009,6 +1161,17 @@ async function initProject(args) {
   };
 
   if (enable_deployment) {
+    // Detect deployment strategy from local directory (like CLI does)
+    const absolutePath = path.resolve(local_path);
+    log.info(`MCP >>> [initProject] Detecting deployment strategy in: ${absolutePath}`);
+
+    const strategy = await detectDeploymentStrategy(absolutePath);
+    log.info(`MCP >>> [initProject] Detected strategy: ${strategy.type} - ${strategy.reason}`);
+    console.error(`🔍 Detected deployment strategy: ${strategy.type}`);
+    if (strategy.reason) {
+      console.error(`   Reason: ${strategy.reason}`);
+    }
+
     // Generate a secure webhook secret for deployments
     const webhookSecret = Array.from(
       crypto.getRandomValues(new Uint8Array(32)),
@@ -1016,10 +1179,14 @@ async function initProject(args) {
     ).join('');
 
     // Use FLAT structure exactly like CLI does - no nested deployment_info
+    // CRITICAL: Send deployment_type so backend doesn't try to detect from empty repo
     projectData.enable_deployment = true;
+    projectData.deployment_type = strategy.type;  // ← NEW: Send detected type!
     projectData.webhook_secret = webhookSecret;
     projectData.hostname = hostname;
     projectData.local_path = local_path;
+
+    log.info(`MCP >>> [initProject] Sending deployment_type: ${strategy.type} to backend`);
   }
 
   const result = await apiRequest('POST', '/api/v1/projects', projectData, true);
@@ -1121,44 +1288,59 @@ async function initProject(args) {
   }
 
   // Create initial commit and push (like CLI does)
+  log.info('MCP >>> [initProject] Starting git commit and push...');
+  log.debug('MCP >>> [initProject] Working directory:', absolutePath);
   const gitSteps = [];
   let pushSucceeded = false;
 
   try {
     // Check if there are any files to commit
+    log.info('MCP >>> [initProject] Checking git status...');
     const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd: absolutePath });
+    log.debug('MCP >>> [initProject] Git status output:', statusOutput.trim() || '(clean)');
 
     if (statusOutput.trim()) {
       // There are uncommitted changes
+      log.info('MCP >>> [initProject] Uncommitted changes detected, staging files...');
       gitSteps.push('Adding files to git');
       await execAsync('git add .', { cwd: absolutePath });
+      log.success('MCP >>> [initProject] Files staged (git add .)');
 
+      log.info('MCP >>> [initProject] Creating commit...');
       gitSteps.push('Creating initial commit');
       await execAsync('git commit -m "Initial MLGym deployment"', { cwd: absolutePath });
+      log.success('MCP >>> [initProject] Commit created');
     } else {
       // Check if there are any commits at all
+      log.info('MCP >>> [initProject] No uncommitted changes, checking for existing commits...');
       try {
         await execAsync('git rev-parse HEAD', { cwd: absolutePath });
+        log.info('MCP >>> [initProject] Repository already has commits');
         gitSteps.push('Repository already has commits');
       } catch {
         // No commits yet, create an initial one
+        log.warning('MCP >>> [initProject] No commits found, creating initial README...');
         gitSteps.push('Creating README for initial commit');
         const readmePath = path.join(absolutePath, 'README.md');
         if (!await fs.access(readmePath).then(() => true).catch(() => false)) {
           await fs.writeFile(readmePath, `# ${name}\n\n${description}\n\nDeployed with MLGym\n`);
+          log.info('MCP >>> [initProject] README.md created');
         }
         await execAsync('git add .', { cwd: absolutePath });
         await execAsync('git commit -m "Initial MLGym deployment"', { cwd: absolutePath });
+        log.success('MCP >>> [initProject] Initial commit created with README');
       }
     }
 
     // Push to trigger webhook and deployment
+    log.info('MCP >>> [initProject] Pushing to GitLab...');
+    log.debug('MCP >>> [initProject] Git remote URL:', gitUrl);
     gitSteps.push('Pushing to GitLab to trigger deployment');
     console.error('Executing: git push -u mlgym main');
     await execAsync('git push -u mlgym main', { cwd: absolutePath });
     gitSteps.push('✅ Successfully pushed to GitLab');
     pushSucceeded = true;
-    console.error('✅ Git push completed successfully');
+    log.success('MCP >>> [initProject] ✅ Git push completed successfully!');
 
   } catch (pushError) {
     console.error('❌ Git push failed:', pushError.message);
@@ -1534,27 +1716,35 @@ class DeploymentWorkflow {
   async prepareProject(localPath, projectType, framework, packageManager) {
     this.currentStep = 'preparation';
     this.addStep('prepare_project', 'running');
+    log.info('MCP >>> [prepareProject] Starting with localPath:', localPath);
 
     try {
       // Check if Dockerfile exists
       const analysis = this.projectAnalysis || await analyzeProject(localPath);
+      log.debug('MCP >>> [prepareProject] has_dockerfile:', analysis.has_dockerfile);
 
       if (analysis.has_dockerfile) {
+        log.info('MCP >>> [prepareProject] Dockerfile already exists, skipping generation');
         this.updateLastStep('skipped', 'Dockerfile already exists');
         return { skipped: true, reason: 'Dockerfile already exists' };
       }
 
       // Generate Dockerfile
+      log.info('MCP >>> [prepareProject] Generating Dockerfile...');
+      log.debug('MCP >>> [prepareProject] Type:', projectType || analysis.project_type, 'Framework:', framework || analysis.framework);
       const prepResult = await prepareProject({
         local_path: localPath,
         project_type: projectType || analysis.project_type,
         framework: framework || analysis.framework,
         package_manager: packageManager || 'npm'
       });
+      log.success('MCP >>> [prepareProject] Dockerfile generated successfully');
+      log.debug('MCP >>> [prepareProject] Actions:', prepResult.actions);
 
       this.updateLastStep('completed', prepResult.actions);
       return prepResult;
     } catch (error) {
+      log.error('MCP >>> [prepareProject] FAILED:', error.message);
       this.updateLastStep('failed', error.message);
       throw error;
     }
@@ -1631,13 +1821,21 @@ async function deployProject(args) {
     package_manager = 'npm'
   } = args;
 
+  log.info('MCP >>> Starting deployment workflow');
+  log.debug('MCP >>> Arguments:', { project_name, hostname, local_path, project_type, framework, package_manager });
+
   try {
     // Step 1: Ensure authenticated
+    log.info('MCP >>> STEP 1: Authenticating...');
     await workflow.ensureAuth(email, password);
+    log.success('MCP >>> STEP 1: Authentication complete');
 
     // Step 2: Check if project already exists
+    log.info('MCP >>> STEP 2: Checking for existing project in', local_path);
     const existing = await workflow.checkExisting(local_path);
     if (existing && existing.exists) {
+      log.warning('MCP >>> Project already exists:', existing.name);
+
       return {
         content: [{
           type: 'text',
@@ -1659,22 +1857,35 @@ async function deployProject(args) {
         }]
       };
     }
+    log.success('MCP >>> STEP 2: No existing project found, proceeding with deployment');
 
     // Step 3: Analyze project (auto-detect type and framework)
+    log.info('MCP >>> STEP 3: Analyzing project...');
     const analysis = await workflow.analyzeProject(local_path);
+    log.success('MCP >>> STEP 3: Analysis complete -', analysis.project_type, '/', analysis.framework);
+    log.debug('MCP >>> Detected files:', analysis.detected_files);
 
     // Step 4: Prepare project (generate Dockerfile if needed)
-    await workflow.prepareProject(local_path, project_type, framework, package_manager);
+    log.info('MCP >>> STEP 4: Preparing project (Dockerfile generation)...');
+    log.debug('MCP >>> Using local_path:', local_path);
+    const prepResult = await workflow.prepareProject(local_path, project_type, framework, package_manager);
+    log.success('MCP >>> STEP 4: Project preparation complete');
+    log.debug('MCP >>> Preparation actions:', prepResult);
 
     // Step 5: Create GitLab project and deploy
+    log.info('MCP >>> STEP 5: Creating GitLab project and deploying...');
+    log.debug('MCP >>> Project params:', { name: project_name, hostname: hostname || project_name, local_path });
     const deployResult = await workflow.createAndDeployProject({
       name: project_name,
       description: project_description,
       hostname: hostname || project_name,
       local_path
     });
+    log.success('MCP >>> STEP 5: Deployment complete!');
+    log.debug('MCP >>> Deploy result:', { project_id: deployResult.project?.id, deployment_url: deployResult.project?.deployment_url });
 
     // Success response
+    log.success('MCP >>> ✅ Full deployment workflow completed successfully!');
     return {
       content: [{
         type: 'text',
@@ -1773,6 +1984,121 @@ async function getStatus(args) {
   }
 }
 
+// Get deployment logs for a project
+async function getDeploymentLogs(args) {
+  const local_path = args.local_path || '.';
+  const depth = args.depth || 1;
+  const project_name = args.project_name;
+
+  log.info(`MCP >>> [getDeploymentLogs] Getting logs for project: ${project_name || 'auto-detect'}, depth: ${depth}`);
+
+  try {
+    // Check authentication
+    const auth = await loadAuth();
+    if (!auth.token) {
+      throw new Error('Authentication required. Please deploy or login first.');
+    }
+
+    // Determine project name
+    let projectName = project_name;
+    if (!projectName) {
+      // Try to get from git remote
+      const projectStatus = await checkExistingProject(local_path);
+      if (!projectStatus.exists) {
+        throw new Error('Project not found. Please specify project_name or run from a project directory with git remote.');
+      }
+      projectName = projectStatus.name;
+    }
+
+    log.info(`MCP >>> [getDeploymentLogs] Detected project name: ${projectName}`);
+
+    // Get project details from backend to get Coolify app UUID
+    const projectsResult = await apiRequest('GET', '/api/v1/projects', null, true);
+    if (!projectsResult.success) {
+      throw new Error(`Failed to get projects: ${projectsResult.error}`);
+    }
+
+    const project = projectsResult.data.projects?.find(p => p.name === projectName);
+    if (!project) {
+      throw new Error(`Project "${projectName}" not found in your account`);
+    }
+
+    if (!project.coolify_app_uuid) {
+      throw new Error(`Project "${projectName}" does not have deployment enabled`);
+    }
+
+    const appUUID = project.coolify_app_uuid;
+    log.info(`MCP >>> [getDeploymentLogs] Found Coolify app UUID: ${appUUID}`);
+
+    // Call User Agent API to get deployment logs
+    const userAgentURL = 'http://coolify.eu.ezb.net:9000';
+    const endpoint = `${userAgentURL}/applications/${appUUID}/deployment-logs?depth=${depth}`;
+
+    log.info(`MCP >>> [getDeploymentLogs] Calling User Agent: ${endpoint}`);
+
+    const response = await axios.get(endpoint, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    const logsData = response.data;
+    log.info(`MCP >>> [getDeploymentLogs] Retrieved ${logsData.count} deployment(s)`);
+
+    // Format the response
+    if (logsData.count === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'ok',
+            project_name: projectName,
+            app_uuid: appUUID,
+            count: 0,
+            message: 'No deployment logs found for this application. To create a deployment, push code to GitLab.'
+          }, null, 2)
+        }]
+      };
+    }
+
+    // Format deployments with readable timestamps
+    const formattedDeployments = logsData.deployments.map(dep => ({
+      id: dep.id,
+      status: dep.status,
+      created_at: new Date(dep.created_at).toISOString().replace('T', ' ').substring(0, 19),
+      updated_at: new Date(dep.updated_at).toISOString().replace('T', ' ').substring(0, 19),
+      output: dep.output || 'No logs available'
+    }));
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'ok',
+          project_name: projectName,
+          app_uuid: appUUID,
+          count: logsData.count,
+          deployments: formattedDeployments
+        }, null, 2)
+      }]
+    };
+
+  } catch (error) {
+    log.error(`MCP >>> [getDeploymentLogs] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: 'Make sure the project exists and has deployment enabled'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
 // Create the MCP server
 const server = new Server(
   {
@@ -1864,6 +2190,33 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           }
         }
       },
+      {
+        name: 'mlgym_deploy_logs',
+        description: 'View deployment history and logs for a project. Shows the last N deployments with their status, timestamps, and build logs.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project name (optional if in project directory with git remote)',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            depth: {
+              type: 'number',
+              description: 'Number of deployments to retrieve (1-10, default: 1)',
+              minimum: 1,
+              maximum: 10,
+              default: 1
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional, defaults to current directory)',
+              default: '.'
+            }
+          }
+        }
+      },
       // ========== LEGACY TOOLS (Re-enabled for specific use cases) ==========
       {
         name: 'mlgym_user_create',
@@ -1941,6 +2294,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = await getStatus(args);
         break;
 
+      case 'mlgym_deploy_logs':
+        log.info(`Retrieving deployment logs...`);
+        result = await getDeploymentLogs(args);
+        break;
+
       case 'mlgym_user_create':
         log.info(`Creating user account...`);
         result = await createUser(args);
@@ -1952,7 +2310,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
 
       default:
-        throw new Error(`Unknown tool: ${name}. Available tools: mlgym_deploy, mlgym_status, mlgym_user_create, mlgym_auth_login`);
+        throw new Error(`Unknown tool: ${name}. Available tools: mlgym_deploy, mlgym_status, mlgym_deploy_logs, mlgym_user_create, mlgym_auth_login`);
     }
 
     const duration = Date.now() - startTime;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mlgym-deploy",
-  "version": "3.0.7",
-  "description": "MCP server for MLGym - Fixed Dockerfile generation path bug",
+  "version": "3.2.0",
+  "description": "MCP server for MLGym - Added deployment logs viewer tool",
   "main": "index.js",
   "type": "module",
   "bin": {