deployment-checker

What this skill does

# Deployment Checker Skill

Pre-deployment validation checklist and automated readiness assessment.

## Instructions

You are a deployment readiness expert. When invoked:

1. **Pre-Deployment Validation**:
   - Code quality checks passed
   - All tests passing
   - Build successful
   - Dependencies updated and secure
   - Environment variables configured
   - Database migrations ready

2. **Security Checks**:
   - No secrets in code
   - Security headers configured
   - Authentication/authorization tested
   - Input validation implemented
   - HTTPS enabled
   - Rate limiting configured

3. **Performance Validation**:
   - Load testing completed
   - Resource limits configured
   - Caching strategies implemented
   - Database indexes optimized
   - CDN configured (if applicable)

4. **Infrastructure Checks**:
   - Health checks configured
   - Monitoring and alerting set up
   - Logging configured
   - Backup strategy in place
   - Rollback plan documented
   - DNS and SSL configured

5. **Generate Checklist**: Create deployment-ready report with go/no-go decision

## Deployment Checklist

### Pre-Deployment (Before Release)

#### Code Quality
- [ ] All tests passing (unit, integration, e2e)
- [ ] Code review completed and approved
- [ ] Linting passed (no warnings)
- [ ] Code coverage meets threshold (>80%)
- [ ] No known critical bugs
- [ ] Breaking changes documented
- [ ] API contracts validated

#### Build & Dependencies
- [ ] Build successful in CI/CD
- [ ] Dependencies updated
- [ ] Security vulnerabilities resolved
- [ ] Bundle size within acceptable limits
- [ ] Source maps generated (if applicable)
- [ ] Docker images built and pushed

#### Database
- [ ] Migrations tested in staging
- [ ] Migration rollback plan ready
- [ ] Backup created before migration
- [ ] Database indexes optimized
- [ ] Data validation scripts run
- [ ] Connection pool configured

#### Environment Configuration
- [ ] Environment variables documented
- [ ] Secrets stored securely (not in code)
- [ ] Feature flags configured
- [ ] CORS settings verified
- [ ] API keys rotated (if needed)
- [ ] Third-party services configured

#### Security
- [ ] Authentication tested
- [ ] Authorization rules verified
- [ ] Input validation implemented
- [ ] SQL injection prevention verified
- [ ] XSS prevention implemented
- [ ] CSRF tokens configured
- [ ] Security headers set
- [ ] Rate limiting enabled
- [ ] HTTPS enforced
- [ ] Secrets manager configured

#### Performance
- [ ] Load testing completed
- [ ] Performance benchmarks met
- [ ] Database query optimization done
- [ ] Caching strategy implemented
- [ ] CDN configured (if applicable)
- [ ] Resource limits set
- [ ] Auto-scaling configured

### Deployment (During Release)

#### Infrastructure
- [ ] Health check endpoints working
- [ ] Monitoring dashboards ready
- [ ] Alerting configured
- [ ] Logging centralized
- [ ] Error tracking enabled (Sentry, etc.)
- [ ] Backup strategy verified
- [ ] SSL certificates valid
- [ ] DNS records updated
- [ ] Load balancer configured

#### Deployment Strategy
- [ ] Deployment method chosen (blue-green, canary, rolling)
- [ ] Rollback plan documented
- [ ] Database migration strategy defined
- [ ] Downtime window communicated (if any)
- [ ] Deployment runbook prepared
- [ ] Staging deployment successful

#### Communication
- [ ] Stakeholders notified
- [ ] Change log prepared
- [ ] Documentation updated
- [ ] Support team briefed
- [ ] Maintenance window scheduled (if needed)
- [ ] Status page updated

### Post-Deployment (After Release)

#### Validation
- [ ] Smoke tests passed
- [ ] Health checks green
- [ ] Error rates normal
- [ ] Response times acceptable
- [ ] Database migrations completed
- [ ] Feature flags validated

#### Monitoring
- [ ] Application logs reviewed
- [ ] Error tracking checked
- [ ] Performance metrics reviewed
- [ ] User feedback monitored
- [ ] Resource usage normal
- [ ] Alerts configured and tested

#### Documentation
- [ ] Release notes published
- [ ] API documentation updated
- [ ] Known issues documented
- [ ] Rollback procedure tested
- [ ] Incident response plan ready

## Usage Examples

```
@deployment-checker
@deployment-checker --environment production
@deployment-checker --checklist
@deployment-checker --automated
@deployment-checker --report
```

## Automated Checks Script

### Node.js Example
```javascript
// deployment-check.js
const chalk = require('chalk');

class DeploymentChecker {
  constructor() {
    this.checks = [];
    this.passed = 0;
    this.failed = 0;
  }

  async runChecks() {
    console.log(chalk.bold('\n🚀 Deployment Readiness Check\n'));

    await this.checkTests();
    await this.checkBuild();
    await this.checkDependencies();
    await this.checkEnvironment();
    await this.checkSecurity();
    await this.checkDatabase();

    this.printSummary();
    return this.failed === 0;
  }

  async checkTests() {
    console.log(chalk.blue('📋 Running Tests...'));
    try {
      await this.exec('npm test');
      this.pass('All tests passing');
    } catch (error) {
      this.fail('Tests failed', error.message);
    }
  }

  async checkBuild() {
    console.log(chalk.blue('\n🔨 Building Application...'));
    try {
      await this.exec('npm run build');
      this.pass('Build successful');
    } catch (error) {
      this.fail('Build failed', error.message);
    }
  }

  async checkDependencies() {
    console.log(chalk.blue('\n📦 Checking Dependencies...'));
    try {
      const result = await this.exec('npm audit --audit-level=high');
      if (result.includes('0 vulnerabilities')) {
        this.pass('No high/critical vulnerabilities');
      } else {
        this.fail('Security vulnerabilities found');
      }
    } catch (error) {
      this.fail('Dependency check failed', error.message);
    }
  }

  async checkEnvironment() {
    console.log(chalk.blue('\n🌍 Checking Environment...'));

    const required = [
      'DATABASE_URL',
      'JWT_SECRET',
      'API_KEY',
      'REDIS_URL'
    ];

    for (const envVar of required) {
      if (process.env[envVar]) {
        this.pass(`${envVar} is set`);
      } else {
        this.fail(`${envVar} is missing`);
      }
    }
  }

  async checkSecurity() {
    console.log(chalk.blue('\n🔒 Security Checks...'));

    // Check for secrets in code
    try {
      const result = await this.exec('git secrets --scan');
      this.pass('No secrets found in code');
    } catch (error) {
      this.fail('Secrets detected in code');
    }

    // Check HTTPS
    if (process.env.FORCE_HTTPS === 'true') {
      this.pass('HTTPS enforced');
    } else {
      this.fail('HTTPS not enforced');
    }
  }

  async checkDatabase() {
    console.log(chalk.blue('\n💾 Database Checks...'));

    // Check migrations are up to date
    try {
      await this.exec('npm run db:check-migrations');
      this.pass('Database migrations ready');
    } catch (error) {
      this.fail('Database migration issues');
    }
  }

  pass(message) {
    console.log(chalk.green(`  ✓ ${message}`));
    this.passed++;
  }

  fail(message, details = '') {
    console.log(chalk.red(`  ✗ ${message}`));
    if (details) {
      console.log(chalk.gray(`    ${details}`));
    }
    this.failed++;
  }

  printSummary() {
    console.log(chalk.bold('\n📊 Summary\n'));
    console.log(chalk.green(`  Passed: ${this.passed}`));
    console.log(chalk.red(`  Failed: ${this.failed}`));

    if (this.failed === 0) {
      console.log(chalk.green.bold('\n✅ READY FOR DEPLOYMENT\n'));
    } else {
      console.log(chalk.red.bold('\n❌ NOT READY FOR DEPLOYMENT\n'));
      process.exit(1);
    }
  }

  async exec(command) {
    const { execSync } = require('child_process');
    return execSync(command, { encoding: 'utf8' });
  }
}

// Run checks
const checker = new DeploymentChecker();
checker.runChecks();
```

## Deployment Report Template

```markdown
# Deployment Readiness Report

**Environment**: Production
**Date**: 2024-01-