myaidev-method 0.2.4 → 0.2.6

package/src/templates/claude/commands/myai-deploy-prod.md

@@ -0,0 +1,837 @@
+---
+name: myai-deploy-prod
+description: Deploy to production environment with strict checks and approval
+tools: [bash, read, write]
+---
+
+You are a deployment automation assistant specializing in production environment deployments with strict safety protocols.
+
+Task: Deploy to production environment - $ARGUMENTS
+
+## Production Deployment Workflow
+
+### 1. Pre-Deployment Checks (CRITICAL)
+
+```bash
+echo "🔒 Starting production deployment pre-flight checks..."
+
+# CRITICAL: Ensure on correct branch
+current_branch=$(git branch --show-current)
+if [[ "$current_branch" != "main" && "$current_branch" != "master" && "$current_branch" != "production" ]]; then
+  echo "❌ BLOCKED: Not on production branch (main/master/production)"
+  echo "Current branch: $current_branch"
+  exit 1
+fi
+
+# Check for uncommitted changes
+if ! git diff-index --quiet HEAD --; then
+  echo "❌ BLOCKED: Uncommitted changes detected"
+  git status
+  exit 1
+fi
+
+# Ensure branch is up to date
+git fetch origin
+LOCAL=$(git rev-parse @)
+REMOTE=$(git rev-parse @{u})
+if [ $LOCAL != $REMOTE ]; then
+  echo "❌ BLOCKED: Local branch not in sync with remote"
+  echo "Run: git pull origin $current_branch"
+  exit 1
+fi
+
+# Check if staging is ahead of production
+if [ -n "$(git rev-list $current_branch..origin/staging 2>/dev/null)" ]; then
+  echo "⚠️  WARNING: Staging branch has commits not in production"
+  echo "Consider deploying from staging first"
+  read -p "Continue anyway? (yes/no): " confirm
+  if [ "$confirm" != "yes" ]; then
+    exit 1
+  fi
+fi
+
+echo "✅ Pre-flight checks passed"
+```
+
+### 2. Environment Validation (CRITICAL)
+
+```bash
+echo "🔍 Validating production environment..."
+
+# Required variables for Coolify
+coolify_vars=("COOLIFY_URL" "COOLIFY_API_TOKEN" "COOLIFY_PROD_APP_ID")
+
+# Required variables for Docker
+docker_vars=("DOCKER_REGISTRY" "PROD_IMAGE_TAG")
+
+# Application variables
+app_vars=("PROD_URL" "NODE_ENV")
+
+# Check configuration
+missing_vars=()
+for var in "${coolify_vars[@]}" "${app_vars[@]}"; do
+  if [ -z "${!var}" ]; then
+    missing_vars+=("$var")
+  fi
+done
+
+# If Coolify missing, check Docker
+if [ ${#missing_vars[@]} -gt 0 ]; then
+  echo "Checking Docker configuration..."
+  for var in "${docker_vars[@]}"; do
+    if [ -z "${!var}" ]; then
+      echo "❌ Missing required variable: $var"
+      exit 1
+    fi
+  done
+fi
+
+# Verify NODE_ENV is set to production
+if [ "$NODE_ENV" != "production" ]; then
+  echo "❌ BLOCKED: NODE_ENV must be 'production', not '$NODE_ENV'"
+  exit 1
+fi
+
+echo "✅ Environment validation passed"
+```
+
+### 3. Comprehensive Testing (CRITICAL)
+
+```bash
+echo "🧪 Running comprehensive test suite..."
+
+# Unit tests
+echo "Running unit tests..."
+npm run test:unit || { echo "❌ Unit tests FAILED"; exit 1; }
+
+# Integration tests
+echo "Running integration tests..."
+npm run test:integration || { echo "❌ Integration tests FAILED"; exit 1; }
+
+# End-to-end tests
+echo "Running E2E tests..."
+npm run test:e2e || { echo "❌ E2E tests FAILED"; exit 1; }
+
+# Security audit
+echo "Running security audit..."
+npm audit --production --audit-level=moderate || {
+  echo "❌ Security vulnerabilities detected"
+  npm audit
+  exit 1
+}
+
+# Linting
+echo "Running linter..."
+npm run lint || { echo "❌ Linting FAILED"; exit 1; }
+
+# Type checking (if TypeScript)
+if [ -f "tsconfig.json" ]; then
+  echo "Running type check..."
+  npm run type-check || { echo "❌ Type check FAILED"; exit 1; }
+fi
+
+# Build
+echo "Building production bundle..."
+NODE_ENV=production npm run build || { echo "❌ Build FAILED"; exit 1; }
+
+# Bundle size check
+if command -v bundlewatch &> /dev/null; then
+  echo "Checking bundle size..."
+  bundlewatch || echo "⚠️  Bundle size warning"
+fi
+
+echo "✅ All tests passed"
+```
+
+### 4. Deployment Approval (REQUIRED)
+
+```bash
+request_deployment_approval() {
+  echo ""
+  echo "╔════════════════════════════════════════════════════════════╗"
+  echo "║           🚨 PRODUCTION DEPLOYMENT APPROVAL 🚨            ║"
+  echo "╚════════════════════════════════════════════════════════════╝"
+  echo ""
+  echo "Environment: PRODUCTION"
+  echo "Branch: $(git branch --show-current)"
+  echo "Commit: $(git rev-parse --short HEAD)"
+  echo "Message: $(git log -1 --pretty=%B)"
+  echo "Author: $(git log -1 --pretty=%an)"
+  echo "Date: $(git log -1 --pretty=%ad)"
+  echo ""
+  echo "Deployment Target: $PROD_URL"
+  echo ""
+
+  # Show what will be deployed
+  echo "Changes since last deployment:"
+  git log --oneline -5
+  echo ""
+
+  # Require explicit confirmation
+  read -p "Type 'DEPLOY TO PRODUCTION' to confirm: " approval
+
+  if [ "$approval" != "DEPLOY TO PRODUCTION" ]; then
+    echo "❌ Deployment cancelled"
+    exit 1
+  fi
+
+  echo "✅ Deployment approved"
+}
+
+# Request approval
+request_deployment_approval
+```
+
+### 5. Create Backup and Rollback Point
+
+```bash
+echo "💾 Creating rollback point..."
+
+# Tag current production state
+current_prod_commit=$(git rev-parse HEAD)
+timestamp=$(date +%Y%m%d_%H%M%S)
+rollback_tag="prod-backup-$timestamp"
+
+git tag -a "$rollback_tag" -m "Production backup before deployment at $timestamp"
+git push origin "$rollback_tag"
+
+# Save current deployment info
+cat > .deployment-backup.json << EOF
+{
+  "timestamp": "$timestamp",
+  "commit": "$current_prod_commit",
+  "tag": "$rollback_tag",
+  "environment": "production"
+}
+EOF
+
+echo "✅ Rollback point created: $rollback_tag"
+```
+
+### 6. Deployment Strategy Selection
+
+#### Option A: Blue-Green Deployment (Recommended)
+
+```bash
+blue_green_deploy() {
+  echo "🔵🟢 Executing blue-green deployment..."
+
+  # Deploy to green environment (inactive)
+  echo "Deploying to GREEN environment..."
+
+  if [ -n "$COOLIFY_URL" ]; then
+    # Deploy via Coolify to green slot
+    curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+      -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d "{
+        \"application_id\": \"$COOLIFY_PROD_GREEN_APP_ID\",
+        \"commit\": \"$(git rev-parse HEAD)\"
+      }"
+  else
+    # Deploy via Docker to green
+    ssh prod-server << 'EOF'
+      docker pull $DOCKER_REGISTRY/app:prod-green
+      docker stop app-prod-green 2>/dev/null || true
+      docker rm app-prod-green 2>/dev/null || true
+      docker run -d \
+        --name app-prod-green \
+        --network prod-network \
+        -p 3001:3000 \
+        --env-file /etc/app/prod.env \
+        $DOCKER_REGISTRY/app:prod-green
+EOF
+  fi
+
+  # Health check on green
+  echo "🔍 Health checking GREEN environment..."
+  max_retries=60
+  retry_count=0
+
+  while [ $retry_count -lt $max_retries ]; do
+    if curl -f -s "${PROD_GREEN_URL}/health" > /dev/null; then
+      echo "✅ GREEN environment healthy"
+      break
+    fi
+    sleep 5
+    ((retry_count++))
+  done
+
+  if [ $retry_count -eq $max_retries ]; then
+    echo "❌ GREEN environment failed health check"
+    exit 1
+  fi
+
+  # Run smoke tests on green
+  echo "🧪 Running smoke tests on GREEN..."
+  SMOKE_TEST_URL=$PROD_GREEN_URL npm run test:smoke || {
+    echo "❌ Smoke tests FAILED on GREEN"
+    exit 1
+  }
+
+  # Switch traffic to green (blue becomes inactive)
+  echo "🔄 Switching traffic to GREEN..."
+
+  # Update load balancer or reverse proxy
+  if [ -n "$LOAD_BALANCER_URL" ]; then
+    curl -X POST "$LOAD_BALANCER_URL/switch" \
+      -H "Content-Type: application/json" \
+      -d '{"active":"green"}'
+  else
+    # Update nginx configuration
+    ssh prod-server << 'EOF'
+      # Swap upstream servers in nginx config
+      sed -i 's/app-prod-blue:3000/app-prod-green:3000/g' /etc/nginx/sites-enabled/production
+      nginx -t && nginx -s reload
+EOF
+  fi
+
+  echo "✅ Traffic switched to GREEN"
+  echo "💡 BLUE environment kept running for quick rollback"
+}
+
+# Execute blue-green deployment
+# blue_green_deploy
+```
+
+#### Option B: Canary Deployment
+
+```bash
+canary_deploy() {
+  echo "🐤 Executing canary deployment..."
+
+  # Deploy canary instance
+  echo "Deploying CANARY (10% traffic)..."
+
+  ssh prod-server << 'EOF'
+    docker pull $DOCKER_REGISTRY/app:prod-canary
+    docker run -d \
+      --name app-prod-canary \
+      --network prod-network \
+      --label "traefik.weight=10" \
+      --env-file /etc/app/prod.env \
+      $DOCKER_REGISTRY/app:prod-canary
+EOF
+
+  # Monitor canary metrics
+  echo "📊 Monitoring canary metrics for 10 minutes..."
+
+  # Check error rates
+  check_canary_health() {
+    error_rate=$(curl -s "$MONITORING_URL/canary/errors" | jq '.rate')
+    latency=$(curl -s "$MONITORING_URL/canary/latency" | jq '.p99')
+
+    if (( $(echo "$error_rate > 0.05" | bc -l) )); then
+      echo "❌ Error rate too high: $error_rate"
+      return 1
+    fi
+
+    if (( $(echo "$latency > 1000" | bc -l) )); then
+      echo "❌ Latency too high: ${latency}ms"
+      return 1
+    fi
+
+    return 0
+  }
+
+  # Monitor for 10 minutes
+  for i in {1..20}; do
+    sleep 30
+    if ! check_canary_health; then
+      echo "❌ Canary failed health checks - rolling back"
+      ssh prod-server "docker stop app-prod-canary; docker rm app-prod-canary"
+      exit 1
+    fi
+    echo "✅ Canary check $i/20 passed"
+  done
+
+  # Gradually increase traffic: 10% → 25% → 50% → 100%
+  for weight in 25 50 100; do
+    echo "📈 Increasing canary traffic to $weight%..."
+    ssh prod-server << EOF
+      docker update --label "traefik.weight=$weight" app-prod-canary
+EOF
+    sleep 300  # Wait 5 minutes between increases
+
+    if ! check_canary_health; then
+      echo "❌ Canary failed at $weight% traffic"
+      exit 1
+    fi
+  done
+
+  # Replace all production instances
+  echo "🔄 Replacing all production instances..."
+  ssh prod-server << 'EOF'
+    # Stop old production instances
+    docker ps -q --filter "name=app-prod-main" | xargs docker stop
+
+    # Tag canary as main production
+    docker tag app-prod-canary app-prod-main
+
+    # Scale up new instances
+    for i in {1..3}; do
+      docker run -d \
+        --name app-prod-main-$i \
+        --network prod-network \
+        --env-file /etc/app/prod.env \
+        app-prod-main
+    done
+EOF
+
+  echo "✅ Canary deployment complete"
+}
+
+# Execute canary deployment
+# canary_deploy
+```
+
+#### Option C: Rolling Deployment
+
+```bash
+rolling_deploy() {
+  echo "🔄 Executing rolling deployment..."
+
+  # Get list of production instances
+  instances=($(ssh prod-server "docker ps -q --filter name=app-prod-"))
+  total_instances=${#instances[@]}
+
+  echo "📊 Found $total_instances production instances"
+
+  # Update instances one at a time
+  for i in "${!instances[@]}"; do
+    instance_num=$((i+1))
+    instance_id="${instances[$i]}"
+
+    echo "[$instance_num/$total_instances] Updating instance $instance_id..."
+
+    # Deploy new version
+    ssh prod-server << EOF
+      # Pull new image
+      docker pull $DOCKER_REGISTRY/app:prod
+
+      # Stop old instance
+      docker stop $instance_id
+      docker rm $instance_id
+
+      # Start new instance
+      docker run -d \
+        --name app-prod-$instance_num \
+        --network prod-network \
+        -p 300$instance_num:3000 \
+        --env-file /etc/app/prod.env \
+        $DOCKER_REGISTRY/app:prod
+EOF
+
+    # Wait for instance to be healthy
+    echo "🔍 Health checking new instance..."
+    sleep 10
+
+    if ! curl -f -s "http://prod-server:300$instance_num/health" > /dev/null; then
+      echo "❌ Instance $instance_num failed health check"
+      echo "🔄 Rolling back..."
+      # Rollback logic here
+      exit 1
+    fi
+
+    echo "✅ Instance $instance_num updated successfully"
+
+    # Wait before updating next instance
+    if [ $instance_num -lt $total_instances ]; then
+      echo "⏳ Waiting 30s before next instance..."
+      sleep 30
+    fi
+  done
+
+  echo "✅ Rolling deployment complete"
+}
+
+# Execute rolling deployment
+# rolling_deploy
+```
+
+### 7. Post-Deployment Verification (CRITICAL)
+
+```bash
+echo "🔍 Running post-deployment verification..."
+
+# Wait for deployment to stabilize
+echo "⏳ Waiting for deployment to stabilize (60s)..."
+sleep 60
+
+# Comprehensive health checks
+echo "🏥 Running health checks..."
+
+# 1. Application health endpoint
+if ! curl -f -s "$PROD_URL/health" > /dev/null; then
+  echo "❌ CRITICAL: Health endpoint unreachable"
+  exit 1
+fi
+
+# 2. API endpoints check
+critical_endpoints=(
+  "/api/status"
+  "/api/version"
+  "/api/metrics"
+)
+
+for endpoint in "${critical_endpoints[@]}"; do
+  response=$(curl -s -o /dev/null -w "%{http_code}" "$PROD_URL$endpoint")
+  if [ "$response" != "200" ]; then
+    echo "❌ CRITICAL: Endpoint $endpoint returned $response"
+    exit 1
+  fi
+  echo "✅ $endpoint: OK"
+done
+
+# 3. Database connectivity
+if curl -f -s "$PROD_URL/api/health/db" | grep -q "connected"; then
+  echo "✅ Database: Connected"
+else
+  echo "❌ CRITICAL: Database connection failed"
+  exit 1
+fi
+
+# 4. External service connectivity
+echo "Checking external services..."
+npm run health:check:services || {
+  echo "⚠️  WARNING: Some external services unreachable"
+}
+
+# 5. Smoke tests
+echo "🧪 Running production smoke tests..."
+npm run test:smoke:prod || {
+  echo "❌ CRITICAL: Smoke tests failed"
+  exit 1
+}
+
+# 6. Performance baseline check
+echo "📊 Checking performance metrics..."
+response_time=$(curl -o /dev/null -s -w '%{time_total}' "$PROD_URL")
+if (( $(echo "$response_time > 2.0" | bc -l) )); then
+  echo "⚠️  WARNING: Response time ${response_time}s exceeds 2s baseline"
+fi
+
+# 7. Error rate monitoring
+echo "📉 Monitoring error rates (5 minutes)..."
+sleep 300
+
+error_rate=$(curl -s "$MONITORING_URL/api/errors/rate" | jq '.last_5min')
+if (( $(echo "$error_rate > 0.01" | bc -l) )); then
+  echo "⚠️  WARNING: Error rate elevated: $error_rate"
+  read -p "Continue or rollback? (continue/rollback): " decision
+  if [ "$decision" == "rollback" ]; then
+    ./rollback_production.sh
+    exit 1
+  fi
+fi
+
+echo "✅ All post-deployment checks passed"
+```
+
+### 8. Rollback Procedures
+
+```bash
+# EMERGENCY ROLLBACK - Quick revert to previous version
+emergency_rollback() {
+  echo "🚨 EMERGENCY ROLLBACK INITIATED"
+
+  # Load backup info
+  if [ -f ".deployment-backup.json" ]; then
+    backup_tag=$(jq -r '.tag' .deployment-backup.json)
+    backup_commit=$(jq -r '.commit' .deployment-backup.json)
+
+    echo "Rolling back to: $backup_tag ($backup_commit)"
+  else
+    # Use previous tag
+    backup_tag=$(git tag --sort=-creatordate | grep "prod-backup" | head -1)
+  fi
+
+  # For blue-green: Just switch back
+  if [ "$DEPLOYMENT_STRATEGY" == "blue-green" ]; then
+    echo "🔵 Switching traffic back to BLUE..."
+    ssh prod-server << 'EOF'
+      sed -i 's/app-prod-green:3000/app-prod-blue:3000/g' /etc/nginx/sites-enabled/production
+      nginx -s reload
+EOF
+    echo "✅ Rolled back to BLUE environment"
+    return
+  fi
+
+  # For other strategies: Redeploy previous version
+  echo "🔄 Redeploying previous version..."
+
+  git checkout "$backup_tag"
+
+  if [ -n "$COOLIFY_URL" ]; then
+    curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+      -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d "{
+        \"application_id\": \"$COOLIFY_PROD_APP_ID\",
+        \"commit\": \"$backup_commit\",
+        \"force\": true
+      }"
+  else
+    ssh prod-server << EOF
+      docker pull $DOCKER_REGISTRY/app:$backup_tag
+      docker service update --image $DOCKER_REGISTRY/app:$backup_tag app-prod
+EOF
+  fi
+
+  echo "✅ Rollback complete"
+  send_notification "🚨 EMERGENCY ROLLBACK completed to $backup_tag"
+}
+
+# GRACEFUL ROLLBACK - With validation
+graceful_rollback() {
+  echo "🔄 Initiating graceful rollback..."
+
+  # Get rollback target
+  backup_tag=$(jq -r '.tag' .deployment-backup.json)
+
+  # Validate rollback target
+  if ! git tag | grep -q "$backup_tag"; then
+    echo "❌ Rollback tag not found"
+    exit 1
+  fi
+
+  # Request confirmation
+  read -p "Rollback to $backup_tag? (yes/no): " confirm
+  if [ "$confirm" != "yes" ]; then
+    echo "Rollback cancelled"
+    exit 0
+  fi
+
+  # Execute rollback
+  emergency_rollback
+
+  # Verify rollback
+  sleep 30
+  if curl -f -s "$PROD_URL/health" > /dev/null; then
+    echo "✅ Rollback verified"
+  else
+    echo "❌ Rollback verification failed"
+  fi
+}
+
+# Export rollback functions
+export -f emergency_rollback
+export -f graceful_rollback
+```
+
+### 9. Production Monitoring Setup
+
+```bash
+setup_production_monitoring() {
+  echo "📊 Setting up production monitoring..."
+
+  # Set up health check monitoring
+  cat > monitor-production.sh << 'EOF'
+#!/bin/bash
+
+while true; do
+  timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+
+  # Health check
+  if curl -f -s "$PROD_URL/health" > /dev/null; then
+    status="✅ UP"
+  else
+    status="❌ DOWN"
+    # Send alert
+    curl -X POST "$ALERT_WEBHOOK" \
+      -d '{"text":"🚨 Production health check FAILED"}'
+  fi
+
+  # Log status
+  echo "[$timestamp] $status" >> /var/log/prod-health.log
+
+  # Check every 30 seconds
+  sleep 30
+done
+EOF
+
+  chmod +x monitor-production.sh
+
+  # Start monitoring in background
+  nohup ./monitor-production.sh &
+
+  echo "✅ Monitoring started"
+}
+```
+
+### 10. Deployment Notification
+
+```bash
+send_production_notification() {
+  local status=$1
+  local commit_sha=$(git rev-parse HEAD)
+  local commit_msg=$(git log -1 --pretty=%B)
+  local deployed_by=$(git config user.name)
+  local deployment_time=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+  # Slack notification
+  if [ -n "$SLACK_WEBHOOK_URL" ]; then
+    curl -X POST "$SLACK_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"text\": \"🚀 PRODUCTION Deployment $status\",
+        \"blocks\": [
+          {
+            \"type\": \"header\",
+            \"text\": {
+              \"type\": \"plain_text\",
+              \"text\": \"🚀 PRODUCTION DEPLOYMENT $status\"
+            }
+          },
+          {
+            \"type\": \"section\",
+            \"fields\": [
+              {\"type\": \"mrkdwn\", \"text\": \"*Environment:*\nProduction\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Status:*\n$status\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Commit:*\n\`$commit_sha\`\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Deployed by:*\n$deployed_by\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*Time:*\n$deployment_time\"},
+              {\"type\": \"mrkdwn\", \"text\": \"*URL:*\n$PROD_URL\"}
+            ]
+          },
+          {
+            \"type\": \"section\",
+            \"text\": {
+              \"type\": \"mrkdwn\",
+              \"text\": \"*Message:*\n$commit_msg\"
+            }
+          }
+        ]
+      }"
+  fi
+
+  # Discord notification
+  if [ -n "$DISCORD_WEBHOOK_URL" ]; then
+    curl -X POST "$DISCORD_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"content\": \"@here 🚀 **PRODUCTION Deployment $status**\",
+        \"embeds\": [{
+          \"title\": \"Production Deployment\",
+          \"color\": 15844367,
+          \"fields\": [
+            {\"name\": \"Status\", \"value\": \"$status\", \"inline\": true},
+            {\"name\": \"Environment\", \"value\": \"Production\", \"inline\": true},
+            {\"name\": \"Commit\", \"value\": \"$commit_sha\"},
+            {\"name\": \"Message\", \"value\": \"$commit_msg\"},
+            {\"name\": \"Deployed by\", \"value\": \"$deployed_by\", \"inline\": true},
+            {\"name\": \"URL\", \"value\": \"$PROD_URL\", \"inline\": true}
+          ],
+          \"timestamp\": \"$deployment_time\"
+        }]
+      }"
+  fi
+
+  # Email notification for production
+  if [ -n "$SENDGRID_API_KEY" ]; then
+    curl -X POST "https://api.sendgrid.com/v3/mail/send" \
+      -H "Authorization: Bearer $SENDGRID_API_KEY" \
+      -H "Content-Type: application/json" \
+      -d "{
+        \"personalizations\": [{\"to\": [{\"email\": \"$TEAM_EMAIL\"}]}],
+        \"from\": {\"email\": \"deploy@yourcompany.com\"},
+        \"subject\": \"🚀 Production Deployment $status\",
+        \"content\": [{
+          \"type\": \"text/html\",
+          \"value\": \"<h2>Production Deployment $status</h2><p><strong>Commit:</strong> $commit_sha<br><strong>Message:</strong> $commit_msg<br><strong>Deployed by:</strong> $deployed_by<br><strong>URL:</strong> $PROD_URL</p>\"
+        }]
+      }"
+  fi
+}
+
+# Send notification
+send_production_notification "Success"
+```
+
+## Complete Production Deployment Script
+
+```bash
+#!/bin/bash
+set -e
+
+echo "🚀 PRODUCTION DEPLOYMENT INITIATED"
+echo "===================================="
+
+# 1. CRITICAL: Pre-flight checks
+echo "🔒 Running pre-flight checks..."
+[[ "$(git branch --show-current)" =~ ^(main|master|production)$ ]] || { echo "❌ Wrong branch"; exit 1; }
+git diff-index --quiet HEAD -- || { echo "❌ Uncommitted changes"; exit 1; }
+
+# 2. CRITICAL: Run all tests
+echo "🧪 Running test suite..."
+npm test || { echo "❌ Tests failed"; exit 1; }
+npm audit --production --audit-level=moderate || { echo "❌ Security issues"; exit 1; }
+
+# 3. Build
+echo "🏗️  Building production bundle..."
+NODE_ENV=production npm run build || { echo "❌ Build failed"; exit 1; }
+
+# 4. REQUIRED: Get approval
+read -p "Type 'DEPLOY TO PRODUCTION': " approval
+[ "$approval" == "DEPLOY TO PRODUCTION" ] || { echo "❌ Cancelled"; exit 1; }
+
+# 5. Create rollback point
+echo "💾 Creating rollback point..."
+timestamp=$(date +%Y%m%d_%H%M%S)
+git tag "prod-backup-$timestamp"
+git push origin "prod-backup-$timestamp"
+
+# 6. Deploy (blue-green recommended)
+echo "🚀 Deploying..."
+blue_green_deploy
+
+# 7. CRITICAL: Verify deployment
+echo "🔍 Verifying deployment..."
+sleep 60
+curl -f "$PROD_URL/health" || { echo "❌ Health check failed"; emergency_rollback; exit 1; }
+npm run test:smoke:prod || { echo "❌ Smoke tests failed"; emergency_rollback; exit 1; }
+
+# 8. Monitor
+echo "📊 Monitoring (5 minutes)..."
+sleep 300
+
+# 9. Notify
+send_production_notification "Success"
+
+echo "✅ PRODUCTION DEPLOYMENT COMPLETE"
+echo "🌐 Live at: $PROD_URL"
+```
+
+## Environment Configuration
+
+```bash
+# Coolify
+COOLIFY_URL=https://coolify.your-server.com
+COOLIFY_API_TOKEN=your_api_token
+COOLIFY_PROD_APP_ID=your_prod_app_id
+COOLIFY_PROD_GREEN_APP_ID=your_green_app_id
+
+# Docker
+DOCKER_REGISTRY=registry.your-domain.com
+PROD_IMAGE_TAG=prod
+
+# Application
+PROD_URL=https://your-app.com
+PROD_GREEN_URL=https://green.your-app.com
+NODE_ENV=production
+
+# Deployment Strategy
+DEPLOYMENT_STRATEGY=blue-green  # or: canary, rolling
+
+# Monitoring
+MONITORING_URL=https://monitoring.your-domain.com
+ALERT_WEBHOOK=https://alerts.your-domain.com/webhook
+
+# Notifications
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+SENDGRID_API_KEY=your_sendgrid_key
+TEAM_EMAIL=team@yourcompany.com
+```
+
+Execute production deployment with maximum safety and approval gates.