mlgym-deploy 2.1.0 → 2.2.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

@@ -2019,10 +2019,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 +2069,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 +2113,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;

package/package.json

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