myaidev-method 0.2.5 → 0.2.7

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

@@ -0,0 +1,331 @@
+---
+name: myai-deploy-staging
+description: Deploy to staging environment via Coolify or Docker
+tools: [bash, read, write]
+---
+
+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
+```
+
+### 7. Deployment Notification
+
+```bash
+send_deployment_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)
+
+  # Slack notification (if webhook configured)
+  if [ -n "$SLACK_WEBHOOK_URL" ]; then
+    curl -X POST "$SLACK_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"text\": \"🚀 Staging Deployment $status\",
+        \"blocks\": [
+          {
+            \"type\": \"section\",
+            \"text\": {
+              \"type\": \"mrkdwn\",
+              \"text\": \"*Staging Deployment $status*\n*Commit:* $commit_sha\n*Message:* $commit_msg\n*Deployed by:* $deployed_by\n*Environment:* Staging\"
+            }
+          }
+        ]
+      }"
+  fi
+
+  # Discord notification (if webhook configured)
+  if [ -n "$DISCORD_WEBHOOK_URL" ]; then
+    curl -X POST "$DISCORD_WEBHOOK_URL" \
+      -H 'Content-Type: application/json' \
+      -d "{
+        \"content\": \"🚀 **Staging Deployment $status**\",
+        \"embeds\": [{
+          \"title\": \"Deployment Details\",
+          \"fields\": [
+            {\"name\": \"Commit\", \"value\": \"$commit_sha\"},
+            {\"name\": \"Message\", \"value\": \"$commit_msg\"},
+            {\"name\": \"Deployed by\", \"value\": \"$deployed_by\"}
+          ]
+        }]
+      }"
+  fi
+}
+
+# Send notification
+send_deployment_notification "Success"
+```
+
+## 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"
+
+# 5. Notify
+send_deployment_notification "Success"
+
+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.