@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/deploy.js

@@ -0,0 +1,543 @@
+/**
+ * Bootspring Deploy CLI
+ *
+ * Deploy projects to various hosting platforms with
+ * pre-deployment validation and quality checks.
+ *
+ * @package bootspring
+ * @module cli/deploy
+ */
+
+const path = require('path');
+const fs = require('fs');
+const utils = require('../core/utils');
+const { DeployWorkflowEngine, DEPLOY_TARGETS, DEPLOY_PHASES } = require('../core/deploy-workflow');
+
+// Get project root
+const projectRoot = process.cwd();
+
+/**
+ * Show deploy help
+ */
+function showHelp() {
+  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) {
+  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, options = {}) {
+  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}...`).start();
+
+    try {
+      let result;
+
+      switch (nextPhaseId) {
+        case 'validate':
+          result = await workflow.runValidation();
+          if (result.passed) {
+            spinner.succeed('Pre-flight validation passed');
+          } else {
+            spinner.fail('Pre-flight validation failed');
+            displayValidationResults(result);
+            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);
+          break;
+
+        case 'target':
+          result = await workflow.detectTarget();
+          if (result.selected) {
+            const target = workflow.getTargetInfo(result.selected);
+            spinner.succeed(`Target: ${target.name}`);
+          } else if (result.detected.length > 0) {
+            spinner.succeed(`Detected: ${result.detected.map(t => t.name).join(', ')}`);
+            // Auto-select first detected
+            workflow.setTarget(result.detected[0].id);
+            result.selected = result.detected[0].id;
+          } else {
+            spinner.fail('No deployment target detected');
+            displayTargetSelection(result);
+            utils.print.error('Run "bootspring deploy init <target>" to configure');
+            workflow.failPhase(nextPhaseId, 'No target');
+            return;
+          }
+          displayTargetResults(result);
+          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.skipped) {
+            spinner.info('Quality checks skipped');
+          } else if (result.passed) {
+            spinner.succeed('Quality checks passed');
+          } else {
+            spinner.warn('Some quality checks failed');
+          }
+          displayQualityResults(result);
+          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.target}`);
+            if (result.url) {
+              console.log(`  ${utils.COLORS.green}URL:${utils.COLORS.reset} ${result.url}`);
+            }
+          }
+          break;
+
+        case 'verify':
+          if (options.dryRun) {
+            spinner.info('Verification: [DRY RUN] Skipped');
+            result = { dryRun: true };
+          } else {
+            result = await workflow.runVerification();
+            if (result.skipped) {
+              spinner.info('Verification skipped');
+            } else if (result.passed) {
+              spinner.succeed(`Verification passed (HTTP ${result.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.message}`);
+      workflow.failPhase(nextPhaseId, error.message);
+
+      if (phase.required) {
+        utils.print.error('Deployment failed.');
+        return;
+      }
+    }
+
+    console.log('');
+  }
+
+  // Deployment complete
+  displayCompletionSummary(workflow, options);
+}
+
+/**
+ * Display validation results
+ */
+function displayValidationResults(result) {
+  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) {
+  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) {
+  console.log('');
+  console.log('Recommended targets for your project:');
+
+  for (const rec of result.recommendations.slice(0, 3)) {
+    const target = DEPLOY_TARGETS[rec.id];
+    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) {
+  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, options) {
+  const progress = workflow.getProgress();
+  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) {
+  const names = {
+    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() {
+  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() {
+  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) {
+  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.message}`);
+  }
+}
+
+/**
+ * Reset deployment workflow
+ */
+async function deployReset() {
+  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) {
+  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
+ */
+async function run(args) {
+  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);
+  }
+}
+
+module.exports = { run };