myaidev-method 0.2.4 → 0.2.6

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

@@ -0,0 +1,431 @@
+# Deploy to production environment with strict checks and approval
+
+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
+
+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")
+
+# 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; }
+
+# Build
+echo "Building production bundle..."
+NODE_ENV=production npm run build || { echo "❌ Build FAILED"; exit 1; }
+
+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. 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
+```
+
+### 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. Smoke tests
+echo "🧪 Running production smoke tests..."
+npm run test:smoke:prod || {
+  echo "❌ CRITICAL: Smoke tests failed"
+  exit 1
+}
+
+echo "✅ All post-deployment checks passed"
+```
+
+### 8. Emergency Rollback
+
+```bash
+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
+      }"
+  fi
+
+  echo "✅ Rollback complete"
+}
+
+# Export rollback functions
+export -f emergency_rollback
+```
+
+## 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
+
+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
+
+# Notifications
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+TEAM_EMAIL=team@yourcompany.com
+```
+
+Execute production deployment with maximum safety and approval gates.

package/src/templates/codex/commands/myai-deploy-staging.md

@@ -0,0 +1,275 @@
+# Deploy to staging environment via Coolify or Docker
+
+You are a deployment automation assistant specializing in staging environment deployments.
+
+Task: Deploy to staging environment - $ARGUMENTS
+
+## Staging Deployment Workflow
+
+### 1. Pre-Deployment Checks
+
+```bash
+# Check current branch and status
+git branch --show-current
+git status
+
+# Ensure on staging branch
+if [ "$(git branch --show-current)" != "staging" ]; then
+  echo "⚠️  Not on staging branch. Switch first."
+  git checkout staging
+fi
+
+# Pull latest changes
+git pull origin staging
+
+# Check for uncommitted changes
+if ! git diff-index --quiet HEAD --; then
+  echo "⚠️  Uncommitted changes detected"
+  git status
+fi
+```
+
+### 2. Environment Validation
+
+**Check Required Environment Variables:**
+```bash
+# For Coolify
+required_vars=("COOLIFY_URL" "COOLIFY_API_TOKEN" "COOLIFY_STAGING_APP_ID")
+
+# For Docker
+required_vars=("DOCKER_REGISTRY" "STAGING_IMAGE_TAG")
+
+for var in "${required_vars[@]}"; do
+  if [ -z "${!var}" ]; then
+    echo "❌ Missing required variable: $var"
+    exit 1
+  fi
+done
+```
+
+### 3. Build and Test
+
+```bash
+# Run tests before deploying
+echo "🧪 Running test suite..."
+npm test || { echo "❌ Tests failed"; exit 1; }
+
+# Build application
+echo "🏗️  Building application..."
+npm run build || { echo "❌ Build failed"; exit 1; }
+
+# Run linter
+npm run lint || echo "⚠️  Linting issues detected"
+```
+
+### 4. Deployment Options
+
+#### Option A: Deploy with Coolify
+
+```bash
+# Using Coolify API
+echo "🚀 Deploying to Coolify staging..."
+
+# Trigger deployment
+curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+  -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"application_id\": \"$COOLIFY_STAGING_APP_ID\",
+    \"force\": false,
+    \"commit\": \"$(git rev-parse HEAD)\"
+  }"
+
+# Monitor deployment status
+echo "📊 Monitoring deployment..."
+deployment_id=$(curl -s "$COOLIFY_URL/api/v1/deployments/latest" \
+  -H "Authorization: Bearer $COOLIFY_API_TOKEN" | jq -r '.id')
+
+while true; do
+  status=$(curl -s "$COOLIFY_URL/api/v1/deployments/$deployment_id" \
+    -H "Authorization: Bearer $COOLIFY_API_TOKEN" | jq -r '.status')
+
+  echo "Status: $status"
+
+  if [ "$status" = "success" ]; then
+    echo "✅ Deployment successful!"
+    break
+  elif [ "$status" = "failed" ]; then
+    echo "❌ Deployment failed!"
+    exit 1
+  fi
+
+  sleep 5
+done
+```
+
+#### Option B: Deploy with Docker
+
+```bash
+echo "🐳 Deploying with Docker..."
+
+# Build Docker image
+docker build -t $DOCKER_REGISTRY/app:staging .
+
+# Push to registry
+docker push $DOCKER_REGISTRY/app:staging
+
+# Deploy to staging server via SSH
+ssh staging-server << 'EOF'
+  docker pull $DOCKER_REGISTRY/app:staging
+  docker stop app-staging || true
+  docker rm app-staging || true
+  docker run -d \
+    --name app-staging \
+    --restart unless-stopped \
+    -p 3000:3000 \
+    --env-file /etc/app/staging.env \
+    $DOCKER_REGISTRY/app:staging
+EOF
+
+echo "✅ Docker deployment complete!"
+```
+
+#### Option C: Deploy with Docker Compose
+
+```bash
+echo "🐳 Deploying with Docker Compose..."
+
+# Deploy to staging server
+ssh staging-server << 'EOF'
+  cd /opt/app
+  git pull origin staging
+  docker-compose -f docker-compose.staging.yml pull
+  docker-compose -f docker-compose.staging.yml up -d --remove-orphans
+  docker-compose -f docker-compose.staging.yml ps
+EOF
+```
+
+### 5. Post-Deployment Verification
+
+```bash
+echo "🔍 Verifying deployment..."
+
+# Health check
+max_retries=30
+retry_count=0
+
+while [ $retry_count -lt $max_retries ]; do
+  if curl -f -s "$STAGING_URL/health" > /dev/null; then
+    echo "✅ Health check passed!"
+    break
+  else
+    echo "⏳ Waiting for application to start... ($retry_count/$max_retries)"
+    sleep 5
+    ((retry_count++))
+  fi
+done
+
+if [ $retry_count -eq $max_retries ]; then
+  echo "❌ Health check failed after $max_retries attempts"
+  exit 1
+fi
+
+# Run smoke tests
+echo "🧪 Running smoke tests..."
+npm run test:smoke:staging || echo "⚠️  Smoke tests failed"
+
+# Check application logs
+echo "📋 Recent logs:"
+if [ -n "$COOLIFY_URL" ]; then
+  curl -s "$COOLIFY_URL/api/v1/applications/$COOLIFY_STAGING_APP_ID/logs" \
+    -H "Authorization: Bearer $COOLIFY_API_TOKEN" | tail -20
+else
+  ssh staging-server "docker logs --tail 20 app-staging"
+fi
+```
+
+### 6. Rollback Procedure
+
+```bash
+rollback_staging() {
+  echo "🔄 Rolling back staging deployment..."
+
+  # Get previous deployment
+  previous_commit=$(git log --oneline -2 | tail -1 | cut -d' ' -f1)
+
+  # Rollback via Coolify
+  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_STAGING_APP_ID\",
+        \"commit\": \"$previous_commit\"
+      }"
+  fi
+
+  # Or rollback via Docker
+  if [ -n "$DOCKER_REGISTRY" ]; then
+    ssh staging-server << EOF
+      docker pull $DOCKER_REGISTRY/app:staging-previous
+      docker stop app-staging
+      docker rm app-staging
+      docker run -d --name app-staging $DOCKER_REGISTRY/app:staging-previous
+EOF
+  fi
+
+  echo "✅ Rollback complete!"
+}
+
+# Call rollback if needed
+# rollback_staging
+```
+
+## Complete Deployment Script
+
+```bash
+#!/bin/bash
+set -e
+
+echo "🚀 Starting staging deployment..."
+
+# 1. Pre-flight checks
+git checkout staging
+git pull origin staging
+npm test
+
+# 2. Build
+npm run build
+
+# 3. Deploy (choose method)
+# Coolify method
+curl -X POST "$COOLIFY_URL/api/v1/deploy" \
+  -H "Authorization: Bearer $COOLIFY_API_TOKEN" \
+  -d '{"application_id":"'"$COOLIFY_STAGING_APP_ID"'"}'
+
+# 4. Verify
+sleep 10
+curl -f "$STAGING_URL/health"
+
+echo "✅ Staging deployment complete!"
+echo "🌐 Application available at: $STAGING_URL"
+```
+
+## Environment Configuration
+
+**Required .env variables:**
+```bash
+# Coolify
+COOLIFY_URL=https://coolify.your-server.com
+COOLIFY_API_TOKEN=your_api_token
+COOLIFY_STAGING_APP_ID=your_staging_app_id
+
+# Docker
+DOCKER_REGISTRY=registry.your-domain.com
+STAGING_IMAGE_TAG=staging
+
+# Application
+STAGING_URL=https://staging.your-app.com
+
+# Notifications (optional)
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
+DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
+```
+
+Execute the staging deployment workflow with appropriate method based on available infrastructure.