mlgym-deploy 2.3.5 → 2.4.0

package/index-v2.js

@@ -1,1062 +0,0 @@
-#!/usr/bin/env node
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from '@modelcontextprotocol/sdk/types.js';
-import axios from 'axios';
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-
-// Configuration
-const CONFIG = {
-  backend_url: process.env.GITLAB_BACKEND_URL || 'https://backend.eu.ezb.net',
-  gitlab_url: process.env.GITLAB_URL || 'https://git.mlgym.io',
-  coolify_url: process.env.COOLIFY_URL || 'https://coolify.eu.ezb.net',
-  config_file: path.join(os.homedir(), '.mlgym', 'config.json'),
-  mlgym_ini: path.join(os.homedir(), '.mlgym', 'mlgym.ini'),
-  terms_url: 'https://mlgym.io/terms',
-  privacy_url: 'https://mlgym.io/privacy',
-  docs_url: 'https://docs.mlgym.io'
-};
-
-// Available regions for deployment
-const REGIONS = {
-  'eu-central': {
-    name: 'Europe (Frankfurt)',
-    coolify_url: 'https://coolify.eu.ezb.net',
-    latency: 'Low for EU users'
-  },
-  'us-east': {
-    name: 'US East (Virginia)',
-    coolify_url: 'https://coolify.us-east.mlgym.io',
-    latency: 'Low for US East Coast'
-  },
-  'asia-pacific': {
-    name: 'Asia Pacific (Singapore)',
-    coolify_url: 'https://coolify.ap.mlgym.io',
-    latency: 'Low for APAC users'
-  }
-};
-
-// Session storage for multi-step flows
-const sessions = new Map();
-
-// Helper to check if file exists
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Helper to check if directory exists
-async function dirExists(dirPath) {
-  try {
-    const stats = await fs.stat(dirPath);
-    return stats.isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-// Helper to load user configuration
-async function loadUserConfig() {
-  try {
-    // First check for mlgym.ini (legacy format)
-    if (await fileExists(CONFIG.mlgym_ini)) {
-      const iniContent = await fs.readFile(CONFIG.mlgym_ini, 'utf8');
-      // Parse simple INI format
-      const config = {};
-      iniContent.split('\n').forEach(line => {
-        const [key, value] = line.split('=');
-        if (key && value) {
-          config[key.trim()] = value.trim();
-        }
-      });
-      return config;
-    }
-
-    // Check for JSON config
-    if (await fileExists(CONFIG.config_file)) {
-      const data = await fs.readFile(CONFIG.config_file, 'utf8');
-      return JSON.parse(data);
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// Helper to save user configuration
-async function saveUserConfig(config) {
-  const dir = path.dirname(CONFIG.config_file);
-  await fs.mkdir(dir, { recursive: true });
-
-  // Save as JSON
-  await fs.writeFile(
-    CONFIG.config_file,
-    JSON.stringify(config, null, 2)
-  );
-
-  // Also save as INI for backwards compatibility
-  const iniContent = Object.entries(config)
-    .map(([key, value]) => `${key}=${value}`)
-    .join('\n');
-  await fs.writeFile(CONFIG.mlgym_ini, iniContent);
-}
-
-// Detect framework from project files
-async function detectFramework(projectPath) {
-  const checks = [
-    {
-      file: 'package.json',
-      detect: async (content) => {
-        const pkg = JSON.parse(content);
-        if (pkg.dependencies?.next || pkg.devDependencies?.next) return 'nextjs';
-        if (pkg.dependencies?.react || pkg.devDependencies?.react) return 'react';
-        if (pkg.dependencies?.vue || pkg.devDependencies?.vue) return 'vue';
-        if (pkg.dependencies?.express) return 'express';
-        if (pkg.dependencies?.fastify) return 'fastify';
-        return 'node';
-      }
-    },
-    {
-      file: 'composer.json',
-      detect: async (content) => {
-        const composer = JSON.parse(content);
-        if (composer.require?.['laravel/framework']) return 'laravel';
-        if (composer.require?.['symfony/framework-bundle']) return 'symfony';
-        return 'php';
-      }
-    },
-    {
-      file: 'requirements.txt',
-      detect: async (content) => {
-        if (content.includes('django')) return 'django';
-        if (content.includes('flask')) return 'flask';
-        if (content.includes('fastapi')) return 'fastapi';
-        return 'python';
-      }
-    },
-    {
-      file: 'Cargo.toml',
-      detect: () => 'rust'
-    },
-    {
-      file: 'go.mod',
-      detect: () => 'go'
-    }
-  ];
-
-  for (const check of checks) {
-    const filePath = path.join(projectPath, check.file);
-    if (await fileExists(filePath)) {
-      if (check.detect) {
-        const content = await fs.readFile(filePath, 'utf8');
-        return await check.detect(content);
-      }
-    }
-  }
-
-  return 'static'; // Default for static HTML sites
-}
-
-// Generate Dockerfile based on 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 name from various sources
-async function detectProjectName(localPath) {
-  // Try package.json first
-  try {
-    const packagePath = path.join(localPath, 'package.json');
-    const packageData = await fs.readFile(packagePath, 'utf8');
-    const packageJson = JSON.parse(packageData);
-    if (packageJson.name) {
-      return packageJson.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-+|-+$/g, '');
-    }
-  } catch {}
-
-  // Try composer.json
-  try {
-    const composerPath = path.join(localPath, 'composer.json');
-    const composerData = await fs.readFile(composerPath, 'utf8');
-    const composerJson = JSON.parse(composerData);
-    if (composerJson.name) {
-      const parts = composerJson.name.split('/');
-      return parts[parts.length - 1].toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    }
-  } catch {}
-
-  // Fall back to directory name
-  const absolutePath = path.resolve(localPath);
-  return path.basename(absolutePath).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-+|-+$/g, '');
-}
-
-// API client helper
-async function apiRequest(method, endpoint, data = null, useAuth = true) {
-  const config = {
-    method,
-    url: `${CONFIG.backend_url}${endpoint}`,
-    headers: {
-      'Content-Type': 'application/json'
-    }
-  };
-
-  if (useAuth) {
-    const userConfig = await loadUserConfig();
-    // Handle both 'token' and 'auth_token' field names
-    const authToken = userConfig?.token || userConfig?.auth_token;
-    if (authToken) {
-      config.headers['Authorization'] = `Bearer ${authToken}`;
-    }
-  }
-
-  if (data) {
-    config.data = data;
-  }
-
-  try {
-    const response = await axios(config);
-    return { success: true, data: response.data };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.response?.data?.message || error.message,
-      status: error.response?.status
-    };
-  }
-}
-
-// Create MCP server
-const server = new Server(
-  {
-    name: 'gitlab-backend-mcp',
-    version: '3.0.0',
-  },
-  {
-    capabilities: {
-      tools: {}
-    }
-  }
-);
-
-// Tool definitions
-const TOOLS = [
-  {
-    name: 'mlgym_get_details',
-    description: 'Get current MLGym user details, authentication status, and configuration. Use this tool when user asks about their MLGym account, login status, or configuration details.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        verbose: {
-          type: 'boolean',
-          description: 'Include detailed information about projects and resources',
-          default: false
-        }
-      }
-    }
-  },
-  {
-    name: 'mlgym_deploy',
-    description: 'Deploy this project to the cloud. Use this tool when user wants to deploy, publish, or host their project online. Handles all deployment tasks including Docker setup, GitLab integration, and cloud hosting on MLGym platform.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          enum: ['analyze', 'register', 'configure', 'deploy'],
-          description: 'Action to perform: analyze (scan project), register (create account), configure (set up project), deploy (final deployment)'
-        },
-        session_id: {
-          type: 'string',
-          description: 'Session ID for multi-step flow (provided after initial analysis)'
-        },
-        local_path: {
-          type: 'string',
-          description: 'Local directory path of the project',
-          default: '.'
-        },
-        // For registration step
-        user_email: {
-          type: 'string',
-          description: 'Email for new account registration'
-        },
-        user_name: {
-          type: 'string',
-          description: 'Full name for new account registration'
-        },
-        accept_terms: {
-          type: 'boolean',
-          description: 'Accept MLGym terms and conditions'
-        },
-        // For configuration step
-        confirm_dockerfile: {
-          type: 'boolean',
-          description: 'Confirm generated Dockerfile'
-        },
-        custom_dockerfile: {
-          type: 'string',
-          description: 'Custom Dockerfile content if not using generated one'
-        },
-        // For deployment step
-        region: {
-          type: 'string',
-          enum: ['eu-central', 'us-east', 'asia-pacific'],
-          description: 'Deployment region'
-        },
-        confirm_deployment: {
-          type: 'boolean',
-          description: 'Final confirmation to deploy'
-        }
-      },
-      required: ['action']
-    }
-  }
-];
-
-// Handle list tools request
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: TOOLS
-  };
-});
-
-// Handle tool execution
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  switch (name) {
-    case 'mlgym_get_details':
-      return await getUserDetails(args);
-    case 'mlgym_deploy':
-      return await smartDeploy(args);
-    default:
-      throw new Error(`Unknown tool: ${name}`);
-  }
-});
-
-// Get user details function
-async function getUserDetails(args = {}) {
-  const { verbose = false } = args;
-
-  try {
-    // Check for MLGym configuration
-    const config = await loadUserConfig();
-
-    // Handle both 'token' and 'auth_token' field names
-    const authToken = config?.auth_token || config?.token;
-
-    if (!config || !authToken) {
-      return {
-        content: [{
-          type: 'text',
-          text: `❌ No MLGym account found
-
-You are not currently logged into MLGym. To get started:
-
-1. Deploy a project using the deploy button
-2. Or check your ~/.mlgym/config.json file
-
-MLGym provides:
-- Free GitLab repository hosting
-- Automated CI/CD pipelines
-- Cloud deployment with custom domains
-- SSL certificates
-- Container orchestration
-
-Visit https://mlgym.io to learn more.`
-        }]
-      };
-    }
-
-    // Get user information from backend
-    try {
-      const response = await axios.get(`${CONFIG.backend_url}/api/v1/user`, {
-        headers: {
-          'Authorization': `Bearer ${authToken}`
-        }
-      });
-
-      const user = response.data;
-
-      let details = `✅ MLGym Account Details
-
-👤 User Information:
-- Email: ${user.email}
-- Name: ${user.name}
-- User ID: ${user.id}
-- GitLab ID: ${user.gitlab_id || 'Not set'}
-- Admin: ${user.is_admin ? 'Yes' : 'No'}
-- Created: ${new Date(user.created_at).toLocaleDateString()}`;
-
-      if (verbose) {
-        // Get projects
-        try {
-          const projectsResponse = await axios.get(`${CONFIG.backend_url}/api/v1/projects`, {
-            headers: {
-              'Authorization': `Bearer ${authToken}`
-            }
-          });
-
-          // API returns array directly, not wrapped in an object
-          const projects = Array.isArray(projectsResponse.data) ? projectsResponse.data :
-                          (projectsResponse.data.projects || []);
-
-          if (projects.length > 0) {
-            details += `\n\n📦 Projects (${projects.length}):`;
-            projects.forEach(project => {
-              details += `\n- ${project.name}`;
-              if (project.deployment_url) {
-                details += ` → ${project.deployment_url}`;
-              }
-            });
-          } else {
-            details += `\n\n📦 No projects yet`;
-          }
-        } catch (err) {
-          // Projects endpoint might not be available
-          console.error('Could not fetch projects:', err.message);
-        }
-      }
-
-      details += `\n\n🔗 Configuration:
-- Config file: ${CONFIG.config_file}
-- Backend: ${CONFIG.backend_url}
-- GitLab: ${CONFIG.gitlab_url}`;
-
-      return {
-        content: [{
-          type: 'text',
-          text: details
-        }]
-      };
-
-    } catch (apiError) {
-      if (apiError.response?.status === 401) {
-        return {
-          content: [{
-            type: 'text',
-            text: `⚠️ Authentication expired
-
-Your MLGym session has expired. Please:
-1. Deploy a new project to refresh your authentication
-2. Or manually update your token in ~/.mlgym/config.json
-
-Error: ${apiError.message}`
-          }]
-        };
-      }
-
-      return {
-        content: [{
-          type: 'text',
-          text: `❌ Error fetching user details
-
-Could not connect to MLGym backend.
-- Backend URL: ${CONFIG.backend_url}
-- Error: ${apiError.message}
-
-Your config file exists at: ${CONFIG.config_file}`
-        }]
-      };
-    }
-
-  } catch (error) {
-    return {
-      content: [{
-        type: 'text',
-        text: `❌ Error reading MLGym configuration
-
-${error.message}
-
-Please check:
-1. ~/.mlgym/config.json exists
-2. You have proper permissions
-3. The file contains valid JSON`
-      }]
-    };
-  }
-}
-
-// Smart deployment flow
-async function smartDeploy(args) {
-  const { action, session_id, local_path = '.' } = args;
-
-  switch (action) {
-    case 'analyze':
-      return await analyzeProject(local_path);
-
-    case 'register':
-      return await registerUser(args);
-
-    case 'configure':
-      return await configureProject(session_id, args);
-
-    case 'deploy':
-      return await deployProject(session_id, args);
-
-    default:
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify({
-            error: 'Invalid action. Use: analyze, register, configure, or deploy'
-          }, null, 2)
-        }]
-      };
-  }
-}
-
-// Step 1: Analyze project
-async function analyzeProject(localPath) {
-  console.error(`Analyzing project at: ${localPath}`);
-
-  const sessionId = crypto.randomBytes(16).toString('hex');
-
-  // Detect project details
-  const projectName = await detectProjectName(localPath);
-  const framework = await detectFramework(localPath);
-  const hasDockerfile = await fileExists(path.join(localPath, 'Dockerfile'));
-  const hasTests = await dirExists(path.join(localPath, 'tests')) ||
-                   await dirExists(path.join(localPath, '__tests__')) ||
-                   await fileExists(path.join(localPath, 'test'));
-
-  // Check if user is already registered
-  const userConfig = await loadUserConfig();
-  // Handle both 'token' and 'auth_token' field names
-  const hasAccount = !!(userConfig?.token || userConfig?.auth_token);
-
-  // Store session data
-  const sessionData = {
-    sessionId,
-    localPath,
-    projectName,
-    framework,
-    hasDockerfile,
-    hasTests,
-    hasAccount,
-    userEmail: userConfig?.email
-  };
-  sessions.set(sessionId, sessionData);
-
-  // Prepare response
-  const response = {
-    status: 'analysis_complete',
-    session_id: sessionId,
-    project: {
-      name: projectName,
-      path: localPath,
-      framework,
-      has_dockerfile: hasDockerfile,
-      has_tests: hasTests
-    }
-  };
-
-  if (!hasAccount) {
-    response.next_step = 'registration_required';
-    response.mlgym_info = {
-      description: 'MLGym is a cloud deployment platform that provides:',
-      features: [
-        '✅ Automatic CI/CD with GitLab integration',
-        '✅ Container-based deployments with Coolify',
-        '✅ Global CDN and SSL certificates',
-        '✅ Automatic scaling and monitoring',
-        '✅ One-click deployments from your IDE'
-      ],
-      pricing: 'Free tier available with 1 project and 1GB storage',
-      terms_url: CONFIG.terms_url,
-      privacy_url: CONFIG.privacy_url,
-      docs_url: CONFIG.docs_url
-    };
-    response.action_required = {
-      message: 'To continue, you need to create a free MLGym account.',
-      next_action: 'mlgym_deploy with action: "register"',
-      required_fields: ['user_email', 'user_name', 'accept_terms']
-    };
-  } else {
-    response.next_step = 'configuration';
-    response.user = {
-      email: userConfig.email,
-      authenticated: true
-    };
-
-    if (!hasDockerfile) {
-      const dockerfile = generateDockerfile(framework, projectName);
-      response.suggested_dockerfile = {
-        content: dockerfile,
-        framework_detected: framework,
-        message: 'No Dockerfile found. Generated one based on detected framework.'
-      };
-    }
-
-    response.action_required = {
-      message: hasDockerfile ?
-        'Project has Dockerfile. Ready to configure deployment.' :
-        'Review the generated Dockerfile above.',
-      next_action: 'mlgym_deploy with action: "configure"',
-      required_fields: hasDockerfile ? [] : ['confirm_dockerfile']
-    };
-  }
-
-  return {
-    content: [{
-      type: 'text',
-      text: JSON.stringify(response, null, 2)
-    }]
-  };
-}
-
-// Step 2: Register user
-async function registerUser(args) {
-  const { user_email, user_name, accept_terms, session_id } = args;
-
-  if (!accept_terms) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'You must accept the terms and conditions to continue.',
-          terms_url: CONFIG.terms_url
-        }, null, 2)
-      }]
-    };
-  }
-
-  if (!user_email || !user_name) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Email and name are required for registration.'
-        }, null, 2)
-      }]
-    };
-  }
-
-  console.error(`Registering user: ${user_email}`);
-
-  // Generate secure password
-  const password = crypto.randomBytes(12).toString('base64').replace(/[^a-zA-Z0-9]/g, '') + '!Aa1';
-
-  // Create user via API
-  const result = await apiRequest('POST', '/api/v1/users', {
-    email: user_email,
-    name: user_name,
-    password
-  }, false);
-
-  if (!result.success) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: `Registration failed: ${result.error}`
-        }, null, 2)
-      }]
-    };
-  }
-
-  // Save user configuration
-  const userConfig = {
-    email: user_email,
-    name: user_name,
-    token: result.data.token,
-    user_id: result.data.id,
-    gitlab_id: result.data.gitlab_id,
-    created: new Date().toISOString()
-  };
-  await saveUserConfig(userConfig);
-
-  // Update session
-  if (session_id && sessions.has(session_id)) {
-    const session = sessions.get(session_id);
-    session.hasAccount = true;
-    session.userEmail = user_email;
-  }
-
-  // Generate Dockerfile if we have session context
-  let dockerfileSection = {};
-  if (session_id && sessions.has(session_id)) {
-    const session = sessions.get(session_id);
-    if (!session.hasDockerfile) {
-      const dockerfile = generateDockerfile(session.framework, session.projectName);
-      dockerfileSection = {
-        suggested_dockerfile: {
-          content: dockerfile,
-          framework_detected: session.framework,
-          message: 'Generated Dockerfile for your project.'
-        }
-      };
-    }
-  }
-
-  return {
-    content: [{
-      type: 'text',
-      text: JSON.stringify({
-        status: 'registration_successful',
-        message: 'Welcome to MLGym! Your account has been created.',
-        user: {
-          email: user_email,
-          name: user_name,
-          gitlab_id: result.data.gitlab_id
-        },
-        credentials: {
-          note: 'Save these credentials securely:',
-          email: user_email,
-          password,
-          gitlab_url: CONFIG.gitlab_url
-        },
-        ...dockerfileSection,
-        next_step: 'configuration',
-        action_required: {
-          message: 'Account created. Now configure your project for deployment.',
-          next_action: 'mlgym_deploy with action: "configure"',
-          session_id,
-          required_fields: dockerfileSection.suggested_dockerfile ? ['confirm_dockerfile'] : []
-        }
-      }, null, 2)
-    }]
-  };
-}
-
-// Step 3: Configure project
-async function configureProject(sessionId, args) {
-  if (!sessionId || !sessions.has(sessionId)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Invalid session. Please start with action: "analyze"'
-        }, null, 2)
-      }]
-    };
-  }
-
-  const session = sessions.get(sessionId);
-  const { confirm_dockerfile, custom_dockerfile } = args;
-
-  // Create/update Dockerfile if needed
-  if (!session.hasDockerfile) {
-    if (!confirm_dockerfile && !custom_dockerfile) {
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: 'Please confirm the generated Dockerfile or provide a custom one.'
-          }, null, 2)
-        }]
-      };
-    }
-
-    const dockerfilePath = path.join(session.localPath, 'Dockerfile');
-    const dockerfileContent = custom_dockerfile || generateDockerfile(session.framework, session.projectName);
-
-    await fs.writeFile(dockerfilePath, dockerfileContent);
-    console.error('Created Dockerfile at:', dockerfilePath);
-
-    // Create nginx.conf for React apps
-    if (session.framework === 'react' && !custom_dockerfile) {
-      const nginxPath = path.join(session.localPath, 'nginx.conf');
-      await fs.writeFile(nginxPath, generateNginxConf());
-      console.error('Created nginx.conf for React app');
-    }
-  }
-
-  // Update session
-  session.configured = true;
-  session.dockerfileCreated = !session.hasDockerfile;
-
-  return {
-    content: [{
-      type: 'text',
-      text: JSON.stringify({
-        status: 'configuration_complete',
-        message: 'Project configured successfully.',
-        project: {
-          name: session.projectName,
-          framework: session.framework,
-          dockerfile: session.dockerfileCreated ? 'Created' : 'Existing'
-        },
-        deployment_regions: REGIONS,
-        next_step: 'deployment',
-        action_required: {
-          message: 'Choose deployment region and confirm deployment.',
-          next_action: 'mlgym_deploy with action: "deploy"',
-          session_id: sessionId,
-          required_fields: ['region', 'confirm_deployment']
-        }
-      }, null, 2)
-    }]
-  };
-}
-
-// Step 4: Deploy project
-async function deployProject(sessionId, args) {
-  if (!sessionId || !sessions.has(sessionId)) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Invalid session. Please start with action: "analyze"'
-        }, null, 2)
-      }]
-    };
-  }
-
-  const session = sessions.get(sessionId);
-  const { region, confirm_deployment } = args;
-
-  if (!confirm_deployment) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Deployment cancelled. Set confirm_deployment: true to proceed.'
-        }, null, 2)
-      }]
-    };
-  }
-
-  if (!region || !REGIONS[region]) {
-    return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Invalid region. Choose from: ' + Object.keys(REGIONS).join(', ')
-        }, null, 2)
-      }]
-    };
-  }
-
-  console.error(`Deploying project ${session.projectName} to ${region}`);
-
-  // Create project via API
-  const projectData = {
-    name: session.projectName,
-    description: `Deployed via MLGym MCP from ${session.framework} project`,
-    visibility: 'private',
-    enable_deployment: true,
-    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}`,
-          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 = [
-    'git init',
-    `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'
-  ];
-
-  // Clear session
-  sessions.delete(sessionId);
-
-  return {
-    content: [{
-      type: 'text',
-      text: JSON.stringify({
-        status: 'deployment_successful',
-        message: '🚀 Project deployed successfully!',
-        project: {
-          name: project.name,
-          url: project.web_url,
-          ssh_url: project.ssh_url_to_repo,
-          region: REGIONS[region].name
-        },
-        deployment: {
-          domain: `${session.projectName}.${region}.mlgym.app`,
-          status: 'initializing',
-          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
-        },
-        monitoring: {
-          dashboard: `${CONFIG.backend_url}/projects/${project.id}`,
-          logs: `${CONFIG.coolify_url}/projects/${project.id}/logs`
-        }
-      }, null, 2)
-    }]
-  };
-}
-
-// Start the server
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('MLGym Smart Deploy MCP Server v3.0.0 started');
-}
-
-main().catch((error) => {
-  console.error('Server error:', error);
-  process.exit(1);
-});