mlgym-deploy 3.2.3 → 3.3.1

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.1';  // Updated help with plain English examples showing what users say vs tool calls
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Debug logging configuration - ENABLED BY DEFAULT
@@ -2311,6 +2311,826 @@ 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          ║
+╚═══════════════════════════════════════════════════════════════════════╝
+
+HOW TO USE THIS GUIDE:
+Users speak in plain English. When they say "deploy to mlgym" or "show me
+the status", the AI translates this to the appropriate tool call.
+
+Examples show both what users say AND the tool call that gets executed.
+
+📦 DEPLOYMENT TOOLS
+───────────────────────────────────────────────────────────────────────
+
+🚀 mlgym_deploy - Deploy your application
+   What users say:
+     • "Deploy to mlgym"
+     • "Deploy this project to mlgym"
+     • "I want to deploy my app"
+     • "Push this to production"
+
+   Tool call:
+     mlgym_deploy({
+       project_name: "my-app",
+       project_description: "My application",
+       email: "user@example.com",     // optional if already logged in
+       password: "password123"         // optional if already logged in
+     })
+
+📊 mlgym_status - Check deployment status
+   What users say:
+     • "Show me the status"
+     • "What's deployed?"
+     • "Am I logged in?"
+     • "Check if my project is configured"
+
+   Tool call:
+     mlgym_status({
+       local_path: "."                // optional, defaults to current directory
+     })
+
+📝 mlgym_deploy_logs - View deployment logs
+   What users say:
+     • "Show me the deployment logs"
+     • "What happened in the last deployment?"
+     • "Why did my deployment fail?"
+     • "Show the build logs"
+
+   Tool call:
+     mlgym_deploy_logs({
+       project_name: "my-app",
+       depth: 3                        // optional, number of recent deployments
+     })
+
+⚙️  CONFIGURATION TOOLS
+───────────────────────────────────────────────────────────────────────
+
+🔧 mlgym_set_env_vars - Set environment variables
+   What users say:
+     • "Set the database URL"
+     • "Add these environment variables"
+     • "Configure my API keys"
+     • "I need to set DATABASE_URL and STRIPE_KEY"
+
+   Tool call:
+     mlgym_set_env_vars({
+       project_name: "my-app",
+       variables: {
+         DATABASE_URL: "postgresql://user:pass@host:5432/db",
+         STRIPE_KEY: "sk_live_123...",
+         NODE_ENV: "production"
+       }
+     })
+
+❤️  mlgym_set_health_check - Configure health monitoring
+   What users say:
+     • "Set up a health check"
+     • "Monitor my /health endpoint"
+     • "Check if my app is alive every 30 seconds"
+     • "Enable health checks on /api/health"
+
+   Tool call:
+     mlgym_set_health_check({
+       project_name: "my-app",
+       enabled: true,
+       path: "/health",               // endpoint to check
+       method: "GET",                  // HTTP method
+       return_code: 200,               // expected status code
+       interval: 30                    // check every 30 seconds
+     })
+
+🌐 mlgym_set_domain - Set custom domain
+   What users say:
+     • "Use my custom domain"
+     • "Point myapp.com to this deployment"
+     • "Set the domain to app.example.com"
+     • "Change the URL to www.mysite.com"
+
+   Tool call:
+     mlgym_set_domain({
+       project_name: "my-app",
+       domain: "myapp.example.com"     // your custom domain
+     })
+
+📜 mlgym_set_deployment_commands - Configure build commands
+   What users say:
+     • "Run migrations before deploying"
+     • "Seed the database after deployment"
+     • "Execute npm run build before starting"
+     • "Run these commands during deployment"
+
+   Tool call:
+     mlgym_set_deployment_commands({
+       project_name: "my-app",
+       pre_command: "npm run migrate",  // runs before deployment
+       post_command: "npm run seed"     // runs after deployment
+     })
+
+⚙️  mlgym_set_options - Configure deployment options
+   What users say:
+     • "Disable build cache"
+     • "Turn off the build cache"
+     • "Don't use cached builds"
+     • "Force a fresh build"
+
+   Tool call:
+     mlgym_set_options({
+       project_name: "my-app",
+       disable_build_cache: true        // force fresh builds
+     })
+
+🎬 DEPLOYMENT MANAGEMENT
+───────────────────────────────────────────────────────────────────────
+
+▶️  mlgym_deploy_manual - Trigger deployment manually
+   What users say:
+     • "Deploy now"
+     • "Trigger a deployment"
+     • "Redeploy my application"
+     • "Start a new deployment"
+
+   Tool call:
+     mlgym_deploy_manual({
+       project_name: "my-app"
+     })
+
+⏪ mlgym_rollback - Rollback to previous version
+   What users say:
+     • "Rollback my deployment"
+     • "Go back to the previous version"
+     • "Undo the last deployment"
+     • "Revert to deployment #123"
+
+   Tool call:
+     mlgym_rollback({
+       project_name: "my-app",
+       deployment_id: 123              // optional, uses previous if omitted
+     })
+
+👤 USER MANAGEMENT
+───────────────────────────────────────────────────────────────────────
+
+➕ mlgym_user_create - Create new account
+   What users say:
+     • "Create a new account"
+     • "Sign me up"
+     • "Register a new user"
+     • "I need an account"
+
+   Tool call:
+     mlgym_user_create({
+       email: "user@example.com",
+       name: "John Doe",
+       password: "SecurePass123!",
+       accept_terms: true               // must be true
+     })
+
+🔐 mlgym_auth_login - Login to existing account
+   What users say:
+     • "Login"
+     • "Log me in"
+     • "Authenticate with my credentials"
+     • "Sign in to my account"
+
+   Tool call:
+     mlgym_auth_login({
+       email: "user@example.com",
+       password: "SecurePass123!"
+     })
+
+❓ HELP
+───────────────────────────────────────────────────────────────────────
+
+📖 mlgym_help - Display this help
+   What users say:
+     • "Help"
+     • "Show me what I can do"
+     • "What commands are available?"
+     • "How do I use mlgym?"
+
+   Tool call:
+     mlgym_help()
+
+╔═══════════════════════════════════════════════════════════════════════╗
+║                    COMMON WORKFLOW EXAMPLES                           ║
+╚═══════════════════════════════════════════════════════════════════════╝
+
+1️⃣  First Time User - Complete Deployment:
+
+   User: "Deploy to mlgym"
+
+   AI executes:
+   mlgym_deploy({
+     project_name: "my-app",
+     project_description: "My new app",
+     email: "me@example.com",
+     password: "pass123"
+   })
+
+2️⃣  Set Environment Variables:
+
+   User: "Set the database URL for my app"
+
+   AI executes:
+   mlgym_set_env_vars({
+     project_name: "my-app",
+     variables: {
+       DATABASE_URL: "postgresql://user:pass@host:5432/db"
+     }
+   })
+
+3️⃣  Configure Health Check:
+
+   User: "Monitor my /health endpoint every 30 seconds"
+
+   AI executes:
+   mlgym_set_health_check({
+     project_name: "my-app",
+     enabled: true,
+     path: "/health",
+     interval: 30
+   })
+
+4️⃣  Set Custom Domain:
+
+   User: "Point myapp.com to this deployment"
+
+   AI executes:
+   mlgym_set_domain({
+     project_name: "my-app",
+     domain: "myapp.com"
+   })
+
+5️⃣  Manually Trigger Deployment:
+
+   User: "Deploy now"
+
+   AI executes:
+   mlgym_deploy_manual({
+     project_name: "my-app"
+   })
+
+6️⃣  Check Deployment Logs:
+
+   User: "Show me the last 5 deployments"
+
+   AI executes:
+   mlgym_deploy_logs({
+     project_name: "my-app",
+     depth: 5
+   })
+
+7️⃣  Rollback if Something Breaks:
+
+   User: "Rollback to the previous version"
+
+   AI executes:
+   mlgym_rollback({
+     project_name: "my-app"
+   })
+
+╔═══════════════════════════════════════════════════════════════════════╗
+║                            QUICK TIPS                                 ║
+╚═══════════════════════════════════════════════════════════════════════╝
+
+💡 Users speak naturally - AI translates to tool calls
+💡 Authentication is cached - login once, deploy many times
+💡 All tools work with project_name to identify the application
+💡 Most parameters are optional with sensible defaults
+
+📚 Documentation: https://mlgym.info
+🌐 Backend: https://backend.eu.ezb.net
+📊 Dashboard: https://platform.mlgym.info
+`;
+
+  return {
+    content: [{
+      type: 'text',
+      text: helpText
+    }]
+  };
+}
+
 // Create the MCP server
 const server = new Server(
   {
@@ -2429,6 +3249,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 +3566,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.3",
-  "description": "MCP server for MLGym - Auto-validates and fixes docker-compose/Dockerfile for Coolify",
+  "version": "3.3.1",
+  "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"
       }
     ]
   }