mlgym-deploy 3.2.2 → 3.3.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.2.2';  // Added automatic validation and fixing for docker-compose and Dockerfile
+const CURRENT_VERSION = '3.3.0';  // Added 6 new tools: health check, domain, deployment commands, manual deploy, options, rollback
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -1072,17 +1072,17 @@ function validateAndFixDockerCompose(content) {
         const [external, internal] = portEntry.split(':').map(p => p.trim());
         const webPorts = ['80', '8080', '3000', '4000', '5000', '8000', '9000'];
 
-        if (webPorts.includes(internal)) {
+        if (webPorts.includes(internal) && external !== '80') {
           issues.push({
             line: i + 1,
             service: currentService,
             issue: `Port mapping "${external}:${internal}" not allowed`,
-            fix: 'Use port "80" only'
+            fix: `Use "80:${internal}" instead`
           });
 
-          // Fix the line
-          fixed[i] = line.replace(trimmed, '- "80"');
-          fixes.push(`Fixed ${currentService}: ${external}:${internal} → 80`);
+          // Fix the line - preserve internal port
+          fixed[i] = line.replace(trimmed, `- "80:${internal}"`);
+          fixes.push(`Fixed ${currentService}: ${external}:${internal} → 80:${internal}`);
         }
       }
     } else if (inPortsSection && !trimmed.startsWith('-')) {
@@ -2311,6 +2311,702 @@ async function getDeploymentLogs(args) {
   }
 }
 
+// Set environment variables for an application
+async function setEnvironmentVariables(args) {
+  try {
+    const {project_name, variables, local_path = '.'} = args;
+
+    log.info(`MCP >>> [setEnvironmentVariables] Setting environment variables for ${project_name || 'project'}`);
+    log.debug(`Variables to set:`, JSON.stringify(Object.keys(variables), null, 2));
+
+    // Ensure authentication
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    log.debug(`Using JWT token: ${auth.jwt_token.substring(0, 20)}...`);
+
+    // Determine project name
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      // Try to get project name from git remote
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) {
+          finalProjectName = match[1];
+          log.debug(`Detected project name from git remote: ${finalProjectName}`);
+        }
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository with remote configured');
+      }
+    }
+
+    log.info(`Setting environment variables for project: ${finalProjectName}`);
+
+    // Get application UUID from backend
+    const backendUrl = `${CONFIG.backend_url}/api/v1/projects/${finalProjectName}`;
+    log.debug(`Fetching project details from: ${backendUrl}`);
+
+    const projectResponse = await axios.get(backendUrl, {
+      headers: {
+        'Authorization': `Bearer ${auth.jwt_token}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    if (!projectResponse.data || !projectResponse.data.application_uuid) {
+      throw new Error(`Project ${finalProjectName} not found or has no application`);
+    }
+
+    const appUUID = projectResponse.data.application_uuid;
+    log.debug(`Application UUID: ${appUUID}`);
+
+    // Call User Agent to set environment variables
+    const userAgentUrl = 'http://coolify.eu.ezb.net:9000/applications/' + appUUID + '/environment-variables';
+    log.debug(`Calling User Agent: ${userAgentUrl}`);
+
+    const envResponse = await axios.post(userAgentUrl, {
+      variables: variables
+    }, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Environment variables set successfully`);
+    log.debug(`Response:`, JSON.stringify(envResponse.data, null, 2));
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          variables_set: envResponse.data.variables_set || Object.keys(variables),
+          count: envResponse.data.count || Object.keys(variables).length,
+          message: `Successfully set ${Object.keys(variables).length} environment variable(s) for ${finalProjectName}`,
+          next_steps: [
+            'Environment variables are now set for both build-time and runtime',
+            'If you need to trigger a rebuild with new variables, use mlgym_deploy',
+            'Variables will be available in your application as process.env.VARIABLE_NAME'
+          ]
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [setEnvironmentVariables] Error: ${error.message}`);
+    if (error.response) {
+      log.error(`Response status: ${error.response.status}`);
+      log.error(`Response data:`, JSON.stringify(error.response.data, null, 2));
+    }
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Helper function to get application UUID from project name
+async function getApplicationUUID(projectName, auth) {
+  const backendUrl = `${CONFIG.backend_url}/api/v1/projects/${projectName}`;
+  log.debug(`Fetching project details from: ${backendUrl}`);
+
+  const projectResponse = await axios.get(backendUrl, {
+    headers: {
+      'Authorization': `Bearer ${auth.jwt_token}`,
+      'Content-Type': 'application/json'
+    }
+  });
+
+  if (!projectResponse.data || !projectResponse.data.application_uuid) {
+    throw new Error(`Project ${projectName} not found or has no application`);
+  }
+
+  return projectResponse.data.application_uuid;
+}
+
+// Set health check configuration
+async function setHealthCheck(args) {
+  try {
+    const {project_name, local_path = '.', ...healthConfig} = args;
+
+    log.info(`MCP >>> [setHealthCheck] Configuring health check for ${project_name || 'project'}`);
+
+    // Ensure authentication
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    // Determine project name
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+    log.debug(`Application UUID: ${appUUID}`);
+
+    // Call User Agent to set health check
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/health-check`;
+    const response = await axios.post(userAgentUrl, healthConfig, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Health check configured successfully`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          health_check: healthConfig,
+          message: `Health check ${healthConfig.enabled ? 'enabled' : 'disabled'} for ${finalProjectName}`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [setHealthCheck] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Set custom domain
+async function setDomain(args) {
+  try {
+    const {project_name, domain, local_path = '.'} = args;
+
+    log.info(`MCP >>> [setDomain] Setting domain for ${project_name || 'project'}`);
+
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/domain`;
+    const response = await axios.post(userAgentUrl, {domain}, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Domain set successfully: ${domain}`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          domain: response.data.domain,
+          message: `Domain updated to ${response.data.domain}`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [setDomain] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Set deployment commands
+async function setDeploymentCommands(args) {
+  try {
+    const {project_name, local_path = '.', ...commands} = args;
+
+    log.info(`MCP >>> [setDeploymentCommands] Setting deployment commands for ${project_name || 'project'}`);
+
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/deployment-commands`;
+    const response = await axios.post(userAgentUrl, commands, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Deployment commands set successfully`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          commands: commands,
+          message: `Deployment commands updated for ${finalProjectName}`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [setDeploymentCommands] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Manually trigger deployment
+async function manualDeploy(args) {
+  try {
+    const {project_name, local_path = '.'} = args;
+
+    log.info(`MCP >>> [manualDeploy] Triggering manual deployment for ${project_name || 'project'}`);
+
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/deploy-manual`;
+    const response = await axios.post(userAgentUrl, {}, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Manual deployment triggered successfully`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          deployment_uuid: response.data.deployment_uuid,
+          deployment_status: response.data.status,
+          message: `Manual deployment triggered for ${finalProjectName}. Use mlgym_deploy_logs to monitor progress.`,
+          next_steps: [
+            'Deployment is queued and will start shortly',
+            'Use mlgym_deploy_logs to view deployment progress',
+            'Check application URL once deployment completes'
+          ]
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [manualDeploy] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Set application options
+async function setOptions(args) {
+  try {
+    const {project_name, local_path = '.', ...options} = args;
+
+    log.info(`MCP >>> [setOptions] Setting options for ${project_name || 'project'}`);
+
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/options`;
+    const response = await axios.post(userAgentUrl, options, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Options set successfully`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          options: options,
+          message: `Application options updated for ${finalProjectName}`
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [setOptions] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and you are authenticated'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Rollback to previous deployment
+async function rollback(args) {
+  try {
+    const {project_name, deployment_id, local_path = '.'} = args;
+
+    log.info(`MCP >>> [rollback] Rolling back ${project_name || 'project'}`);
+
+    let auth = await loadAuth();
+    if (!auth || !auth.jwt_token) {
+      throw new Error('Not authenticated. Please run mlgym_deploy or mlgym_auth_login first');
+    }
+
+    let finalProjectName = project_name;
+    if (!finalProjectName) {
+      try {
+        const {stdout} = await execAsync('git remote get-url origin', {cwd: local_path});
+        const match = stdout.match(/\/([^\/]+)\.git/);
+        if (match) finalProjectName = match[1];
+      } catch (error) {
+        throw new Error('project_name is required when not in a git repository');
+      }
+    }
+
+    const appUUID = await getApplicationUUID(finalProjectName, auth);
+
+    const userAgentUrl = `http://coolify.eu.ezb.net:9000/applications/${appUUID}/rollback`;
+    const requestBody = deployment_id ? {deployment_id} : {};
+    const response = await axios.post(userAgentUrl, requestBody, {
+      headers: {
+        'Authorization': 'Bearer 1|Jkztb5qPptwRKgtocfbT2TLjp8WGJG1SkPE4DzLt4c5d600f',
+        'Content-Type': 'application/json'
+      }
+    });
+
+    log.success(`Rollback triggered successfully`);
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'success',
+          project_name: finalProjectName,
+          application_uuid: appUUID,
+          rollback_to_deployment: response.data.rollback_to_deployment,
+          commit: response.data.commit,
+          deployment_uuid: response.data.deployment_uuid,
+          message: `Rollback deployment queued for ${finalProjectName}. Use mlgym_deploy_logs to monitor progress.`,
+          next_steps: [
+            'Rollback deployment is queued',
+            'Use mlgym_deploy_logs to view deployment progress',
+            'Application will revert to previous version once deployed'
+          ]
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    log.error(`MCP >>> [rollback] Error: ${error.message}`);
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          error: error.message,
+          hint: error.response?.data?.error || 'Make sure the project exists and has previous deployments'
+        }, null, 2)
+      }]
+    };
+  }
+}
+
+// Display help with all available tools
+async function showHelp(args) {
+  const helpText = `
+╔═══════════════════════════════════════════════════════════════════════╗
+║                    MLGym MCP Tools v${CURRENT_VERSION}                          ║
+║            Complete Deployment Platform for GitLab + Coolify          ║
+╚═══════════════════════════════════════════════════════════════════════╝
+
+📦 DEPLOYMENT TOOLS
+───────────────────────────────────────────────────────────────────────
+
+🚀 mlgym_deploy
+   Complete deployment workflow - auth, analyze, create repo, and deploy in one call.
+
+   Usage:
+     mlgym_deploy({
+       project_name: "my-app",
+       project_description: "My application",
+       email: "user@example.com",     // optional if already authenticated
+       password: "password123"         // optional if already authenticated
+     })
+
+📊 mlgym_status
+   Check authentication status and project configuration.
+
+   Usage:
+     mlgym_status({local_path: "."})
+
+📝 mlgym_deploy_logs
+   View deployment history and build logs.
+
+   Usage:
+     mlgym_deploy_logs({
+       project_name: "my-app",
+       depth: 3                        // number of deployments to retrieve
+     })
+
+⚙️  CONFIGURATION TOOLS
+───────────────────────────────────────────────────────────────────────
+
+🔧 mlgym_set_env_vars
+   Set environment variables (DATABASE_URL, API keys, etc.)
+
+   Usage:
+     mlgym_set_env_vars({
+       project_name: "my-app",
+       variables: {
+         DATABASE_URL: "postgresql://...",
+         API_KEY: "secret123"
+       }
+     })
+
+❤️  mlgym_set_health_check
+   Configure health checks to monitor application availability.
+
+   Usage:
+     mlgym_set_health_check({
+       project_name: "my-app",
+       enabled: true,
+       path: "/health",
+       method: "GET",
+       return_code: 200,
+       interval: 5
+     })
+
+🌐 mlgym_set_domain
+   Set custom domain/FQDN for your application.
+
+   Usage:
+     mlgym_set_domain({
+       project_name: "my-app",
+       domain: "myapp.example.com"
+     })
+
+📜 mlgym_set_deployment_commands
+   Configure pre-deployment and post-deployment commands.
+
+   Usage:
+     mlgym_set_deployment_commands({
+       project_name: "my-app",
+       pre_command: "npm run migrate",
+       post_command: "npm run seed"
+     })
+
+⚙️  mlgym_set_options
+   Configure application options (build cache, etc.)
+
+   Usage:
+     mlgym_set_options({
+       project_name: "my-app",
+       disable_build_cache: true
+     })
+
+🎬 DEPLOYMENT MANAGEMENT
+───────────────────────────────────────────────────────────────────────
+
+▶️  mlgym_deploy_manual
+   Manually trigger a new deployment.
+
+   Usage:
+     mlgym_deploy_manual({project_name: "my-app"})
+
+⏪ mlgym_rollback
+   Rollback to previous deployment.
+
+   Usage:
+     mlgym_rollback({
+       project_name: "my-app",
+       deployment_id: 123              // optional, uses previous if not specified
+     })
+
+👤 USER MANAGEMENT
+───────────────────────────────────────────────────────────────────────
+
+➕ mlgym_user_create
+   Create a new MLGym user account.
+
+   Usage:
+     mlgym_user_create({
+       email: "user@example.com",
+       name: "John Doe",
+       password: "SecurePass123!",
+       accept_terms: true
+     })
+
+🔐 mlgym_auth_login
+   Login with existing credentials.
+
+   Usage:
+     mlgym_auth_login({
+       email: "user@example.com",
+       password: "SecurePass123!"
+     })
+
+❓ HELP
+───────────────────────────────────────────────────────────────────────
+
+📖 mlgym_help
+   Display this help message.
+
+   Usage:
+     mlgym_help()
+
+╔═══════════════════════════════════════════════════════════════════════╗
+║                         WORKFLOW EXAMPLES                             ║
+╚═══════════════════════════════════════════════════════════════════════╝
+
+1️⃣  Complete New Deployment:
+   mlgym_deploy({
+     project_name: "my-app",
+     project_description: "My new app",
+     email: "me@example.com",
+     password: "pass123"
+   })
+
+2️⃣  Set Environment Variables:
+   mlgym_set_env_vars({
+     project_name: "my-app",
+     variables: {DATABASE_URL: "..."}
+   })
+
+3️⃣  Configure & Deploy:
+   mlgym_set_health_check({project_name: "my-app", enabled: true})
+   mlgym_set_domain({project_name: "my-app", domain: "app.example.com"})
+   mlgym_deploy_manual({project_name: "my-app"})
+
+4️⃣  Monitor & Rollback if needed:
+   mlgym_deploy_logs({project_name: "my-app", depth: 5})
+   mlgym_rollback({project_name: "my-app"})
+
+📚 More info: https://backend.eu.ezb.net
+🐛 Issues: Report via user dashboard
+`;
+
+  return {
+    content: [{
+      type: 'text',
+      text: helpText
+    }]
+  };
+}
+
 // Create the MCP server
 const server = new Server(
   {
@@ -2429,6 +3125,231 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           }
         }
       },
+      {
+        name: 'mlgym_set_env_vars',
+        description: 'Set environment variables for a Coolify application. Environment variables are available during both build time and runtime. Useful for setting DATABASE_URL, API keys, and other configuration.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            variables: {
+              type: 'object',
+              description: 'Environment variables as key-value pairs (e.g., {"DATABASE_URL": "postgresql://...", "STRIPE_SECRET_KEY": "sk_..."})',
+              additionalProperties: {
+                type: 'string'
+              }
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional, defaults to current directory)',
+              default: '.'
+            }
+          },
+          required: ['variables']
+        }
+      },
+      {
+        name: 'mlgym_set_health_check',
+        description: 'Configure health check for application. Health checks monitor application availability and restart containers if unhealthy.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            enabled: {
+              type: 'boolean',
+              description: 'Enable or disable health checks'
+            },
+            path: {
+              type: 'string',
+              description: 'Health check endpoint path (e.g., "/health", "/api/health")',
+              default: '/'
+            },
+            port: {
+              type: 'string',
+              description: 'Port to check (optional, uses exposed port if not specified)'
+            },
+            method: {
+              type: 'string',
+              description: 'HTTP method for health check',
+              enum: ['GET', 'POST', 'HEAD'],
+              default: 'GET'
+            },
+            return_code: {
+              type: 'number',
+              description: 'Expected HTTP return code for healthy status',
+              default: 200
+            },
+            interval: {
+              type: 'number',
+              description: 'Seconds between health checks',
+              default: 5
+            },
+            timeout: {
+              type: 'number',
+              description: 'Seconds before health check times out',
+              default: 5
+            },
+            retries: {
+              type: 'number',
+              description: 'Number of retries before marking unhealthy',
+              default: 10
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          },
+          required: ['enabled']
+        }
+      },
+      {
+        name: 'mlgym_set_domain',
+        description: 'Set custom domain/FQDN for application. Updates the application URL where it will be accessible.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            domain: {
+              type: 'string',
+              description: 'Domain/FQDN (e.g., "myapp.example.com" or "https://myapp.example.com")'
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          },
+          required: ['domain']
+        }
+      },
+      {
+        name: 'mlgym_set_deployment_commands',
+        description: 'Configure pre-deployment and post-deployment commands. Pre-deployment runs before build, post-deployment runs after deployment.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            pre_command: {
+              type: 'string',
+              description: 'Command to run before deployment (e.g., "npm run migrate")'
+            },
+            pre_command_container: {
+              type: 'string',
+              description: 'Container to run pre-command in (for docker-compose apps)'
+            },
+            post_command: {
+              type: 'string',
+              description: 'Command to run after deployment (e.g., "npm run seed")'
+            },
+            post_command_container: {
+              type: 'string',
+              description: 'Container to run post-command in (for docker-compose apps)'
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_deploy_manual',
+        description: 'Manually trigger a new deployment. Forces rebuild and deploys current code from GitLab repository.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_set_options',
+        description: 'Configure application options like build cache. More options may be added in future versions.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            disable_build_cache: {
+              type: 'boolean',
+              description: 'Disable Docker build cache (forces clean builds)'
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_rollback',
+        description: 'Rollback to a previous deployment. If deployment_id not specified, rolls back to the last successful deployment.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_name: {
+              type: 'string',
+              description: 'Project/application name',
+              pattern: '^[a-z0-9][a-z0-9-]*[a-z0-9]$',
+              minLength: 3
+            },
+            deployment_id: {
+              type: 'number',
+              description: 'Specific deployment ID to rollback to (optional, uses previous if not specified)'
+            },
+            local_path: {
+              type: 'string',
+              description: 'Local project directory path (optional)',
+              default: '.'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_help',
+        description: 'Display all available MLGym tools with descriptions and usage examples. Use this to discover what operations you can perform.',
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
       // ========== LEGACY TOOLS (Re-enabled for specific use cases) ==========
       {
         name: 'mlgym_user_create',
@@ -2521,8 +3442,48 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = await loginUser(args);
         break;
 
+      case 'mlgym_set_env_vars':
+        log.info(`Setting environment variables...`);
+        result = await setEnvironmentVariables(args);
+        break;
+
+      case 'mlgym_set_health_check':
+        log.info(`Configuring health check...`);
+        result = await setHealthCheck(args);
+        break;
+
+      case 'mlgym_set_domain':
+        log.info(`Setting custom domain...`);
+        result = await setDomain(args);
+        break;
+
+      case 'mlgym_set_deployment_commands':
+        log.info(`Setting deployment commands...`);
+        result = await setDeploymentCommands(args);
+        break;
+
+      case 'mlgym_deploy_manual':
+        log.info(`Triggering manual deployment...`);
+        result = await manualDeploy(args);
+        break;
+
+      case 'mlgym_set_options':
+        log.info(`Setting application options...`);
+        result = await setOptions(args);
+        break;
+
+      case 'mlgym_rollback':
+        log.info(`Rolling back deployment...`);
+        result = await rollback(args);
+        break;
+
+      case 'mlgym_help':
+        log.info(`Showing help...`);
+        result = await showHelp(args);
+        break;
+
       default:
-        throw new Error(`Unknown tool: ${name}. Available tools: mlgym_deploy, mlgym_status, mlgym_deploy_logs, 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, mlgym_set_env_vars, mlgym_set_health_check, mlgym_set_domain, mlgym_set_deployment_commands, mlgym_deploy_manual, mlgym_set_options, mlgym_rollback`);
     }
 
     const duration = Date.now() - startTime;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mlgym-deploy",
-  "version": "3.2.2",
-  "description": "MCP server for MLGym - Auto-validates and fixes docker-compose/Dockerfile for Coolify",
+  "version": "3.3.0",
+  "description": "MCP server for MLGym - Complete deployment management: deploy, configure, monitor, and rollback applications",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -47,6 +47,38 @@
       {
         "name": "mlgym_auth_login",
         "description": "Login with existing credentials"
+      },
+      {
+        "name": "mlgym_set_env_vars",
+        "description": "Set environment variables for an application (DATABASE_URL, API keys, etc.)"
+      },
+      {
+        "name": "mlgym_set_health_check",
+        "description": "Configure health checks to monitor application availability"
+      },
+      {
+        "name": "mlgym_set_domain",
+        "description": "Set custom domain/FQDN for application"
+      },
+      {
+        "name": "mlgym_set_deployment_commands",
+        "description": "Configure pre-deployment and post-deployment commands"
+      },
+      {
+        "name": "mlgym_deploy_manual",
+        "description": "Manually trigger a new deployment"
+      },
+      {
+        "name": "mlgym_set_options",
+        "description": "Configure application options (build cache, etc.)"
+      },
+      {
+        "name": "mlgym_rollback",
+        "description": "Rollback to previous deployment"
+      },
+      {
+        "name": "mlgym_help",
+        "description": "Display all available tools with descriptions and usage examples"
       }
     ]
   }