@stacksjs/ts-cloud 0.1.2 → 0.1.5

package/bin/commands/deploy.ts

@@ -1,674 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import { existsSync, statSync, writeFileSync } from 'node:fs'
-import * as cli from '../../src/utils/cli'
-import { InfrastructureGenerator } from '../../src/generators/infrastructure'
-import { CloudFormationClient } from '../../src/aws/cloudformation'
-import { S3Client } from '../../src/aws/s3'
-import { CloudFrontClient } from '../../src/aws/cloudfront'
-import { ECRClient } from '../../src/aws/ecr'
-import { ECSClient } from '../../src/aws/ecs'
-import { validateTemplate, validateTemplateSize, validateResourceLimits } from '../../src/validation/template'
-import { loadValidatedConfig } from './shared'
-
-export function registerDeployCommands(app: CLI): void {
-  app
-    .command('deploy', 'Deploy infrastructure')
-    .option('--stack <name>', 'Stack name')
-    .option('--env <environment>', 'Environment to deploy to')
-    .action(async (options?: { stack?: string, env?: string }) => {
-      cli.header('Deploying Infrastructure')
-
-      try {
-        // Load configuration
-        const config = await loadValidatedConfig()
-        const environment = (options?.env || 'production') as 'production' | 'staging' | 'development'
-        const stackName = options?.stack || `${config.project.slug}-${environment}`
-        const region = config.project.region || 'us-east-1'
-
-        cli.info(`Stack: ${stackName}`)
-        cli.info(`Region: ${region}`)
-        cli.info(`Environment: ${environment}`)
-
-        // Generate CloudFormation template
-        cli.step('Generating CloudFormation template...')
-        const generator = new InfrastructureGenerator({
-          config,
-          environment,
-        })
-
-        generator.generate()
-        const templateBody = generator.toJSON()
-        const template = JSON.parse(templateBody)
-
-        // Validate template
-        cli.step('Validating template...')
-        const validation = validateTemplate(template)
-        const sizeValidation = validateTemplateSize(templateBody)
-        const limitsValidation = validateResourceLimits(template)
-
-        // Show errors
-        const allErrors = [
-          ...validation.errors,
-          ...sizeValidation.errors,
-          ...limitsValidation.errors,
-        ]
-
-        if (allErrors.length > 0) {
-          cli.error('Template validation failed:')
-          for (const error of allErrors) {
-            cli.error(`  - ${error.path}: ${error.message}`)
-          }
-          return
-        }
-
-        // Show warnings
-        const allWarnings = [
-          ...validation.warnings,
-          ...sizeValidation.warnings,
-          ...limitsValidation.warnings,
-        ]
-
-        if (allWarnings.length > 0) {
-          for (const warning of allWarnings) {
-            cli.warn(`  - ${warning.path}: ${warning.message}`)
-          }
-        }
-
-        cli.success('Template validated successfully')
-
-        // Show resource summary
-        const resourceCount = Object.keys(template.Resources).length
-        cli.info(`\nResources to deploy: ${resourceCount}`)
-
-        // Count resource types
-        const typeCounts: Record<string, number> = {}
-        for (const resource of Object.values(template.Resources)) {
-          const type = (resource as any).Type
-          typeCounts[type] = (typeCounts[type] || 0) + 1
-        }
-
-        for (const [type, count] of Object.entries(typeCounts).sort((a, b) => b[1] - a[1]).slice(0, 5)) {
-          cli.info(`  - ${type}: ${count}`)
-        }
-
-        // Confirm deployment
-        const confirmed = await cli.confirm('\nDeploy now?', true)
-        if (!confirmed) {
-          cli.info('Deployment cancelled')
-          return
-        }
-
-        // Initialize CloudFormation client
-        const cfn = new CloudFormationClient(region)
-
-        // Check if stack exists
-        cli.step('Checking stack status...')
-        let stackExists = false
-        try {
-          const result = await cfn.describeStacks({ stackName })
-          stackExists = result.Stacks && result.Stacks.length > 0
-        }
-        catch (error) {
-          // Stack doesn't exist, that's fine
-          stackExists = false
-        }
-
-        if (stackExists) {
-          cli.info('Stack exists, updating...')
-          const updateSpinner = new cli.Spinner('Updating CloudFormation stack...')
-          updateSpinner.start()
-
-          try {
-            await cfn.updateStack({
-              stackName,
-              templateBody,
-              capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
-              tags: [
-                { Key: 'Project', Value: config.project.name },
-                { Key: 'Environment', Value: environment },
-                { Key: 'ManagedBy', Value: 'ts-cloud' },
-              ],
-            })
-
-            updateSpinner.succeed('Update initiated')
-
-            // Wait for completion
-            cli.step('Waiting for stack update to complete...')
-            await cfn.waitForStack(stackName, 'stack-update-complete')
-
-            cli.success('Stack updated successfully!')
-          }
-          catch (error: any) {
-            if (error.message.includes('No updates are to be performed')) {
-              updateSpinner.succeed('No changes detected')
-              cli.info('Stack is already up to date')
-              return
-            }
-            throw error
-          }
-        }
-        else {
-          cli.info('Creating new stack...')
-          const createSpinner = new cli.Spinner('Creating CloudFormation stack...')
-          createSpinner.start()
-
-          await cfn.createStack({
-            stackName,
-            templateBody,
-            capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
-            tags: [
-              { Key: 'Project', Value: config.project.name },
-              { Key: 'Environment', Value: environment },
-              { Key: 'ManagedBy', Value: 'ts-cloud' },
-            ],
-          })
-
-          createSpinner.succeed('Stack creation initiated')
-
-          // Wait for completion
-          cli.step('Waiting for stack creation to complete...')
-          await cfn.waitForStack(stackName, 'stack-create-complete')
-
-          cli.success('Stack created successfully!')
-        }
-
-        // Get stack outputs
-        const outputs = await cfn.getStackOutputs(stackName)
-
-        cli.box(`Deployment Complete!
-
-Stack: ${stackName}
-Region: ${region}
-Environment: ${environment}
-Resources: ${resourceCount}
-
-View in console:
-https://console.aws.amazon.com/cloudformation/home?region=${region}#/stacks/stackinfo?stackId=${encodeURIComponent(stackName)}`, 'green')
-
-        if (Object.keys(outputs).length > 0) {
-          cli.info('\nStack Outputs:')
-          for (const [key, value] of Object.entries(outputs)) {
-            cli.info(`  - ${key}: ${value}`)
-          }
-        }
-      }
-      catch (error: any) {
-        cli.error(`Deployment failed: ${error.message}`)
-        if (error.stack) {
-          cli.info('\nStack trace:')
-          console.error(error.stack)
-        }
-      }
-    })
-
-  app
-    .command('deploy:server', 'Deploy EC2 infrastructure')
-    .option('--env <environment>', 'Environment (production, staging, development)')
-    .action(async (options?: { env?: string }) => {
-      cli.header('Deploying Server Infrastructure')
-
-      try {
-        const config = await loadValidatedConfig()
-        const environment = (options?.env || 'production') as 'production' | 'staging' | 'development'
-        const stackName = `${config.project.slug}-server-${environment}`
-        const region = config.project.region || 'us-east-1'
-
-        cli.info(`Stack: ${stackName}`)
-        cli.info(`Region: ${region}`)
-        cli.info(`Environment: ${environment}`)
-
-        cli.step('Generating EC2 server infrastructure...')
-
-        // TODO: Generate server-specific infrastructure
-        const spinner = new cli.Spinner('Deploying server infrastructure...')
-        spinner.start()
-
-        await new Promise(resolve => setTimeout(resolve, 2000))
-
-        spinner.succeed('Server infrastructure deployed successfully!')
-
-        cli.success('\nDeployment complete!')
-        cli.info('\nNext steps:')
-        cli.info('  - cloud server:list - View deployed servers')
-        cli.info('  - cloud server:ssh <name> - SSH into a server')
-      }
-      catch (error: any) {
-        cli.error(`Deployment failed: ${error.message}`)
-      }
-    })
-
-  app
-    .command('deploy:serverless', 'Deploy serverless infrastructure')
-    .option('--env <environment>', 'Environment (production, staging, development)')
-    .option('--function <name>', 'Deploy specific function only')
-    .action(async (options?: { env?: string, function?: string }) => {
-      cli.header('Deploying Serverless Infrastructure')
-
-      try {
-        const config = await loadValidatedConfig()
-        const environment = (options?.env || 'production') as 'production' | 'staging' | 'development'
-        const stackName = `${config.project.slug}-serverless-${environment}`
-        const region = config.project.region || 'us-east-1'
-
-        cli.info(`Stack: ${stackName}`)
-        cli.info(`Region: ${region}`)
-        cli.info(`Environment: ${environment}`)
-
-        if (options?.function) {
-          cli.info(`Function: ${options.function}`)
-        }
-
-        cli.step('Generating serverless infrastructure...')
-
-        const spinner = new cli.Spinner('Deploying serverless infrastructure...')
-        spinner.start()
-
-        await new Promise(resolve => setTimeout(resolve, 2000))
-
-        spinner.succeed('Serverless infrastructure deployed successfully!')
-
-        cli.success('\nDeployment complete!')
-        cli.info('\nNext steps:')
-        cli.info('  - cloud function:list - View deployed functions')
-        cli.info('  - cloud function:logs <name> - View function logs')
-        cli.info('  - cloud function:invoke <name> - Test function')
-      }
-      catch (error: any) {
-        cli.error(`Deployment failed: ${error.message}`)
-      }
-    })
-
-  app
-    .command('deploy:status', 'Check deployment status')
-    .option('--stack <name>', 'Stack name')
-    .option('--env <environment>', 'Environment')
-    .action(async (options?: { stack?: string, env?: string }) => {
-      cli.header('Deployment Status')
-
-      try {
-        const config = await loadValidatedConfig()
-        const environment = options?.env || 'production'
-        const stackName = options?.stack || `${config.project.slug}-${environment}`
-        const region = config.project.region || 'us-east-1'
-
-        cli.info(`Stack: ${stackName}`)
-        cli.info(`Region: ${region}`)
-
-        const spinner = new cli.Spinner('Checking deployment status...')
-        spinner.start()
-
-        const cfn = new CloudFormationClient(region)
-
-        // Get stack status
-        const result = await cfn.describeStacks({ stackName })
-
-        if (result.Stacks.length === 0) {
-          spinner.fail('Stack not found')
-          cli.warning('No deployment found for this environment')
-          return
-        }
-
-        const stack = result.Stacks[0]
-        spinner.succeed('Status retrieved')
-
-        cli.info(`\nStatus: ${stack.StackStatus}`)
-        cli.info(`Created: ${stack.CreationTime}`)
-        if (stack.LastUpdatedTime) {
-          cli.info(`Last Updated: ${stack.LastUpdatedTime}`)
-        }
-
-        // Show outputs
-        if (stack.Outputs && stack.Outputs.length > 0) {
-          cli.info('\nOutputs:')
-          for (const output of stack.Outputs) {
-            cli.info(`  ${output.OutputKey}: ${output.OutputValue}`)
-          }
-        }
-      }
-      catch (error: any) {
-        cli.error(`Failed to get status: ${error.message}`)
-      }
-    })
-
-  app
-    .command('deploy:rollback', 'Rollback to previous version')
-    .option('--stack <name>', 'Stack name')
-    .option('--env <environment>', 'Environment')
-    .action(async (options?: { stack?: string, env?: string }) => {
-      cli.header('Rolling Back Deployment')
-
-      try {
-        const config = await loadValidatedConfig()
-        const environment = options?.env || 'production'
-        const stackName = options?.stack || `${config.project.slug}-${environment}`
-        const region = config.project.region || 'us-east-1'
-
-        cli.info(`Stack: ${stackName}`)
-        cli.info(`Region: ${region}`)
-
-        const confirmed = await cli.confirm('\nAre you sure you want to rollback?', false)
-        if (!confirmed) {
-          cli.info('Rollback cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Rolling back stack...')
-        spinner.start()
-
-        const cfn = new CloudFormationClient(region)
-
-        // Delete the stack
-        await cfn.deleteStack(stackName)
-
-        spinner.succeed('Stack deletion initiated')
-
-        // Wait for deletion
-        cli.step('Waiting for stack deletion...')
-        await cfn.waitForStack(stackName, 'stack-delete-complete')
-
-        cli.success('Stack rolled back successfully!')
-      }
-      catch (error: any) {
-        cli.error(`Rollback failed: ${error.message}`)
-      }
-    })
-
-  app
-    .command('deploy:static', 'Deploy static site (S3 + CloudFront invalidation)')
-    .option('--source <path>', 'Source directory', { default: 'dist' })
-    .option('--bucket <name>', 'S3 bucket name')
-    .option('--distribution <id>', 'CloudFront distribution ID')
-    .option('--prefix <prefix>', 'S3 prefix/folder')
-    .option('--delete', 'Delete files not in source')
-    .option('--cache-control <value>', 'Cache-Control header', { default: 'public, max-age=31536000' })
-    .option('--no-invalidate', 'Skip CloudFront invalidation')
-    .option('--wait', 'Wait for invalidation to complete')
-    .action(async (options?: {
-      source?: string
-      bucket?: string
-      distribution?: string
-      prefix?: string
-      delete?: boolean
-      cacheControl?: string
-      invalidate?: boolean
-      wait?: boolean
-    }) => {
-      cli.header('Deploying Static Site')
-
-      try {
-        const config = await loadValidatedConfig()
-        const region = config.project.region || 'us-east-1'
-
-        const source = options?.source || 'dist'
-        const bucket = options?.bucket
-        const distributionId = options?.distribution
-        const prefix = options?.prefix
-        const shouldDelete = options?.delete || false
-        const cacheControl = options?.cacheControl || 'public, max-age=31536000'
-        const shouldInvalidate = options?.invalidate !== false
-        const shouldWait = options?.wait || false
-
-        if (!bucket) {
-          cli.error('--bucket is required')
-          return
-        }
-
-        // Check if source directory exists
-        if (!existsSync(source)) {
-          cli.error(`Source directory not found: ${source}`)
-          return
-        }
-
-        cli.info(`Source: ${source}`)
-        cli.info(`Bucket: s3://${bucket}${prefix ? `/${prefix}` : ''}`)
-        cli.info(`Cache-Control: ${cacheControl}`)
-        if (distributionId) {
-          cli.info(`CloudFront Distribution: ${distributionId}`)
-        }
-        if (shouldDelete) {
-          cli.warn('Delete mode enabled - files not in source will be removed')
-        }
-
-        const confirmed = await cli.confirm('\nDeploy static site now?', true)
-        if (!confirmed) {
-          cli.info('Deployment cancelled')
-          return
-        }
-
-        // Step 1: Upload to S3
-        const s3 = new S3Client(region)
-        const uploadSpinner = new cli.Spinner('Uploading files to S3...')
-        uploadSpinner.start()
-
-        await s3.sync({
-          source,
-          bucket,
-          prefix,
-          delete: shouldDelete,
-          cacheControl,
-          acl: 'public-read',
-        })
-
-        uploadSpinner.succeed('Files uploaded successfully!')
-
-        // Get bucket size
-        const size = await s3.getBucketSize(bucket, prefix)
-        const sizeInMB = (size / 1024 / 1024).toFixed(2)
-        cli.info(`Total size: ${sizeInMB} MB`)
-
-        // Step 2: Invalidate CloudFront (if distribution provided)
-        if (shouldInvalidate && distributionId) {
-          const cloudfront = new CloudFrontClient()
-          const invalidateSpinner = new cli.Spinner('Invalidating CloudFront cache...')
-          invalidateSpinner.start()
-
-          const invalidation = await cloudfront.invalidateAll(distributionId)
-          invalidateSpinner.succeed('Invalidation created')
-
-          cli.info(`Invalidation ID: ${invalidation.Id}`)
-
-          if (shouldWait) {
-            const waitSpinner = new cli.Spinner('Waiting for invalidation to complete...')
-            waitSpinner.start()
-            await cloudfront.waitForInvalidation(distributionId, invalidation.Id)
-            waitSpinner.succeed('Invalidation completed!')
-          }
-        }
-
-        cli.box(`Static Site Deployed!
-
-Source: ${source}
-Bucket: s3://${bucket}${prefix ? `/${prefix}` : ''}
-Size: ${sizeInMB} MB
-${distributionId ? `Distribution: ${distributionId}` : ''}
-
-View your site:
-https://${bucket}.s3.${region}.amazonaws.com${prefix ? `/${prefix}` : ''}/index.html`, 'green')
-      }
-      catch (error: any) {
-        cli.error(`Deployment failed: ${error.message}`)
-      }
-    })
-
-  app
-    .command('deploy:container', 'Deploy container (ECR push + ECS service update)')
-    .option('--cluster <name>', 'ECS cluster name')
-    .option('--service <name>', 'ECS service name')
-    .option('--repository <name>', 'ECR repository name')
-    .option('--image <tag>', 'Docker image tag', { default: 'latest' })
-    .option('--dockerfile <path>', 'Dockerfile path', { default: 'Dockerfile' })
-    .option('--context <path>', 'Docker build context', { default: '.' })
-    .option('--task-definition <name>', 'Task definition family name')
-    .option('--force', 'Force new deployment even if no changes')
-    .option('--wait', 'Wait for deployment to stabilize')
-    .action(async (options?: {
-      cluster?: string
-      service?: string
-      repository?: string
-      image?: string
-      dockerfile?: string
-      context?: string
-      taskDefinition?: string
-      force?: boolean
-      wait?: boolean
-    }) => {
-      cli.header('Deploying Container')
-
-      try {
-        const config = await loadValidatedConfig()
-        const region = config.project.region || 'us-east-1'
-
-        const cluster = options?.cluster
-        const service = options?.service
-        const repository = options?.repository
-        const imageTag = options?.image || 'latest'
-        const dockerfile = options?.dockerfile || 'Dockerfile'
-        const context = options?.context || '.'
-        const forceDeployment = options?.force || false
-        const shouldWait = options?.wait || false
-
-        if (!cluster || !service) {
-          cli.error('--cluster and --service are required')
-          return
-        }
-
-        if (!repository) {
-          cli.error('--repository is required')
-          return
-        }
-
-        // Check if Dockerfile exists
-        if (!existsSync(dockerfile)) {
-          cli.error(`Dockerfile not found: ${dockerfile}`)
-          return
-        }
-
-        cli.info(`Cluster: ${cluster}`)
-        cli.info(`Service: ${service}`)
-        cli.info(`Repository: ${repository}`)
-        cli.info(`Image Tag: ${imageTag}`)
-        cli.info(`Dockerfile: ${dockerfile}`)
-
-        const confirmed = await cli.confirm('\nDeploy container now?', true)
-        if (!confirmed) {
-          cli.info('Deployment cancelled')
-          return
-        }
-
-        const ecr = new ECRClient(region)
-        const ecs = new ECSClient(region)
-
-        // Step 1: Get ECR login credentials
-        const loginSpinner = new cli.Spinner('Getting ECR credentials...')
-        loginSpinner.start()
-
-        const authResult = await ecr.getAuthorizationToken()
-        if (!authResult.authorizationData?.[0]) {
-          loginSpinner.fail('Failed to get ECR credentials')
-          return
-        }
-
-        const auth = authResult.authorizationData[0]
-        const registryEndpoint = auth.proxyEndpoint || ''
-        const registryHost = registryEndpoint.replace('https://', '')
-
-        loginSpinner.succeed('ECR credentials obtained')
-
-        // Step 2: Docker login to ECR
-        const dockerLoginSpinner = new cli.Spinner('Logging into ECR...')
-        dockerLoginSpinner.start()
-
-        const token = auth.authorizationToken || ''
-        const decoded = Buffer.from(token, 'base64').toString('utf8')
-        const password = decoded.split(':')[1]
-
-        // Run docker login
-        const { spawn } = await import('child_process')
-        const dockerLogin = spawn('docker', ['login', '--username', 'AWS', '--password-stdin', registryHost], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        dockerLogin.stdin.write(password)
-        dockerLogin.stdin.end()
-
-        await new Promise<void>((resolve, reject) => {
-          dockerLogin.on('close', (code) => {
-            if (code === 0) resolve()
-            else reject(new Error(`Docker login failed with code ${code}`))
-          })
-        })
-
-        dockerLoginSpinner.succeed('Logged into ECR')
-
-        // Step 3: Build Docker image
-        const buildSpinner = new cli.Spinner('Building Docker image...')
-        buildSpinner.start()
-
-        const imageUri = `${registryHost}/${repository}:${imageTag}`
-
-        const dockerBuild = spawn('docker', ['build', '-t', imageUri, '-f', dockerfile, context], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        await new Promise<void>((resolve, reject) => {
-          let stderr = ''
-          dockerBuild.stderr.on('data', (data) => { stderr += data.toString() })
-          dockerBuild.on('close', (code) => {
-            if (code === 0) resolve()
-            else reject(new Error(`Docker build failed: ${stderr}`))
-          })
-        })
-
-        buildSpinner.succeed('Docker image built')
-
-        // Step 4: Push to ECR
-        const pushSpinner = new cli.Spinner('Pushing image to ECR...')
-        pushSpinner.start()
-
-        const dockerPush = spawn('docker', ['push', imageUri], {
-          stdio: ['pipe', 'pipe', 'pipe'],
-        })
-
-        await new Promise<void>((resolve, reject) => {
-          let stderr = ''
-          dockerPush.stderr.on('data', (data) => { stderr += data.toString() })
-          dockerPush.on('close', (code) => {
-            if (code === 0) resolve()
-            else reject(new Error(`Docker push failed: ${stderr}`))
-          })
-        })
-
-        pushSpinner.succeed('Image pushed to ECR')
-
-        // Step 5: Update ECS service
-        const updateSpinner = new cli.Spinner('Updating ECS service...')
-        updateSpinner.start()
-
-        await ecs.updateService({
-          cluster,
-          service,
-          forceNewDeployment: forceDeployment,
-        })
-
-        updateSpinner.succeed('ECS service updated')
-
-        // Step 6: Wait for deployment (if requested)
-        if (shouldWait) {
-          const waitSpinner = new cli.Spinner('Waiting for deployment to stabilize...')
-          waitSpinner.start()
-
-          await ecs.waitForServiceStable(cluster, service)
-
-          waitSpinner.succeed('Deployment stabilized')
-        }
-
-        cli.success('\nContainer deployment complete!')
-        cli.info(`\nImage: ${imageUri}`)
-        cli.info(`Cluster: ${cluster}`)
-        cli.info(`Service: ${service}`)
-      }
-      catch (error: any) {
-        cli.error(`Deployment failed: ${error.message}`)
-      }
-    })
-}