@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/core/deploy-workflow.ts

@@ -0,0 +1,1085 @@
+/**
+ * Bootspring Deploy Workflow Engine
+ *
+ * Handles deployment workflows with pre-deployment validation,
+ * target detection, and execution.
+ *
+ * @package bootspring
+ * @module core/deploy-workflow
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import { execSync, spawn, ChildProcess } from 'child_process';
+import * as http from 'http';
+import * as https from 'https';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface DeployTarget {
+  name: string;
+  description: string;
+  detect: string[];
+  cli: string;
+  installCmd: string;
+  deployCmd: string;
+  previewCmd: string;
+  frameworks: string[];
+  envFile: string;
+  docs: string;
+}
+
+export interface DeployPhase {
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+export interface DeployPhaseState {
+  name: string;
+  status: PhaseStatus;
+  required: boolean;
+  startedAt: string | null;
+  completedAt: string | null;
+  result: unknown;
+  error: string | null;
+}
+
+export interface DeployConfig {
+  dryRun: boolean;
+  skipQuality: boolean;
+  env: string;
+}
+
+export interface DeployHistoryEntry {
+  phase: string;
+  action: string;
+  timestamp: string;
+}
+
+export interface DeployWorkflowState {
+  version: string;
+  startedAt: string;
+  lastUpdated: string;
+  target: string | null;
+  phases: Record<string, DeployPhaseState>;
+  config: DeployConfig;
+  history: DeployHistoryEntry[];
+}
+
+export interface ValidationResult {
+  passed: boolean;
+  checks: {
+    packageJson: boolean;
+    nodeModules: boolean;
+    buildScript: boolean;
+    gitClean: boolean;
+    envFile: boolean;
+  };
+  issues: string[];
+  warnings: string[];
+  summary: string;
+}
+
+export interface DetectedTarget {
+  id: string;
+  name: string;
+  file: string;
+  confidence: string;
+}
+
+export interface AvailableTarget {
+  id: string;
+  name: string;
+  cli: string;
+}
+
+export interface RecommendedTarget {
+  id: string;
+  name: string;
+  reason: string;
+}
+
+export interface TargetDetectionResult {
+  detected: DetectedTarget[];
+  available: AvailableTarget[];
+  recommendations: RecommendedTarget[];
+  framework: string | null;
+  selected: string | null;
+}
+
+export interface BuildResult {
+  success?: boolean | undefined;
+  dryRun?: boolean | undefined;
+  command: string;
+  skipped?: boolean | undefined;
+  output?: string | undefined;
+}
+
+export interface QualityCheckResult {
+  passed: boolean | null;
+  output: string;
+}
+
+export interface QualityChecksResult {
+  passed?: boolean | undefined;
+  skipped?: boolean | undefined;
+  checks?: Record<string, QualityCheckResult> | undefined;
+  summary?: string | undefined;
+}
+
+export interface DeployResult {
+  success?: boolean | undefined;
+  dryRun?: boolean | undefined;
+  target: string;
+  command?: string | undefined;
+  skipped?: boolean | undefined;
+  url?: string | null | undefined;
+  output?: string | undefined;
+}
+
+export interface VerificationResult {
+  passed?: boolean | undefined;
+  skipped?: boolean | undefined;
+  reason?: string | undefined;
+  statusCode?: number | undefined;
+  url?: string | undefined;
+  error?: string | undefined;
+}
+
+export interface DeployProgress {
+  phases: Array<DeployPhaseState & { id: string }>;
+  target: string | null;
+  overall: {
+    completed: number;
+    total: number;
+    percentage: number;
+  };
+  startedAt: string;
+  lastUpdated: string;
+  isComplete: boolean;
+}
+
+export interface TargetConfig {
+  file: string;
+  content: string;
+}
+
+export interface TargetInfo {
+  id: string;
+  name: string;
+  description: string;
+  detect: string[];
+  cli: string;
+  installCmd: string;
+  deployCmd: string;
+  previewCmd: string;
+  frameworks: string[];
+  envFile: string;
+  docs: string;
+}
+
+export interface DeployWorkflowOptions {
+  dryRun?: boolean | undefined;
+  skipQuality?: boolean | undefined;
+  env?: string | undefined;
+}
+
+type PhaseStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'failed';
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+/**
+ * Deployment targets configuration
+ */
+export const DEPLOY_TARGETS: Record<string, DeployTarget> = {
+  vercel: {
+    name: 'Vercel',
+    description: 'Deploy to Vercel (recommended for Next.js)',
+    detect: ['vercel.json', '.vercel'],
+    cli: 'vercel',
+    installCmd: 'npm install -g vercel',
+    deployCmd: 'vercel --prod',
+    previewCmd: 'vercel',
+    frameworks: ['nextjs', 'react', 'vue', 'svelte', 'nuxt', 'astro'],
+    envFile: '.env.production',
+    docs: 'https://vercel.com/docs'
+  },
+  railway: {
+    name: 'Railway',
+    description: 'Deploy to Railway (great for full-stack apps)',
+    detect: ['railway.json', 'railway.toml', '.railway'],
+    cli: 'railway',
+    installCmd: 'npm install -g @railway/cli',
+    deployCmd: 'railway up',
+    previewCmd: 'railway up --detach',
+    frameworks: ['nextjs', 'node', 'python', 'go', 'rust'],
+    envFile: '.env.production',
+    docs: 'https://docs.railway.app'
+  },
+  fly: {
+    name: 'Fly.io',
+    description: 'Deploy to Fly.io (edge deployment)',
+    detect: ['fly.toml'],
+    cli: 'fly',
+    installCmd: 'curl -L https://fly.io/install.sh | sh',
+    deployCmd: 'fly deploy',
+    previewCmd: 'fly deploy --build-only',
+    frameworks: ['docker', 'node', 'go', 'rust', 'python'],
+    envFile: '.env.production',
+    docs: 'https://fly.io/docs'
+  },
+  netlify: {
+    name: 'Netlify',
+    description: 'Deploy to Netlify (static sites & serverless)',
+    detect: ['netlify.toml', '.netlify'],
+    cli: 'netlify',
+    installCmd: 'npm install -g netlify-cli',
+    deployCmd: 'netlify deploy --prod',
+    previewCmd: 'netlify deploy',
+    frameworks: ['react', 'vue', 'svelte', 'gatsby', 'astro', 'nextjs'],
+    envFile: '.env.production',
+    docs: 'https://docs.netlify.com'
+  },
+  docker: {
+    name: 'Docker',
+    description: 'Build Docker image for deployment',
+    detect: ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml'],
+    cli: 'docker',
+    installCmd: 'Install Docker Desktop from https://docker.com',
+    deployCmd: 'docker build -t app . && docker push',
+    previewCmd: 'docker build -t app .',
+    frameworks: ['any'],
+    envFile: '.env.production',
+    docs: 'https://docs.docker.com'
+  },
+  aws: {
+    name: 'AWS Amplify',
+    description: 'Deploy to AWS Amplify',
+    detect: ['amplify.yml', 'amplify'],
+    cli: 'amplify',
+    installCmd: 'npm install -g @aws-amplify/cli',
+    deployCmd: 'amplify push',
+    previewCmd: 'amplify status',
+    frameworks: ['react', 'nextjs', 'vue', 'angular'],
+    envFile: '.env.production',
+    docs: 'https://docs.amplify.aws'
+  }
+};
+
+/**
+ * Deployment phases
+ */
+export const DEPLOY_PHASES: Record<string, DeployPhase> = {
+  validate: {
+    name: 'Pre-flight Validation',
+    description: 'Validate project readiness for deployment',
+    required: true
+  },
+  target: {
+    name: 'Target Detection',
+    description: 'Detect or configure deployment target',
+    required: true
+  },
+  build: {
+    name: 'Build',
+    description: 'Build production assets',
+    required: true
+  },
+  quality: {
+    name: 'Quality Checks',
+    description: 'Run pre-deploy quality gates',
+    required: false
+  },
+  deploy: {
+    name: 'Deploy',
+    description: 'Execute deployment',
+    required: true
+  },
+  verify: {
+    name: 'Verification',
+    description: 'Verify deployment success',
+    required: false
+  }
+};
+
+// ============================================================================
+// DeployWorkflowEngine Class
+// ============================================================================
+
+/**
+ * DeployWorkflowEngine class
+ */
+export class DeployWorkflowEngine {
+  readonly projectRoot: string;
+  readonly bootspringDir: string;
+  readonly deployDir: string;
+  readonly statePath: string;
+  readonly options: DeployWorkflowOptions;
+  state: DeployWorkflowState | null;
+
+  constructor(projectRoot: string, options: DeployWorkflowOptions = {}) {
+    this.projectRoot = projectRoot;
+    this.bootspringDir = path.join(projectRoot, '.bootspring');
+    this.deployDir = path.join(this.bootspringDir, 'deploy');
+    this.statePath = path.join(this.deployDir, 'workflow-state.json');
+    this.options = options;
+    this.state = null;
+  }
+
+  /**
+   * Check if workflow exists
+   */
+  hasWorkflow(): boolean {
+    return fs.existsSync(this.statePath);
+  }
+
+  /**
+   * Initialize workflow
+   */
+  initializeWorkflow(target: string | null = null): void {
+    // Ensure directories exist
+    if (!fs.existsSync(this.deployDir)) {
+      fs.mkdirSync(this.deployDir, { recursive: true });
+    }
+
+    this.state = {
+      version: '1.0.0',
+      startedAt: new Date().toISOString(),
+      lastUpdated: new Date().toISOString(),
+      target: target,
+      phases: {},
+      config: {
+        dryRun: this.options.dryRun ?? false,
+        skipQuality: this.options.skipQuality ?? false,
+        env: this.options.env ?? 'production'
+      },
+      history: []
+    };
+
+    // Initialize phases
+    for (const [phaseId, phase] of Object.entries(DEPLOY_PHASES)) {
+      this.state.phases[phaseId] = {
+        name: phase.name,
+        status: 'pending',
+        required: phase.required,
+        startedAt: null,
+        completedAt: null,
+        result: null,
+        error: null
+      };
+    }
+
+    this.saveState();
+  }
+
+  /**
+   * Load state
+   */
+  loadState(): DeployWorkflowState | null {
+    if (fs.existsSync(this.statePath)) {
+      this.state = JSON.parse(fs.readFileSync(this.statePath, 'utf-8')) as DeployWorkflowState;
+    }
+    return this.state;
+  }
+
+  /**
+   * Save state
+   */
+  saveState(): void {
+    if (!this.state) return;
+    this.state.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+  }
+
+  /**
+   * Get next phase
+   */
+  getNextPhase(): string | null {
+    if (!this.state) return null;
+
+    const phaseOrder = ['validate', 'target', 'build', 'quality', 'deploy', 'verify'];
+
+    for (const phaseId of phaseOrder) {
+      const phase = this.state.phases[phaseId];
+      if (phase && (phase.status === 'pending' || phase.status === 'in_progress')) {
+        return phaseId;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Start phase
+   */
+  startPhase(phaseId: string): void {
+    if (!this.state) return;
+    const phase = this.state.phases[phaseId];
+    if (!phase) return;
+
+    phase.status = 'in_progress';
+    phase.startedAt = new Date().toISOString();
+    this.saveState();
+  }
+
+  /**
+   * Complete phase
+   */
+  completePhase(phaseId: string, result: unknown = null): void {
+    if (!this.state) return;
+    const phase = this.state.phases[phaseId];
+    if (!phase) return;
+
+    phase.status = 'completed';
+    phase.completedAt = new Date().toISOString();
+    phase.result = result;
+    this.state.history.push({
+      phase: phaseId,
+      action: 'completed',
+      timestamp: new Date().toISOString()
+    });
+    this.saveState();
+  }
+
+  /**
+   * Fail phase
+   */
+  failPhase(phaseId: string, error: string): void {
+    if (!this.state) return;
+    const phase = this.state.phases[phaseId];
+    if (!phase) return;
+
+    phase.status = 'failed';
+    phase.completedAt = new Date().toISOString();
+    phase.error = error;
+    this.saveState();
+  }
+
+  /**
+   * Skip phase
+   */
+  skipPhase(phaseId: string): void {
+    if (!this.state) return;
+    const phase = this.state.phases[phaseId];
+    if (!phase) return;
+
+    phase.status = 'skipped';
+    this.saveState();
+  }
+
+  /**
+   * Get progress
+   */
+  getProgress(): DeployProgress | null {
+    if (!this.state) return null;
+
+    const phases = Object.entries(this.state.phases).map(([id, phase]) => ({
+      id,
+      ...phase
+    }));
+
+    const completed = phases.filter(p => p.status === 'completed').length;
+    const total = phases.filter(p => p.required).length;
+
+    return {
+      phases,
+      target: this.state.target,
+      overall: {
+        completed,
+        total,
+        percentage: Math.round((completed / total) * 100)
+      },
+      startedAt: this.state.startedAt,
+      lastUpdated: this.state.lastUpdated,
+      isComplete: phases.every(p =>
+        p.status === 'completed' || p.status === 'skipped' || !p.required
+      )
+    };
+  }
+
+  /**
+   * Reset workflow
+   */
+  resetWorkflow(): void {
+    if (fs.existsSync(this.deployDir)) {
+      fs.rmSync(this.deployDir, { recursive: true });
+    }
+    this.state = null;
+  }
+
+  // ==========================================
+  // Phase Implementations
+  // ==========================================
+
+  /**
+   * Run validation phase
+   */
+  async runValidation(): Promise<ValidationResult> {
+    const checks = {
+      packageJson: false,
+      nodeModules: false,
+      buildScript: false,
+      gitClean: false,
+      envFile: false
+    };
+
+    const issues: string[] = [];
+    const warnings: string[] = [];
+
+    // Check package.json
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      checks.packageJson = true;
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
+        scripts?: Record<string, string>;
+      };
+
+      // Check build script
+      if (pkg.scripts?.build) {
+        checks.buildScript = true;
+      } else {
+        issues.push('No build script found in package.json');
+      }
+    } else {
+      issues.push('No package.json found');
+    }
+
+    // Check node_modules
+    if (fs.existsSync(path.join(this.projectRoot, 'node_modules'))) {
+      checks.nodeModules = true;
+    } else {
+      warnings.push('node_modules not found - run npm install first');
+    }
+
+    // Check git status
+    try {
+      const gitStatus = execSync('git status --porcelain', {
+        cwd: this.projectRoot,
+        encoding: 'utf-8'
+      });
+      if (!gitStatus.trim()) {
+        checks.gitClean = true;
+      } else {
+        warnings.push('Uncommitted changes detected');
+      }
+    } catch {
+      warnings.push('Not a git repository');
+    }
+
+    // Check .env.production or .env.local
+    const envPaths = ['.env.production', '.env.local', '.env'];
+    for (const envPath of envPaths) {
+      if (fs.existsSync(path.join(this.projectRoot, envPath))) {
+        checks.envFile = true;
+        break;
+      }
+    }
+    if (!checks.envFile) {
+      warnings.push('No environment file found (.env.production, .env.local, or .env)');
+    }
+
+    const passed = issues.length === 0;
+
+    return {
+      passed,
+      checks,
+      issues,
+      warnings,
+      summary: passed ? 'Validation passed' : `${issues.length} issues found`
+    };
+  }
+
+  /**
+   * Detect deployment target
+   */
+  async detectTarget(): Promise<TargetDetectionResult> {
+    const detected: DetectedTarget[] = [];
+    const recommendations: RecommendedTarget[] = [];
+
+    // Check for existing configs
+    for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+      for (const detectFile of target.detect) {
+        const filePath = path.join(this.projectRoot, detectFile);
+        if (fs.existsSync(filePath)) {
+          detected.push({
+            id: targetId,
+            name: target.name,
+            file: detectFile,
+            confidence: 'high'
+          });
+          break;
+        }
+      }
+    }
+
+    // Check CLI availability
+    const available: AvailableTarget[] = [];
+    for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+      if (this.checkCliInstalled(target.cli)) {
+        available.push({
+          id: targetId,
+          name: target.name,
+          cli: target.cli
+        });
+      }
+    }
+
+    // Detect framework and recommend
+    const framework = this.detectFramework();
+    if (framework) {
+      for (const [targetId, target] of Object.entries(DEPLOY_TARGETS)) {
+        if (target.frameworks.includes(framework) || target.frameworks.includes('any')) {
+          recommendations.push({
+            id: targetId,
+            name: target.name,
+            reason: `Works well with ${framework}`
+          });
+        }
+      }
+    }
+
+    // Set state target if exactly one detected
+    const firstDetected = detected[0];
+    if (detected.length === 1 && firstDetected && this.state && !this.state.target) {
+      this.state.target = firstDetected.id;
+    }
+
+    return {
+      detected,
+      available,
+      recommendations,
+      framework,
+      selected: this.state?.target ?? null
+    };
+  }
+
+  /**
+   * Check if CLI is installed
+   */
+  checkCliInstalled(cli: string): boolean {
+    try {
+      execSync(`which ${cli}`, { encoding: 'utf-8', stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Detect framework
+   */
+  detectFramework(): string | null {
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) return null;
+
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
+      dependencies?: Record<string, string>;
+      devDependencies?: Record<string, string>;
+    };
+    const deps: Record<string, string> = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps.next) return 'nextjs';
+    if (deps['@angular/core']) return 'angular';
+    if (deps.vue) return 'vue';
+    if (deps.svelte) return 'svelte';
+    if (deps.gatsby) return 'gatsby';
+    if (deps.astro) return 'astro';
+    if (deps.nuxt) return 'nuxt';
+    if (deps.react) return 'react';
+    if (deps.express) return 'node';
+
+    return null;
+  }
+
+  /**
+   * Set target
+   */
+  setTarget(targetId: string): void {
+    if (!DEPLOY_TARGETS[targetId]) {
+      throw new Error(`Unknown target: ${targetId}`);
+    }
+    if (this.state) {
+      this.state.target = targetId;
+      this.saveState();
+    }
+  }
+
+  /**
+   * Run build phase
+   */
+  async runBuild(): Promise<BuildResult> {
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
+      scripts?: Record<string, string>;
+    };
+
+    const buildScript = pkg.scripts?.build;
+    if (!buildScript) {
+      throw new Error('No build script found');
+    }
+
+    if (this.state?.config.dryRun) {
+      return {
+        dryRun: true,
+        command: 'npm run build',
+        skipped: true
+      };
+    }
+
+    // Execute build
+    return new Promise((resolve, reject) => {
+      const buildProcess: ChildProcess = spawn('npm', ['run', 'build'], {
+        cwd: this.projectRoot,
+        stdio: 'pipe',
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      buildProcess.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      buildProcess.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      buildProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+            command: 'npm run build',
+            output: stdout.slice(-500) // Last 500 chars
+          });
+        } else {
+          reject(new Error(`Build failed with code ${code}: ${stderr.slice(-200)}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * Run quality checks
+   */
+  async runQualityChecks(): Promise<QualityChecksResult> {
+    if (this.state?.config.skipQuality) {
+      return { skipped: true };
+    }
+
+    const lintCheck: QualityCheckResult = { passed: null, output: '' };
+    const typecheckCheck: QualityCheckResult = { passed: null, output: '' };
+    const testCheck: QualityCheckResult = { passed: null, output: '' };
+
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as {
+      scripts?: Record<string, string>;
+    };
+
+    // Run lint if available
+    if (pkg.scripts?.lint) {
+      try {
+        execSync('npm run lint', { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        lintCheck.passed = true;
+      } catch (error) {
+        lintCheck.passed = false;
+        lintCheck.output = (error as Error).message;
+      }
+    }
+
+    // Run typecheck if TypeScript
+    if (pkg.scripts?.typecheck || pkg.scripts?.['type-check']) {
+      const script = pkg.scripts.typecheck ? 'typecheck' : 'type-check';
+      try {
+        execSync(`npm run ${script}`, { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        typecheckCheck.passed = true;
+      } catch (error) {
+        typecheckCheck.passed = false;
+        typecheckCheck.output = (error as Error).message;
+      }
+    }
+
+    // Run tests if available (but don't fail deploy on test failure)
+    if (pkg.scripts?.test) {
+      try {
+        execSync('npm test -- --passWithNoTests', { cwd: this.projectRoot, encoding: 'utf-8', stdio: 'pipe' });
+        testCheck.passed = true;
+      } catch {
+        testCheck.passed = false;
+        // Don't fail on test failures, just warn
+      }
+    }
+
+    const checks: Record<string, QualityCheckResult> = {
+      lint: lintCheck,
+      typecheck: typecheckCheck,
+      test: testCheck
+    };
+
+    const allPassed = Object.values(checks).every(c => c.passed === null || c.passed === true);
+
+    return {
+      passed: allPassed,
+      checks,
+      summary: allPassed ? 'All quality checks passed' : 'Some checks failed'
+    };
+  }
+
+  /**
+   * Run deployment
+   */
+  async runDeploy(): Promise<DeployResult> {
+    if (!this.state?.target) {
+      throw new Error('No deployment target configured');
+    }
+
+    const target = DEPLOY_TARGETS[this.state.target];
+    if (!target) {
+      throw new Error('No deployment target configured');
+    }
+
+    // Check CLI is installed
+    if (!this.checkCliInstalled(target.cli)) {
+      throw new Error(`${target.cli} CLI not installed. Run: ${target.installCmd}`);
+    }
+
+    if (this.state.config.dryRun) {
+      return {
+        dryRun: true,
+        target: target.name,
+        command: target.deployCmd,
+        skipped: true
+      };
+    }
+
+    // Execute deployment
+    const deployCmd = this.state.config.env === 'preview' ? target.previewCmd : target.deployCmd;
+
+    return new Promise((resolve, reject) => {
+      const deployProcess: ChildProcess = spawn(deployCmd, [], {
+        cwd: this.projectRoot,
+        stdio: 'pipe',
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      deployProcess.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+        process.stdout.write(data);
+      });
+
+      deployProcess.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+        process.stderr.write(data);
+      });
+
+      deployProcess.on('close', (code) => {
+        if (code === 0) {
+          // Try to extract URL from output
+          const urlMatch = stdout.match(/https?:\/\/[^\s]+/);
+          resolve({
+            success: true,
+            target: target.name,
+            url: urlMatch ? urlMatch[0] : null,
+            output: stdout.slice(-500)
+          });
+        } else {
+          reject(new Error(`Deployment failed with code ${code}`));
+        }
+      });
+    });
+  }
+
+  /**
+   * Run verification
+   */
+  async runVerification(): Promise<VerificationResult> {
+    if (!this.state) {
+      return {
+        skipped: true,
+        reason: 'No workflow state'
+      };
+    }
+
+    const deployResult = this.state.phases.deploy?.result as { url?: string } | null | undefined;
+
+    if (!deployResult?.url) {
+      return {
+        skipped: true,
+        reason: 'No deployment URL available'
+      };
+    }
+
+    // Simple HTTP check
+    try {
+      const protocol = deployResult.url.startsWith('https') ? https : http;
+
+      return new Promise((resolve) => {
+        const req = protocol.get(deployResult.url!, (res) => {
+          resolve({
+            passed: (res.statusCode ?? 0) >= 200 && (res.statusCode ?? 0) < 400,
+            statusCode: res.statusCode,
+            url: deployResult.url
+          });
+        });
+
+        req.on('error', () => {
+          resolve({
+            passed: false,
+            error: 'Could not reach deployment URL'
+          });
+        });
+
+        req.setTimeout(10000, () => {
+          req.destroy();
+          resolve({
+            passed: false,
+            error: 'Request timed out'
+          });
+        });
+      });
+    } catch {
+      return {
+        skipped: true,
+        reason: 'Verification not available'
+      };
+    }
+  }
+
+  /**
+   * Get target info
+   */
+  getTargetInfo(targetId: string): TargetInfo | null {
+    const target = DEPLOY_TARGETS[targetId];
+    if (!target) return null;
+
+    return {
+      id: targetId,
+      ...target
+    };
+  }
+
+  /**
+   * Get all targets
+   */
+  getAllTargets(): TargetInfo[] {
+    return Object.entries(DEPLOY_TARGETS).map(([id, target]) => ({
+      id,
+      ...target
+    }));
+  }
+
+  /**
+   * Generate deployment config for target
+   */
+  generateTargetConfig(targetId: string): TargetConfig | null {
+    const target = DEPLOY_TARGETS[targetId];
+    if (!target) return null;
+
+    switch (targetId) {
+      case 'vercel':
+        return {
+          file: 'vercel.json',
+          content: JSON.stringify({
+            '$schema': 'https://openapi.vercel.sh/vercel.json',
+            'buildCommand': 'npm run build',
+            'devCommand': 'npm run dev',
+            'installCommand': 'npm install'
+          }, null, 2)
+        };
+
+      case 'railway':
+        return {
+          file: 'railway.toml',
+          content: `[build]
+builder = "nixpacks"
+
+[deploy]
+startCommand = "npm start"
+restartPolicyType = "on_failure"
+restartPolicyMaxRetries = 3
+`
+        };
+
+      case 'fly':
+        return {
+          file: 'fly.toml',
+          content: `app = "my-app"
+primary_region = "iad"
+
+[build]
+  builder = "heroku/buildpacks:20"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+`
+        };
+
+      case 'netlify':
+        return {
+          file: 'netlify.toml',
+          content: `[build]
+  command = "npm run build"
+  publish = ".next"
+
+[[plugins]]
+  package = "@netlify/plugin-nextjs"
+`
+        };
+
+      case 'docker':
+        return {
+          file: 'Dockerfile',
+          content: `FROM node:20-alpine AS base
+
+FROM base AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+FROM base AS runner
+WORKDIR /app
+ENV NODE_ENV production
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/.next/standalone ./
+COPY --from=builder /app/.next/static ./.next/static
+
+EXPOSE 3000
+ENV PORT 3000
+CMD ["node", "server.js"]
+`
+        };
+
+      default:
+        return null;
+    }
+  }
+}
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+export function createDeployWorkflowEngine(
+  projectRoot: string,
+  options: DeployWorkflowOptions = {}
+): DeployWorkflowEngine {
+  return new DeployWorkflowEngine(projectRoot, options);
+}