@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/deploy.ts

@@ -0,0 +1,704 @@
+/**
+ * Bootspring Deploy CLI
+ *
+ * Deploy projects to various hosting platforms with
+ * pre-deployment validation and quality checks.
+ *
+ * @package bootspring
+ * @module cli/deploy
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Type interfaces for JS modules
+interface Colors {
+  reset: string;
+  bold: string;
+  dim: string;
+  cyan: string;
+  green: string;
+  yellow: string;
+  red: string;
+}
+
+interface PrintModule {
+  header(msg: string): void;
+  info(msg: string): void;
+  success(msg: string): void;
+  warning(msg: string): void;
+  error(msg: string): void;
+}
+
+interface UtilsModule {
+  COLORS: Colors;
+  print: PrintModule;
+  parseArgs(args: string[]): ParsedArgs;
+  createSpinner(text: string): Spinner;
+}
+
+interface ParsedArgs {
+  _: string[];
+  preview?: boolean | undefined;
+  'skip-quality'?: boolean | undefined;
+  'dry-run'?: boolean | undefined;
+  force?: boolean | undefined;
+}
+
+interface Spinner {
+  start(): Spinner;
+  stop(): void;
+  succeed(text: string): void;
+  fail(text: string): void;
+  warn(text: string): void;
+  info(text: string): void;
+  text: string;
+}
+
+interface DeployPhase {
+  name: string;
+  required: boolean;
+}
+
+interface DeployTarget {
+  id: string;
+  name: string;
+  description: string;
+  cli: string;
+  installCmd: string;
+  deployCmd: string;
+}
+
+interface DeployProgress {
+  isComplete: boolean;
+  overall: {
+    percentage: number;
+  };
+  target?: string | undefined;
+  startedAt?: string | undefined;
+  phases: Array<{
+    name: string;
+    status: string;
+    required: boolean;
+  }>;
+}
+
+interface ValidationResult {
+  passed: boolean;
+  checks: Record<string, boolean>;
+  issues: string[];
+  warnings: string[];
+}
+
+interface TargetDetectionResult {
+  selected?: string | undefined;
+  detected: Array<{ id: string; name: string }>;
+  available: Array<{ name: string }>;
+  framework?: string | undefined;
+  recommendations: Array<{ id: string }>;
+}
+
+interface BuildResult {
+  dryRun?: boolean | undefined;
+}
+
+interface QualityResult {
+  passed: boolean;
+  skipped: boolean;
+  checks: Record<string, { passed: boolean | null }>;
+}
+
+interface DeployResult {
+  target: string;
+  url?: string | undefined;
+  dryRun?: boolean | undefined;
+  success?: boolean | undefined;
+}
+
+interface VerifyResult {
+  passed: boolean;
+  skipped: boolean;
+  statusCode?: number | undefined;
+  dryRun?: boolean | undefined;
+}
+
+interface GeneratedConfig {
+  file: string;
+  content: string;
+}
+
+interface PhaseData {
+  result?: DeployResult | undefined;
+}
+
+interface WorkflowState {
+  target: string;
+  phases: Record<string, PhaseData>;
+}
+
+interface DeployWorkflowEngineInstance {
+  hasWorkflow(): boolean;
+  loadState(): void;
+  getProgress(): DeployProgress;
+  initializeWorkflow(target: string | null): void;
+  getNextPhase(): string | null;
+  startPhase(phaseId: string): void;
+  completePhase(phaseId: string, result: unknown): void;
+  failPhase(phaseId: string, message: string): void;
+  skipPhase(phaseId: string): void;
+  runValidation(): Promise<ValidationResult>;
+  detectTarget(): Promise<TargetDetectionResult>;
+  setTarget(targetId: string): void;
+  runBuild(): Promise<BuildResult>;
+  runQualityChecks(): Promise<QualityResult>;
+  runDeploy(): Promise<DeployResult>;
+  runVerification(): Promise<VerifyResult>;
+  getTargetInfo(targetId: string): DeployTarget;
+  getAllTargets(): DeployTarget[];
+  checkCliInstalled(cli: string): boolean;
+  generateTargetConfig(targetId: string): GeneratedConfig | null;
+  resetWorkflow(): void;
+  state: WorkflowState;
+}
+
+interface DeployWorkflowEngineClass {
+  new (projectRoot: string, options?: { dryRun?: boolean; skipQuality?: boolean; env?: string }): DeployWorkflowEngineInstance;
+}
+
+interface DeployWorkflowModule {
+  DeployWorkflowEngine: DeployWorkflowEngineClass;
+  DEPLOY_TARGETS: Record<string, DeployTarget>;
+  DEPLOY_PHASES: Record<string, DeployPhase>;
+}
+
+const utils = require('../core/utils') as UtilsModule;
+const { DeployWorkflowEngine, DEPLOY_TARGETS, DEPLOY_PHASES } = require('../core/deploy-workflow') as DeployWorkflowModule;
+
+// Get project root
+const projectRoot = process.cwd();
+
+/**
+ * Show deploy help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.bold}Bootspring Deploy${utils.COLORS.reset}
+Deploy your project to production
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring deploy                    Deploy to detected/configured target
+  bootspring deploy <target>           Deploy to specific target
+  bootspring deploy status             Show deployment status
+  bootspring deploy targets            List available targets
+  bootspring deploy init <target>      Initialize deployment config
+  bootspring deploy reset              Reset deployment state
+
+${utils.COLORS.bold}Targets:${utils.COLORS.reset}
+  vercel        Vercel (recommended for Next.js)
+  railway       Railway (full-stack apps)
+  fly           Fly.io (edge deployment)
+  netlify       Netlify (static sites & serverless)
+  docker        Docker (build image)
+  aws           AWS Amplify
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --preview                Preview deployment (not production)
+  --skip-quality           Skip quality checks
+  --dry-run                Show what would be deployed
+  --force                  Force deployment even with warnings
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring deploy                    # Auto-detect and deploy
+  bootspring deploy vercel             # Deploy to Vercel
+  bootspring deploy --preview          # Deploy preview
+  bootspring deploy init vercel        # Create vercel.json
+  bootspring deploy targets            # List all targets
+`);
+}
+
+/**
+ * Start deployment workflow
+ */
+async function deployStart(args: ParsedArgs): Promise<void> {
+  const target = args._[0] || null;
+  const preview = args.preview || false;
+  const skipQuality = args['skip-quality'] || false;
+  const dryRun = args['dry-run'] || false;
+  const force = args.force || false;
+
+  const workflow = new DeployWorkflowEngine(projectRoot, {
+    dryRun,
+    skipQuality,
+    env: preview ? 'preview' : 'production'
+  });
+
+  // Check for existing workflow
+  if (workflow.hasWorkflow()) {
+    workflow.loadState();
+    const progress = workflow.getProgress();
+
+    if (!progress.isComplete) {
+      utils.print.info('Existing deployment in progress.');
+      console.log(`  Progress: ${progress.overall.percentage}% complete`);
+      console.log(`  Target: ${progress.target || 'not set'}`);
+      console.log('');
+      utils.print.info('Use "bootspring deploy reset" to start fresh');
+      return;
+    }
+  }
+
+  // Initialize workflow
+  utils.print.header('Bootspring Deploy');
+  console.log(preview ? 'Preview deployment' : 'Production deployment');
+  if (dryRun) {
+    console.log(`${utils.COLORS.yellow}[DRY RUN]${utils.COLORS.reset}`);
+  }
+  console.log('');
+
+  workflow.initializeWorkflow(target);
+
+  // Run workflow
+  await runWorkflowLoop(workflow, { force, dryRun });
+}
+
+/**
+ * Run the workflow loop
+ */
+async function runWorkflowLoop(workflow: DeployWorkflowEngineInstance, options: { force?: boolean; dryRun?: boolean } = {}): Promise<void> {
+  while (true) {
+    const nextPhaseId = workflow.getNextPhase();
+
+    if (!nextPhaseId) {
+      break;
+    }
+
+    const phase = DEPLOY_PHASES[nextPhaseId];
+
+    // Run the phase
+    workflow.startPhase(nextPhaseId);
+    const spinner = utils.createSpinner(`${phase?.name || nextPhaseId}...`).start();
+
+    try {
+      let result: unknown;
+
+      switch (nextPhaseId) {
+        case 'validate':
+          result = await workflow.runValidation();
+          if ((result as ValidationResult).passed) {
+            spinner.succeed('Pre-flight validation passed');
+          } else {
+            spinner.fail('Pre-flight validation failed');
+            displayValidationResults(result as ValidationResult);
+            if (!options.force) {
+              utils.print.error('Fix issues above or use --force to continue');
+              workflow.failPhase(nextPhaseId, 'Validation failed');
+              return;
+            }
+            utils.print.warning('Continuing with --force');
+          }
+          displayValidationResults(result as ValidationResult);
+          break;
+
+        case 'target':
+          result = await workflow.detectTarget();
+          if ((result as TargetDetectionResult).selected) {
+            const target = workflow.getTargetInfo((result as TargetDetectionResult).selected as string);
+            spinner.succeed(`Target: ${target.name}`);
+          } else if ((result as TargetDetectionResult).detected.length > 0) {
+            const detected = (result as TargetDetectionResult).detected;
+            spinner.succeed(`Detected: ${detected.map(t => t.name).join(', ')}`);
+            // Auto-select first detected
+            workflow.setTarget(detected[0]?.id || '');
+            (result as TargetDetectionResult).selected = detected[0]?.id;
+          } else {
+            spinner.fail('No deployment target detected');
+            displayTargetSelection(result as TargetDetectionResult);
+            utils.print.error('Run "bootspring deploy init <target>" to configure');
+            workflow.failPhase(nextPhaseId, 'No target');
+            return;
+          }
+          displayTargetResults(result as TargetDetectionResult);
+          break;
+
+        case 'build':
+          if (options.dryRun) {
+            spinner.info('Build: [DRY RUN] Would run npm run build');
+            result = { dryRun: true };
+          } else {
+            spinner.text = 'Building...';
+            result = await workflow.runBuild();
+            spinner.succeed('Build successful');
+          }
+          break;
+
+        case 'quality':
+          result = await workflow.runQualityChecks();
+          if ((result as QualityResult).skipped) {
+            spinner.info('Quality checks skipped');
+          } else if ((result as QualityResult).passed) {
+            spinner.succeed('Quality checks passed');
+          } else {
+            spinner.warn('Some quality checks failed');
+          }
+          displayQualityResults(result as QualityResult);
+          break;
+
+        case 'deploy':
+          if (options.dryRun) {
+            const target = workflow.getTargetInfo(workflow.state.target);
+            spinner.info(`Deploy: [DRY RUN] Would run: ${target.deployCmd}`);
+            result = { dryRun: true };
+          } else {
+            spinner.text = 'Deploying...';
+            console.log('');
+            result = await workflow.runDeploy();
+            console.log('');
+            spinner.succeed(`Deployed to ${(result as DeployResult).target}`);
+            if ((result as DeployResult).url) {
+              console.log(`  ${utils.COLORS.green}URL:${utils.COLORS.reset} ${(result as DeployResult).url}`);
+            }
+          }
+          break;
+
+        case 'verify':
+          if (options.dryRun) {
+            spinner.info('Verification: [DRY RUN] Skipped');
+            result = { dryRun: true };
+          } else {
+            result = await workflow.runVerification();
+            if ((result as VerifyResult).skipped) {
+              spinner.info('Verification skipped');
+            } else if ((result as VerifyResult).passed) {
+              spinner.succeed(`Verification passed (HTTP ${(result as VerifyResult).statusCode})`);
+            } else {
+              spinner.warn('Verification failed');
+            }
+          }
+          break;
+
+        default:
+          spinner.warn(`Unknown phase: ${nextPhaseId}`);
+          workflow.skipPhase(nextPhaseId);
+          continue;
+      }
+
+      workflow.completePhase(nextPhaseId, result);
+
+    } catch (error) {
+      spinner.fail(`Failed: ${(error as Error).message}`);
+      workflow.failPhase(nextPhaseId, (error as Error).message);
+
+      if (phase?.required) {
+        utils.print.error('Deployment failed.');
+        return;
+      }
+    }
+
+    console.log('');
+  }
+
+  // Deployment complete
+  displayCompletionSummary(workflow, options);
+}
+
+/**
+ * Display validation results
+ */
+function displayValidationResults(result: ValidationResult): void {
+  console.log('');
+
+  for (const [check, passed] of Object.entries(result.checks)) {
+    const icon = passed ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+    console.log(`  ${icon} ${formatCheckName(check)}`);
+  }
+
+  if (result.issues.length > 0) {
+    console.log('');
+    console.log(`  ${utils.COLORS.red}Issues:${utils.COLORS.reset}`);
+    for (const issue of result.issues) {
+      console.log(`    - ${issue}`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    console.log('');
+    console.log(`  ${utils.COLORS.yellow}Warnings:${utils.COLORS.reset}`);
+    for (const warning of result.warnings) {
+      console.log(`    - ${warning}`);
+    }
+  }
+}
+
+/**
+ * Display target results
+ */
+function displayTargetResults(result: TargetDetectionResult): void {
+  if (result.framework) {
+    console.log(`  ${utils.COLORS.dim}Framework: ${result.framework}${utils.COLORS.reset}`);
+  }
+
+  if (result.available.length > 0 && !result.selected) {
+    console.log('');
+    console.log('  Available CLIs:');
+    for (const target of result.available.slice(0, 3)) {
+      console.log(`    ${utils.COLORS.cyan}${target.name}${utils.COLORS.reset}`);
+    }
+  }
+}
+
+/**
+ * Display target selection options
+ */
+function displayTargetSelection(result: TargetDetectionResult): void {
+  console.log('');
+  console.log('Recommended targets for your project:');
+
+  for (const rec of result.recommendations.slice(0, 3)) {
+    const target = DEPLOY_TARGETS[rec.id];
+    if (target) {
+      console.log(`  ${utils.COLORS.cyan}${rec.id}${utils.COLORS.reset} - ${target.description}`);
+    }
+  }
+
+  console.log('');
+  console.log('Run: bootspring deploy init <target>');
+}
+
+/**
+ * Display quality results
+ */
+function displayQualityResults(result: QualityResult): void {
+  if (result.skipped) return;
+
+  console.log('');
+  for (const [check, status] of Object.entries(result.checks)) {
+    if (status.passed === null) continue;
+
+    const icon = status.passed ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.yellow}○${utils.COLORS.reset}`;
+    console.log(`  ${icon} ${check}`);
+  }
+}
+
+/**
+ * Display completion summary
+ */
+function displayCompletionSummary(workflow: DeployWorkflowEngineInstance, options: { dryRun?: boolean }): void {
+  const deployResult = workflow.state.phases.deploy?.result;
+
+  console.log('');
+
+  if (options.dryRun) {
+    utils.print.info('Dry run complete - no changes made');
+    return;
+  }
+
+  if (deployResult?.url) {
+    utils.print.success('Deployment successful!');
+    console.log('');
+    console.log(`  ${utils.COLORS.bold}URL:${utils.COLORS.reset} ${deployResult.url}`);
+  } else if (deployResult?.success) {
+    utils.print.success('Deployment successful!');
+  } else {
+    utils.print.warning('Deployment completed with warnings');
+  }
+
+  console.log('');
+  utils.print.info('Next steps:');
+  console.log('  1. Verify your deployment is working');
+  console.log('  2. Set up environment variables if needed');
+  console.log('  3. Configure custom domain (optional)');
+}
+
+/**
+ * Format check name
+ */
+function formatCheckName(name: string): string {
+  const names: Record<string, string> = {
+    packageJson: 'package.json exists',
+    nodeModules: 'Dependencies installed',
+    buildScript: 'Build script available',
+    gitClean: 'Git working tree clean',
+    envFile: 'Environment file exists'
+  };
+  return names[name] || name;
+}
+
+/**
+ * Show deployment status
+ */
+async function deployStatus(): Promise<void> {
+  const workflow = new DeployWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.info('No deployment workflow started.');
+    utils.print.info('Run "bootspring deploy" to begin.');
+    return;
+  }
+
+  workflow.loadState();
+  const progress = workflow.getProgress();
+
+  utils.print.header('Deployment Status');
+
+  console.log(`Progress: ${progress.overall.percentage}% complete`);
+  console.log(`Target: ${progress.target || 'not set'}`);
+  console.log(`Started: ${progress.startedAt ? new Date(progress.startedAt).toLocaleString() : 'N/A'}`);
+  console.log('');
+
+  console.log('Phases:');
+  for (const phase of progress.phases) {
+    const statusIcon = getStatusIcon(phase.status);
+    const required = phase.required ? '' : ' (optional)';
+    console.log(`  ${statusIcon} ${phase.name}${required}`);
+  }
+
+  if (progress.isComplete) {
+    console.log('');
+    const deployResult = workflow.state.phases.deploy?.result;
+    if (deployResult?.url) {
+      console.log(`URL: ${deployResult.url}`);
+    }
+  }
+}
+
+/**
+ * List available targets
+ */
+function listTargets(): void {
+  const workflow = new DeployWorkflowEngine(projectRoot);
+
+  utils.print.header('Deployment Targets');
+  console.log('');
+
+  const targets = workflow.getAllTargets();
+
+  for (const target of targets) {
+    const installed = workflow.checkCliInstalled(target.cli);
+    const icon = installed ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+
+    console.log(`  ${icon} ${utils.COLORS.cyan}${target.id}${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}${target.description}${utils.COLORS.reset}`);
+    console.log(`    CLI: ${target.cli} ${installed ? '(installed)' : '(not installed)'}`);
+    console.log('');
+  }
+
+  console.log('Install a CLI to enable deployment:');
+  console.log(`  ${utils.COLORS.dim}npm install -g vercel${utils.COLORS.reset}`);
+}
+
+/**
+ * Initialize deployment config
+ */
+async function deployInit(args: ParsedArgs): Promise<void> {
+  const targetId = args._[1];
+
+  if (!targetId) {
+    utils.print.error('Specify a target: bootspring deploy init <target>');
+    console.log('');
+    console.log('Available targets: vercel, railway, fly, netlify, docker, aws');
+    return;
+  }
+
+  const workflow = new DeployWorkflowEngine(projectRoot);
+  const config = workflow.generateTargetConfig(targetId);
+
+  if (!config) {
+    utils.print.error(`Unknown target: ${targetId}`);
+    return;
+  }
+
+  const filePath = path.join(projectRoot, config.file);
+
+  if (fs.existsSync(filePath)) {
+    utils.print.warning(`${config.file} already exists`);
+    utils.print.info('Use --force to overwrite');
+    return;
+  }
+
+  const spinner = utils.createSpinner(`Creating ${config.file}...`).start();
+
+  try {
+    fs.writeFileSync(filePath, config.content);
+    spinner.succeed(`Created ${config.file}`);
+
+    const target = workflow.getTargetInfo(targetId);
+    console.log('');
+    utils.print.info('Next steps:');
+    console.log(`  1. Install CLI: ${target.installCmd}`);
+    console.log(`  2. Login: ${target.cli} login`);
+    console.log(`  3. Deploy: bootspring deploy ${targetId}`);
+  } catch (error) {
+    spinner.fail(`Failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Reset deployment workflow
+ */
+async function deployReset(): Promise<void> {
+  const workflow = new DeployWorkflowEngine(projectRoot);
+
+  if (!workflow.hasWorkflow()) {
+    utils.print.info('No workflow to reset.');
+    return;
+  }
+
+  workflow.resetWorkflow();
+  utils.print.success('Deployment workflow reset.');
+}
+
+/**
+ * Get status icon
+ */
+function getStatusIcon(status: string): string {
+  switch (status) {
+    case 'completed':
+      return `${utils.COLORS.green}✓${utils.COLORS.reset}`;
+    case 'in_progress':
+      return `${utils.COLORS.cyan}●${utils.COLORS.reset}`;
+    case 'failed':
+      return `${utils.COLORS.red}✗${utils.COLORS.reset}`;
+    case 'skipped':
+      return `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+    default:
+      return `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  }
+}
+
+/**
+ * Main entry point
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  switch (subcommand) {
+    case 'status':
+      return deployStatus();
+
+    case 'targets':
+    case 'list':
+      return listTargets();
+
+    case 'init':
+      return deployInit(parsedArgs);
+
+    case 'reset':
+      return deployReset();
+
+    case 'help':
+    case '--help':
+    case '-h':
+      return showHelp();
+
+    default:
+      // Start deployment (subcommand might be a target)
+      return deployStart(parsedArgs);
+  }
+}