mlgym-deploy 2.0.1 → 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

@@ -16,6 +16,65 @@ import crypto from 'crypto';
 
 const execAsync = promisify(exec);
 
+// Current version of this MCP server
+const CURRENT_VERSION = '2.1.0';
+const PACKAGE_NAME = 'mlgym-deploy';
+
+// Version check state
+let versionCheckResult = null;
+let lastVersionCheck = 0;
+const VERSION_CHECK_INTERVAL = 3600000; // Check once per hour
+
+// Helper to check for updates
+async function checkForUpdates() {
+  try {
+    // Check if we've recently checked
+    if (Date.now() - lastVersionCheck < VERSION_CHECK_INTERVAL && versionCheckResult) {
+      return versionCheckResult;
+    }
+
+    // Get latest version from npm
+    const { stdout } = await execAsync(`npm view ${PACKAGE_NAME} version`);
+    const latestVersion = stdout.trim();
+
+    // Compare versions
+    const isUpdateAvailable = latestVersion !== CURRENT_VERSION;
+
+    versionCheckResult = {
+      current: CURRENT_VERSION,
+      latest: latestVersion,
+      updateAvailable: isUpdateAvailable,
+      lastChecked: new Date().toISOString()
+    };
+
+    lastVersionCheck = Date.now();
+
+    // Log to stderr if update available (visible in Cursor logs)
+    if (isUpdateAvailable) {
+      console.error(`\n╔════════════════════════════════════════════════════════════════╗`);
+      console.error(`║ MLGym MCP Server Update Available!                                ║`);
+      console.error(`║                                                                    ║`);
+      console.error(`║ Current version: ${CURRENT_VERSION.padEnd(49)} ║`);
+      console.error(`║ Latest version:  ${latestVersion.padEnd(49)} ║`);
+      console.error(`║                                                                    ║`);
+      console.error(`║ To update, run: npm install -g ${PACKAGE_NAME}@latest              ║`);
+      console.error(`╚════════════════════════════════════════════════════════════════╝\n`);
+    }
+
+    return versionCheckResult;
+  } catch (error) {
+    // Silent fail - don't disrupt normal operation
+    console.error('Version check failed (network may be offline):', error.message);
+    return {
+      current: CURRENT_VERSION,
+      latest: 'unknown',
+      updateAvailable: false,
+      error: error.message,
+      lastChecked: new Date().toISOString()
+    };
+  }
+}
+
 // Helper to generate random password
 function generateRandomPassword() {
   const chars = 'ABCDEFGHJKLMNPQRSTWXYZabcdefghjkmnpqrstwxyz23456789!@#$%^&*';
@@ -195,6 +254,35 @@ async function apiRequest(method, endpoint, data = null, useAuth = true) {
   }
 }
 
+// Global error and status tracking
+let lastError = null;
+let lastOperation = null;
+let operationHistory = [];
+const MAX_HISTORY = 20;
+
+// Helper to track operations
+function trackOperation(operation, success = true, error = null) {
+  const entry = {
+    operation,
+    success,
+    timestamp: new Date().toISOString(),
+    error: error ? error.message || error : null
+  };
+
+  lastOperation = entry;
+  if (!success && error) {
+    lastError = {
+      ...entry,
+      stack: error.stack || null
+    };
+  }
+
+  operationHistory.unshift(entry);
+  if (operationHistory.length > MAX_HISTORY) {
+    operationHistory = operationHistory.slice(0, MAX_HISTORY);
+  }
+}
+
 // Create MCP server
 const server = new Server(
   {
@@ -210,6 +298,119 @@ const server = new Server(
 
 // Tool definitions
 const TOOLS = [
+  {
+    name: 'mlgym_git_configure',
+    description: 'Check and configure git user settings (required before making commits)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: {
+          type: 'string',
+          description: 'Email to use for git commits (defaults to MLGym user email if logged in)',
+          pattern: '^[^@]+@[^@]+\\.[^@]+$'
+        },
+        name: {
+          type: 'string',
+          description: 'Name to use for git commits (defaults to email username if not provided)'
+        },
+        check_only: {
+          type: 'boolean',
+          description: 'If true, only check current configuration without changing it',
+          default: false
+        }
+      }
+    }
+  },
+  {
+    name: 'mlgym_debug_last_error',
+    description: 'Get detailed error information from the last failed operation',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_stack: {
+          type: 'boolean',
+          description: 'Include stack trace if available',
+          default: true
+        }
+      }
+    }
+  },
+  {
+    name: 'mlgym_debug_status',
+    description: 'Get current system status and recent operations',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        verbose: {
+          type: 'boolean',
+          description: 'Include detailed status information',
+          default: false
+        }
+      }
+    }
+  },
+  {
+    name: 'mlgym_debug_logs',
+    description: 'View recent logs from backend, User Agent, or Coolify',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: {
+          type: 'string',
+          enum: ['backend', 'user-agent', 'coolify', 'all'],
+          description: 'Which service logs to retrieve',
+          default: 'all'
+        },
+        lines: {
+          type: 'integer',
+          description: 'Number of log lines to retrieve',
+          default: 50,
+          minimum: 10,
+          maximum: 500
+        },
+        filter: {
+          type: 'string',
+          description: 'Filter logs by keyword (e.g., "error", "deployment", "user")'
+        }
+      }
+    }
+  },
+  {
+    name: 'mlgym_debug_deployment',
+    description: 'Check detailed deployment status and troubleshoot deployment issues',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project_id: {
+          type: 'integer',
+          description: 'Project ID to check deployment status for'
+        },
+        deployment_uuid: {
+          type: 'string',
+          description: 'Specific deployment UUID to investigate'
+        },
+        check_queue: {
+          type: 'boolean',
+          description: 'Check Coolify deployment queue status',
+          default: true
+        }
+      }
+    }
+  },
+  {
+    name: 'mlgym_version_check',
+    description: 'Check for MCP server updates and get version information',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        check_now: {
+          type: 'boolean',
+          description: 'Force immediate version check (bypasses cache)',
+          default: false
+        }
+      }
+    }
+  },
   {
     name: 'mlgym_user_create',
     description: 'Create a new user with GitLab, Coolify, and SSH key setup. IMPORTANT: You must explicitly ask the user for their email, full name, password, and terms acceptance.',
@@ -241,7 +442,7 @@ const TOOLS = [
   },
   {
     name: 'mlgym_project_init',
-    description: 'Initialize and deploy a project with GitLab repository and Coolify deployment. IMPORTANT: You must explicitly ask the user for project name and description.',
+    description: 'Initialize and deploy a project with GitLab repository and Coolify deployment. IMPORTANT: You must explicitly ask the user for project name, description, and deployment URL if deployment is enabled.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -261,6 +462,13 @@ const TOOLS = [
           description: 'Enable Coolify deployment with webhooks (ask user yes/no)',
           default: true
         },
+        hostname: {
+          type: 'string',
+          description: 'Custom hostname for deployment (REQUIRED if enable_deployment is true: ask user for their preferred hostname, will be used as subdomain)',
+          pattern: '^[a-z][a-z0-9-]*[a-z0-9]$',
+          minLength: 3,
+          maxLength: 63
+        },
         local_path: {
           type: 'string',
           description: 'Local directory path to initialize as git repository',
@@ -955,6 +1163,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
   switch (name) {
+    case 'mlgym_git_configure':
+      return await configureGit(args);
+
+    case 'mlgym_debug_last_error':
+      return await debugLastError(args);
+
+    case 'mlgym_debug_status':
+      return await debugStatus(args);
+
+    case 'mlgym_debug_logs':
+      return await debugLogs(args);
+
+    case 'mlgym_debug_deployment':
+      return await debugDeployment(args);
+
+    case 'mlgym_version_check':
+      return await versionCheck(args);
+
     case 'mlgym_user_create':
       return await createUser(args);
 
@@ -1138,6 +1364,342 @@ async function generateSSHKeyPair(email) {
   }
 }
 
+// Tool implementation: Debug Last Error
+async function debugLastError(args) {
+  const { include_stack = true } = args;
+
+  if (!lastError) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'info',
+          message: 'No errors recorded',
+          last_operation: lastOperation || 'None'
+        }, null, 2)
+      }]
+    };
+  }
+
+  const response = {
+    status: 'error',
+    error: {
+      operation: lastError.operation,
+      message: lastError.error,
+      timestamp: lastError.timestamp
+    }
+  };
+
+  if (include_stack && lastError.stack) {
+    response.error.stack = lastError.stack;
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Debug Status
+async function debugStatus(args) {
+  const { verbose = false } = args;
+
+  // Check authentication status
+  const auth = await loadAuth();
+  const isAuthenticated = !!auth.token;
+
+  const response = {
+    status: 'info',
+    authentication: {
+      logged_in: isAuthenticated,
+      user: isAuthenticated ? auth.email : null
+    },
+    last_operation: lastOperation || { message: 'No operations recorded' },
+    recent_operations: operationHistory.slice(0, verbose ? 10 : 5).map(op => ({
+      operation: op.operation,
+      success: op.success,
+      timestamp: op.timestamp,
+      error: op.error
+    }))
+  };
+
+  if (verbose) {
+    response.backend_url = process.env.GITLAB_BACKEND_URL || 'https://backend.eu.ezb.net';
+    response.gitlab_url = process.env.GITLAB_URL || 'https://git.mlgym.io';
+    response.coolify_url = process.env.COOLIFY_URL || 'https://coolify.eu.ezb.net';
+    response.error_count = operationHistory.filter(op => !op.success).length;
+    response.success_count = operationHistory.filter(op => op.success).length;
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Debug Logs
+async function debugLogs(args) {
+  const { source = 'all', lines = 50, filter } = args;
+
+  // Since we're in an MCP server, we can't directly access remote logs
+  // But we can provide instructions on how to check them
+  const instructions = {
+    status: 'info',
+    message: 'Log viewing instructions',
+    sources: {}
+  };
+
+  if (source === 'all' || source === 'backend') {
+    instructions.sources.backend = {
+      description: 'GitLab Backend Server logs',
+      commands: [
+        'ssh -i ~/.ssh/id_rsa_chka05 root@backend.eu.ezb.net',
+        'docker logs gitlab-admin-server --tail ' + lines,
+        filter ? `docker logs gitlab-admin-server 2>&1 | grep -i "${filter}" | tail -${lines}` : null
+      ].filter(Boolean)
+    };
+  }
+
+  if (source === 'all' || source === 'user-agent') {
+    instructions.sources.user_agent = {
+      description: 'Coolify User Agent logs',
+      commands: [
+        'ssh -i ~/.ssh/id_rsa_chka05 root@coolify.eu.ezb.net',
+        'docker logs coolify-user-agent --tail ' + lines,
+        filter ? `docker logs coolify-user-agent 2>&1 | grep -i "${filter}" | tail -${lines}` : null
+      ].filter(Boolean)
+    };
+  }
+
+  if (source === 'all' || source === 'coolify') {
+    instructions.sources.coolify = {
+      description: 'Coolify platform logs',
+      commands: [
+        'ssh -i ~/.ssh/id_rsa_chka05 root@coolify.eu.ezb.net',
+        'docker logs coolify --tail ' + lines,
+        filter ? `docker logs coolify 2>&1 | grep -i "${filter}" | tail -${lines}` : null
+      ].filter(Boolean)
+    };
+  }
+
+  instructions.note = 'The AI assistant should execute these commands to retrieve logs for debugging';
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(instructions, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Debug Deployment
+async function debugDeployment(args) {
+  const { project_id, deployment_uuid, check_queue = true } = args;
+
+  const response = {
+    status: 'info',
+    deployment_debugging: {}
+  };
+
+  // Get authentication
+  const auth = await loadAuth();
+  if (!auth.token) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Not authenticated. Login required to check deployments.'
+        }, null, 2)
+      }]
+    };
+  }
+
+  if (project_id) {
+    // Get project deployment status
+    try {
+      const result = await apiRequest('GET', `/api/v1/projects/${project_id}/deployments?limit=5`);
+      response.deployment_debugging.project_deployments = result.success ? result.data : { error: result.error };
+    } catch (error) {
+      response.deployment_debugging.project_deployments = { error: error.message };
+    }
+  }
+
+  if (deployment_uuid) {
+    response.deployment_debugging.specific_deployment = {
+      uuid: deployment_uuid,
+      check_commands: [
+        'Check deployment status in Coolify database:',
+        `ssh -i ~/.ssh/id_rsa_chka05 root@coolify.eu.ezb.net`,
+        `docker exec coolify-db psql -U coolify -d coolify -c "SELECT * FROM application_deployment_queues WHERE deployment_uuid = '${deployment_uuid}';"`,
+        '',
+        'Check if deployment is stuck in queue:',
+        `docker exec coolify sh -c "cd /var/www/html && php artisan check:deployment-queue"`
+      ]
+    };
+  }
+
+  if (check_queue) {
+    response.deployment_debugging.queue_status = {
+      description: 'Commands to check Coolify deployment queue',
+      commands: [
+        'Check recent deployments:',
+        `ssh -i ~/.ssh/id_rsa_chka05 root@coolify.eu.ezb.net`,
+        `docker exec coolify-db psql -U coolify -d coolify -c "SELECT id, application_id, deployment_uuid, status, created_at FROM application_deployment_queues ORDER BY created_at DESC LIMIT 10;"`,
+        '',
+        'Check if Horizon queue processor is running:',
+        `docker exec coolify sh -c "cd /var/www/html && php artisan horizon:status"`,
+        '',
+        'Try to manually process queue:',
+        `docker exec coolify sh -c "cd /var/www/html && php artisan queue:work --once"`
+      ]
+    };
+  }
+
+  response.common_issues = [
+    'Deployment stuck in "queued" status: Coolify queue processor not picking up jobs',
+    'Authentication errors: SSH keys not properly configured',
+    'Build failures: Check Dockerfile or build configuration',
+    'Network issues: Verify GitLab repository is accessible'
+  ];
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Version Check
+async function versionCheck(args) {
+  const { check_now = false } = args;
+
+  // Force check if requested
+  if (check_now) {
+    lastVersionCheck = 0;
+  }
+
+  // Check for updates
+  const versionInfo = await checkForUpdates();
+
+  const response = {
+    status: 'success',
+    version: {
+      current: versionInfo.current,
+      latest: versionInfo.latest,
+      update_available: versionInfo.updateAvailable,
+      last_checked: versionInfo.lastChecked
+    }
+  };
+
+  if (versionInfo.updateAvailable) {
+    response.update_instructions = {
+      message: '🔄 A new version of MLGym MCP Server is available!',
+      current_version: versionInfo.current,
+      latest_version: versionInfo.latest,
+      commands: [
+        'To update globally:',
+        `npm install -g ${PACKAGE_NAME}@latest`,
+        '',
+        'Or update to a specific version:',
+        `npm install -g ${PACKAGE_NAME}@${versionInfo.latest}`,
+        '',
+        'After updating, restart Cursor IDE to load the new version.'
+      ],
+      changelog_url: `https://www.npmjs.com/package/${PACKAGE_NAME}?activeTab=versions`
+    };
+  } else {
+    response.message = '✅ You are running the latest version of MLGym MCP Server';
+  }
+
+  if (versionInfo.error) {
+    response.note = `Version check had issues: ${versionInfo.error}`;
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response, null, 2)
+    }]
+  };
+}
+
+// Tool implementation: Configure Git
+async function configureGit(args) {
+  const { email, name, check_only = false } = args;
+
+  // Try to get email from auth if not provided
+  let gitEmail = email;
+  let gitName = name;
+
+  if (!gitEmail && !check_only) {
+    // Try to get from authenticated user
+    const auth = await loadAuth();
+    if (auth.token && auth.email) {
+      gitEmail = auth.email;
+      gitName = gitName || auth.email.split('@')[0];
+    }
+  }
+
+  // If just checking, return current configuration
+  if (check_only) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'info',
+          message: 'Git configuration check',
+          instructions: [
+            'Run: git config --global user.email',
+            'Run: git config --global user.name',
+            'If not set, configure with:',
+            `git config --global user.email "${gitEmail || 'your-email@example.com'}"`,
+            `git config --global user.name "${gitName || 'Your Name'}"`,
+            '',
+            'IMPORTANT: Git must be configured before making any commits.'
+          ]
+        }, null, 2)
+      }]
+    };
+  }
+
+  // Return configuration instructions
+  if (!gitEmail) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Email is required for git configuration',
+          solution: 'Either provide email parameter or login with mlgym_auth_login first'
+        }, null, 2)
+      }]
+    };
+  }
+
+  gitName = gitName || gitEmail.split('@')[0];
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify({
+        status: 'success',
+        message: 'Git configuration instructions',
+        commands: [
+          `git config --global user.email "${gitEmail}"`,
+          `git config --global user.name "${gitName}"`
+        ],
+        note: 'The AI assistant should execute these commands to configure git before making any commits'
+      }, null, 2)
+    }]
+  };
+}
+
 // Tool implementation: Create User
 async function createUser(args) {
   let { email, name, password, accept_terms } = args;
@@ -1216,6 +1778,8 @@ async function createUser(args) {
     console.error(`SSH key generated: ${privateKeyPath}`);
 
     // Create user via backend API with SSH key
+    trackOperation('user_create', true, null);
+
     const result = await apiRequest('POST', '/api/v1/users', {
       email,
       name,
@@ -1224,6 +1788,7 @@ async function createUser(args) {
     }, false);
 
     if (!result.success) {
+      trackOperation('user_create', false, new Error(result.error || 'User creation failed'));
       return {
         content: [{
           type: 'text',
@@ -1353,22 +1918,46 @@ async function detectProjectName(localPath) {
 
 // Tool implementation: Initialize Project
 async function initProject(args) {
-  let { name, description, enable_deployment = true, local_path = '.' } = args;
+  let { name, description, enable_deployment = true, hostname, local_path = '.' } = args;
+
+  // Start tracking this operation
+  const operationId = `init-project-${Date.now()}`;
 
   // Validate required fields are provided
   if (!name || !description) {
+    const error = {
+      status: 'error',
+      message: 'Project name and description are required and must be provided by user',
+      required_fields: {
+        name: name ? '✓ provided' : '✗ missing - must be provided by user',
+        description: description ? '✓ provided' : '✗ missing - must be provided by user'
+      },
+      note: 'Auto-detection is disabled. User must explicitly provide project details.'
+    };
+    trackOperation('mlgym_project_init', operationId, 'failed', error.message, { args, error });
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Project name and description are required and must be provided by user',
-          required_fields: {
-            name: name ? '✓ provided' : '✗ missing - must be provided by user',
-            description: description ? '✓ provided' : '✗ missing - must be provided by user'
-          },
-          note: 'Auto-detection is disabled. User must explicitly provide project details.'
-        }, null, 2)
+        text: JSON.stringify(error, null, 2)
+      }]
+    };
+  }
+
+  // Validate hostname if deployment is enabled
+  if (enable_deployment && !hostname) {
+    const error = {
+      status: 'error',
+      message: 'Hostname is required when deployment is enabled',
+      required_fields: {
+        hostname: '✗ missing - must be provided by user (will be used as subdomain)'
+      },
+      note: 'Please provide a unique hostname for your deployment (e.g., "myapp" for myapp.ezb.net)'
+    };
+    trackOperation('mlgym_project_init', operationId, 'failed', error.message, { args, error });
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(error, null, 2)
       }]
     };
   }
@@ -1378,10 +1967,12 @@ async function initProject(args) {
   // Check authentication
   const auth = await loadAuth();
   if (!auth.token) {
+    const errorMsg = 'Not authenticated. Please create a user first with mlgym_user_create';
+    trackOperation('mlgym_project_init', operationId, 'failed', errorMsg, { args });
     return {
       content: [{
         type: 'text',
-        text: 'Error: Not authenticated. Please create a user first with mlgym_user_create'
+        text: `Error: ${errorMsg}`
       }]
     };
   }
@@ -1395,16 +1986,19 @@ async function initProject(args) {
     description,
     visibility: 'private',
     enable_deployment: enable_deployment,
-    webhook_secret: webhookSecret
+    webhook_secret: webhookSecret,
+    hostname: hostname || null
   };
 
   const result = await apiRequest('POST', '/api/v1/projects', projectData);
 
   if (!result.success) {
+    const errorMsg = `Failed to create project: ${result.error}`;
+    trackOperation('mlgym_project_init', operationId, 'failed', errorMsg, { args, projectData, response: result });
     return {
       content: [{
         type: 'text',
-        text: `Failed to create project: ${result.error}`
+        text: errorMsg
       }]
     };
   }
@@ -1425,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',
@@ -1438,12 +2069,19 @@ 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'
     };
   }
 
   // Add git commands for local setup
+  // First ensure git is configured
   response.next_steps = [
+    '# First, ensure git is configured (check with: git config --list | grep user)',
+    '# If not configured, run:',
+    `git config --global user.email "${auth.email}"`,
+    `git config --global user.name "${auth.email.split('@')[0]}"`,
+    '# Then initialize and push the repository:',
     `cd ${local_path}`,
     'git init',
     `git remote add origin ${project.ssh_url_to_repo}`,
@@ -1452,6 +2090,11 @@ async function initProject(args) {
     'git push -u origin main'
   ];
 
+  response.important_note = 'IMPORTANT: Ensure git is configured with user.email and user.name before committing. The AI should check this first and configure if needed.';
+
+  // Track successful operation
+  trackOperation('mlgym_project_init', operationId, 'success', `Project ${name} created successfully`, { args, response });
+
   return {
     content: [{
       type: 'text',
@@ -1470,10 +2113,187 @@ 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;
 
+  // Start tracking this operation
+  const operationId = `recover-user-${Date.now()}`;
+
   // Clean up any expired PINs first
   await cleanupExpiredPINs();
 
@@ -1492,6 +2312,9 @@ async function recoverUser(args) {
 
     console.error(`Recovery PIN generated for ${email}: ${generatedPIN}`);
 
+    // Track PIN generation
+    trackOperation('mlgym_user_recover', operationId, 'success', `Recovery PIN generated for ${email}`, { args: { email }, stage: 'pin_generation' });
+
     // In production, this would send an actual email
     // For now, we'll include it in the response for testing
     return {
@@ -1513,13 +2336,15 @@ async function recoverUser(args) {
     const stored = await loadPIN(email);
 
     if (!stored) {
+      const error = {
+        status: 'error',
+        message: 'No recovery request found. Please request a new PIN.'
+      };
+      trackOperation('mlgym_user_recover', operationId, 'failed', error.message, { args: { email }, stage: 'pin_verification' });
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: 'No recovery request found. Please request a new PIN.'
-          }, null, 2)
+          text: JSON.stringify(error, null, 2)
         }]
       };
     }
@@ -1527,13 +2352,15 @@ async function recoverUser(args) {
     // Check if PIN expired (10 minutes)
     if (Date.now() - stored.timestamp > 10 * 60 * 1000) {
       await deletePIN(email);
+      const error = {
+        status: 'error',
+        message: 'PIN has expired. Please request a new one.'
+      };
+      trackOperation('mlgym_user_recover', operationId, 'failed', error.message, { args: { email }, stage: 'pin_verification' });
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: 'PIN has expired. Please request a new one.'
-          }, null, 2)
+          text: JSON.stringify(error, null, 2)
         }]
       };
     }
@@ -1541,13 +2368,15 @@ async function recoverUser(args) {
     // Check attempts
     if (stored.attempts >= 3) {
       await deletePIN(email);
+      const error = {
+        status: 'error',
+        message: 'Too many failed attempts. Please request a new PIN.'
+      };
+      trackOperation('mlgym_user_recover', operationId, 'failed', error.message, { args: { email }, stage: 'pin_verification' });
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: 'Too many failed attempts. Please request a new PIN.'
-          }, null, 2)
+          text: JSON.stringify(error, null, 2)
         }]
       };
     }
@@ -4107,14 +4936,19 @@ async function getDeploymentStatus(args) {
 async function triggerDeployment(args) {
   const { project_id, environment = 'production' } = args;
 
+  // Start tracking this operation
+  const operationId = `trigger-deployment-${Date.now()}`;
+
   if (!project_id) {
+    const error = {
+      status: 'error',
+      message: 'project_id is required'
+    };
+    trackOperation('mlgym_deployments_trigger', operationId, 'failed', error.message, { args });
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'project_id is required'
-        }, null, 2)
+        text: JSON.stringify(error, null, 2)
       }]
     };
   }
@@ -4124,33 +4958,40 @@ async function triggerDeployment(args) {
   // Check authentication
   const auth = await loadAuth();
   if (!auth.token) {
+    const error = {
+      status: 'error',
+      message: 'Not authenticated. Please login first with mlgym_auth_login'
+    };
+    trackOperation('mlgym_deployments_trigger', operationId, 'failed', error.message, { args });
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Not authenticated. Please login first with mlgym_auth_login'
-        }, null, 2)
+        text: JSON.stringify(error, null, 2)
       }]
     };
   }
 
   try {
     // Trigger deployment via backend API
-    const result = await apiRequest('POST', '/api/v1/deployments/trigger', {
-      project_id,
-      environment
-    });
+    // Backend expects project_id (integer) and optional trigger field
+    const deploymentData = {
+      project_id: parseInt(project_id), // Ensure it's an integer
+      trigger: 'initial' // Use 'initial' like the CLI does, not 'environment'
+    };
+
+    const result = await apiRequest('POST', '/api/v1/deployments/trigger', deploymentData);
 
     if (!result.success) {
+      const error = {
+        status: 'error',
+        message: result.error || 'Failed to trigger deployment',
+        details: 'Project may not have deployment enabled or webhook configured'
+      };
+      trackOperation('mlgym_deployments_trigger', operationId, 'failed', error.message, { args, deploymentData, response: result });
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: result.error || 'Failed to trigger deployment',
-            details: 'Project may not have deployment enabled or webhook configured'
-          }, null, 2)
+          text: JSON.stringify(error, null, 2)
         }]
       };
     }
@@ -4171,6 +5012,9 @@ async function triggerDeployment(args) {
       ]
     };
 
+    // Track successful operation
+    trackOperation('mlgym_deployments_trigger', operationId, 'success', `Deployment triggered for project ${project_id}`, { args, response });
+
     return {
       content: [{
         type: 'text',
@@ -4178,14 +5022,16 @@ async function triggerDeployment(args) {
       }]
     };
   } catch (error) {
+    const errorDetails = {
+      status: 'error',
+      message: 'Failed to trigger deployment',
+      error: error.message
+    };
+    trackOperation('mlgym_deployments_trigger', operationId, 'failed', error.message, { args, error: errorDetails });
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Failed to trigger deployment',
-          error: error.message
-        }, null, 2)
+        text: JSON.stringify(errorDetails, null, 2)
       }]
     };
   }
@@ -4267,14 +5113,19 @@ async function listProjects(args) {
 async function loginUser(args) {
   const { email, password } = args;
 
+  // Start tracking this operation
+  const operationId = `login-user-${Date.now()}`;
+
   if (!email || !password) {
+    const error = {
+      status: 'error',
+      message: 'Email and password are required'
+    };
+    trackOperation('mlgym_auth_login', operationId, 'failed', error.message, { args: { email } }); // Don't log password
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Email and password are required'
-        }, null, 2)
+        text: JSON.stringify(error, null, 2)
       }]
     };
   }
@@ -4289,14 +5140,16 @@ async function loginUser(args) {
     }, false);
 
     if (!result.success) {
+      const error = {
+        status: 'error',
+        message: result.error || 'Login failed',
+        details: 'Invalid email or password'
+      };
+      trackOperation('mlgym_auth_login', operationId, 'failed', error.message, { args: { email }, response: result });
       return {
         content: [{
           type: 'text',
-          text: JSON.stringify({
-            status: 'error',
-            message: result.error || 'Login failed',
-            details: 'Invalid email or password'
-          }, null, 2)
+          text: JSON.stringify(error, null, 2)
         }]
       };
     }
@@ -4326,6 +5179,9 @@ async function loginUser(args) {
       ]
     };
 
+    // Track successful operation
+    trackOperation('mlgym_auth_login', operationId, 'success', `User ${email} logged in successfully`, { args: { email }, response });
+
     return {
       content: [{
         type: 'text',
@@ -4333,14 +5189,16 @@ async function loginUser(args) {
       }]
     };
   } catch (error) {
+    const errorDetails = {
+      status: 'error',
+      message: 'Login failed',
+      error: error.message
+    };
+    trackOperation('mlgym_auth_login', operationId, 'failed', error.message, { args: { email }, error: errorDetails });
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          status: 'error',
-          message: 'Login failed',
-          error: error.message
-        }, null, 2)
+        text: JSON.stringify(errorDetails, null, 2)
       }]
     };
   }
@@ -5249,7 +6107,12 @@ async function replicateProject(args) {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('GitLab Backend MCP Server v2.0.0 started');
+  console.error(`GitLab Backend MCP Server v${CURRENT_VERSION} started`);
+
+  // Check for updates in the background (don't block startup)
+  setTimeout(async () => {
+    await checkForUpdates();
+  }, 2000); // Check after 2 seconds
 }
 
 main().catch((error) => {

package/package.json

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