@stacksjs/ts-cloud 0.1.1

package/bin/commands/cache.ts

@@ -0,0 +1,294 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+import { ElastiCacheClient } from '../../src/aws/elasticache'
+import { loadValidatedConfig } from './shared'
+
+export function registerCacheCommands(app: CLI): void {
+  app
+    .command('cache:list', 'List all ElastiCache clusters')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('ElastiCache Clusters')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+        const elasticache = new ElastiCacheClient(region)
+
+        const spinner = new cli.Spinner('Fetching clusters...')
+        spinner.start()
+
+        const result = await elasticache.describeCacheClusters()
+        const clusters = result.CacheClusters || []
+
+        spinner.succeed(`Found ${clusters.length} cluster(s)`)
+
+        if (clusters.length === 0) {
+          cli.info('No ElastiCache clusters found')
+          cli.info('Use `cloud cache:create` to create a new cluster')
+          return
+        }
+
+        cli.table(
+          ['Cluster ID', 'Engine', 'Node Type', 'Nodes', 'Status'],
+          clusters.map(cluster => [
+            cluster.CacheClusterId || 'N/A',
+            `${cluster.Engine || 'N/A'} ${cluster.EngineVersion || ''}`,
+            cluster.CacheNodeType || 'N/A',
+            (cluster.NumCacheNodes || 0).toString(),
+            cluster.CacheClusterStatus || 'N/A',
+          ]),
+        )
+      }
+      catch (error: any) {
+        cli.error(`Failed to list clusters: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cache:create <name>', 'Create a new ElastiCache cluster')
+    .option('--engine <engine>', 'Cache engine (redis or memcached)', { default: 'redis' })
+    .option('--node-type <type>', 'Node instance type', { default: 'cache.t3.micro' })
+    .option('--nodes <number>', 'Number of cache nodes', { default: '1' })
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--version <version>', 'Engine version')
+    .action(async (name: string, options: { engine: string; nodeType: string; nodes: string; region: string; version?: string }) => {
+      cli.header('Create ElastiCache Cluster')
+
+      try {
+        const elasticache = new ElastiCacheClient(options.region)
+
+        cli.info(`Cluster ID: ${name}`)
+        cli.info(`Engine: ${options.engine}`)
+        cli.info(`Node Type: ${options.nodeType}`)
+        cli.info(`Number of Nodes: ${options.nodes}`)
+        cli.info(`Region: ${options.region}`)
+
+        const confirmed = await cli.confirm('\nCreate this cluster?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Creating cluster...')
+        spinner.start()
+
+        await elasticache.createCacheCluster({
+          cacheClusterId: name,
+          engine: options.engine as 'redis' | 'memcached',
+          cacheNodeType: options.nodeType,
+          numCacheNodes: Number.parseInt(options.nodes),
+          engineVersion: options.version,
+        })
+
+        spinner.succeed('Cluster creation initiated')
+
+        cli.success(`\nCluster: ${name}`)
+        cli.info('Status: creating')
+        cli.info('\nNote: Cluster creation may take several minutes.')
+        cli.info('Use `cloud cache:list` to check status.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to create cluster: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cache:delete <clusterId>', 'Delete an ElastiCache cluster')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (clusterId: string, options: { region: string }) => {
+      cli.header('Delete ElastiCache Cluster')
+
+      try {
+        const elasticache = new ElastiCacheClient(options.region)
+
+        cli.warn(`This will permanently delete cluster: ${clusterId}`)
+        cli.warn('All data in the cluster will be lost!')
+
+        const confirmed = await cli.confirm('\nDelete this cluster?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Deleting cluster...')
+        spinner.start()
+
+        await elasticache.deleteCacheCluster(clusterId)
+
+        spinner.succeed('Cluster deletion initiated')
+
+        cli.info('\nNote: Cluster deletion may take several minutes.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to delete cluster: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cache:stats <clusterId>', 'Show ElastiCache cluster statistics')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (clusterId: string, options: { region: string }) => {
+      cli.header(`ElastiCache Stats: ${clusterId}`)
+
+      try {
+        const elasticache = new ElastiCacheClient(options.region)
+
+        const spinner = new cli.Spinner('Fetching cluster details...')
+        spinner.start()
+
+        const result = await elasticache.describeCacheClusters(clusterId)
+
+        const cluster = result.CacheClusters?.[0]
+
+        if (!cluster) {
+          spinner.fail('Cluster not found')
+          return
+        }
+
+        spinner.succeed('Cluster details loaded')
+
+        cli.info('\nCluster Information:')
+        cli.info(`  Cluster ID: ${cluster.CacheClusterId}`)
+        cli.info(`  Engine: ${cluster.Engine} ${cluster.EngineVersion}`)
+        cli.info(`  Node Type: ${cluster.CacheNodeType}`)
+        cli.info(`  Status: ${cluster.CacheClusterStatus}`)
+        cli.info(`  Nodes: ${cluster.NumCacheNodes}`)
+        cli.info(`  Availability Zone: ${cluster.PreferredAvailabilityZone || 'Not set'}`)
+
+        if (cluster.CacheNodes && cluster.CacheNodes.length > 0) {
+          cli.info('\nCache Nodes:')
+          for (const node of cluster.CacheNodes) {
+            cli.info(`  - ${node.CacheNodeId}: ${node.CacheNodeStatus}`)
+            if (node.Endpoint) {
+              cli.info(`    Endpoint: ${node.Endpoint.Address}:${node.Endpoint.Port}`)
+            }
+          }
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to get cluster stats: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cache:flush <clusterId>', 'Flush all data from a Redis cluster')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (clusterId: string, options: { region: string }) => {
+      cli.header('Flush ElastiCache Cluster')
+
+      try {
+        const elasticache = new ElastiCacheClient(options.region)
+
+        // First get cluster info to get the endpoint
+        const spinner = new cli.Spinner('Getting cluster endpoint...')
+        spinner.start()
+
+        const result = await elasticache.describeCacheClusters(clusterId)
+
+        const cluster = result.CacheClusters?.[0]
+
+        if (!cluster) {
+          spinner.fail('Cluster not found')
+          return
+        }
+
+        if (cluster.Engine !== 'redis') {
+          spinner.fail('Flush is only supported for Redis clusters')
+          cli.info('For Memcached, items expire automatically based on TTL.')
+          return
+        }
+
+        spinner.stop()
+
+        const endpoint = cluster.CacheNodes?.[0]?.Endpoint
+
+        if (!endpoint) {
+          cli.error('Could not determine cluster endpoint')
+          return
+        }
+
+        cli.warn(`This will delete ALL data in cluster: ${clusterId}`)
+        cli.warn(`Endpoint: ${endpoint.Address}:${endpoint.Port}`)
+        cli.warn('This action cannot be undone!')
+
+        const confirmed = await cli.confirm('\nFlush all data?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        cli.info('\nTo flush the Redis cluster, connect and run FLUSHALL:')
+        cli.info(`  redis-cli -h ${endpoint.Address} -p ${endpoint.Port} FLUSHALL`)
+        cli.info('\nNote: Direct FLUSHALL via AWS API is not supported.')
+        cli.info('You must connect to the cluster directly to execute this command.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to get cluster info: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cache:reboot <clusterId>', 'Reboot cache cluster nodes')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--node <nodeId>', 'Specific node ID to reboot')
+    .action(async (clusterId: string, options: { region: string; node?: string }) => {
+      cli.header('Reboot ElastiCache Cluster')
+
+      try {
+        const elasticache = new ElastiCacheClient(options.region)
+
+        // Get cluster info first
+        const spinner = new cli.Spinner('Getting cluster info...')
+        spinner.start()
+
+        const result = await elasticache.describeCacheClusters(clusterId)
+
+        const cluster = result.CacheClusters?.[0]
+
+        if (!cluster) {
+          spinner.fail('Cluster not found')
+          return
+        }
+
+        spinner.stop()
+
+        const nodeIds = options.node
+          ? [options.node]
+          : cluster.CacheNodes?.map(n => n.CacheNodeId).filter(Boolean) || []
+
+        if (nodeIds.length === 0) {
+          cli.error('No nodes found to reboot')
+          return
+        }
+
+        cli.warn(`This will reboot the following nodes: ${nodeIds.join(', ')}`)
+        cli.warn('The cluster may be temporarily unavailable during reboot.')
+
+        const confirmed = await cli.confirm('\nReboot these nodes?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const rebootSpinner = new cli.Spinner('Rebooting nodes...')
+        rebootSpinner.start()
+
+        await elasticache.rebootCacheCluster(clusterId, nodeIds)
+
+        rebootSpinner.succeed('Reboot initiated')
+
+        cli.info('\nNote: Reboot may take several minutes to complete.')
+        cli.info('Use `cloud cache:stats` to check status.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to reboot cluster: ${error.message}`)
+        process.exit(1)
+      }
+    })
+}

package/bin/commands/cdn.ts

@@ -0,0 +1,281 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+import type { Distribution } from '../../src/aws/cloudfront'
+import { CloudFrontClient } from '../../src/aws/cloudfront'
+import { loadValidatedConfig } from './shared'
+
+export function registerCdnCommands(app: CLI): void {
+  app
+    .command('cdn:list', 'List all CloudFront distributions')
+    .action(async () => {
+      cli.header('CloudFront Distributions')
+
+      try {
+        const config = await loadValidatedConfig()
+        const cloudfront = new CloudFrontClient()
+
+        const spinner = new cli.Spinner('Fetching distributions...')
+        spinner.start()
+
+        const distributions = await cloudfront.listDistributions()
+
+        spinner.succeed(`Found ${distributions.length} distribution(s)`)
+
+        if (distributions.length === 0) {
+          cli.info('No CloudFront distributions found')
+          cli.info('Use `cloud cdn:create` to create a new distribution')
+          return
+        }
+
+        cli.table(
+          ['ID', 'Domain', 'Status', 'Enabled', 'Aliases'],
+          distributions.map((dist: Distribution) => [
+            dist.Id || 'N/A',
+            dist.DomainName || 'N/A',
+            dist.Status || 'N/A',
+            dist.Enabled ? 'Yes' : 'No',
+            (dist.Aliases?.Items?.length || 0).toString(),
+          ]),
+        )
+      }
+      catch (error: any) {
+        cli.error(`Failed to list distributions: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cdn:status <distributionId>', 'Get CloudFront distribution status')
+    .action(async (distributionId: string) => {
+      cli.header(`CloudFront Distribution: ${distributionId}`)
+
+      try {
+        const cloudfront = new CloudFrontClient()
+
+        const spinner = new cli.Spinner('Fetching distribution details...')
+        spinner.start()
+
+        const dist = await cloudfront.getDistribution(distributionId)
+
+        spinner.succeed('Distribution details loaded')
+
+        cli.info('\nDistribution Information:')
+        cli.info(`  ID: ${dist.Id}`)
+        cli.info(`  Domain: ${dist.DomainName}`)
+        cli.info(`  Status: ${dist.Status}`)
+        cli.info(`  ARN: ${dist.ARN}`)
+        cli.info(`  Enabled: ${dist.Enabled ? 'Yes' : 'No'}`)
+
+        if (dist.Aliases?.Items?.length) {
+          cli.info(`  Aliases: ${dist.Aliases.Items.join(', ')}`)
+        }
+
+        // Fetch full config for origin and cache behavior details
+        const config = await cloudfront.getDistributionConfig(distributionId)
+
+        cli.info('\nOrigins:')
+        const origins = config.DistributionConfig?.Origins?.Items || []
+        if (Array.isArray(origins)) {
+          for (const origin of origins) {
+            cli.info(`  - ${origin.Id}: ${origin.DomainName}`)
+          }
+        }
+
+        if (config.DistributionConfig?.DefaultCacheBehavior) {
+          const behavior = config.DistributionConfig.DefaultCacheBehavior
+          cli.info('\nDefault Cache Behavior:')
+          cli.info(`  Target Origin: ${behavior.TargetOriginId}`)
+          cli.info(`  Viewer Protocol: ${behavior.ViewerProtocolPolicy}`)
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to get distribution: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cdn:create', 'Create a new CloudFront distribution for an S3 bucket')
+    .option('--bucket <name>', 'S3 bucket name')
+    .option('--region <region>', 'S3 bucket region', { default: 'us-east-1' })
+    .option('--alias <domain>', 'Custom domain alias (CNAME)')
+    .option('--certificate <arn>', 'ACM certificate ARN for custom domain')
+    .option('--comment <text>', 'Distribution comment/description')
+    .action(async (options: { bucket?: string; region: string; alias?: string; certificate?: string; comment?: string }) => {
+      cli.header('Create CloudFront Distribution')
+
+      try {
+        if (!options.bucket) {
+          cli.error('--bucket is required')
+          cli.info('Example: cloud cdn:create --bucket my-bucket --region us-east-1')
+          process.exit(1)
+        }
+
+        const cloudfront = new CloudFrontClient()
+
+        cli.info(`Bucket: ${options.bucket}`)
+        cli.info(`Region: ${options.region}`)
+        if (options.alias) {
+          cli.info(`Alias: ${options.alias}`)
+        }
+
+        const confirmed = await cli.confirm('\nCreate this distribution?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Setting up Origin Access Control...')
+        spinner.start()
+
+        // Find or create an OAC for S3
+        const oac = await cloudfront.findOrCreateOriginAccessControl(`OAC-${options.bucket}`)
+        if (oac.isNew) {
+          spinner.text = 'Created new Origin Access Control'
+        }
+
+        spinner.text = 'Creating distribution...'
+
+        const aliases = options.alias ? [options.alias] : []
+
+        const result = await cloudfront.createDistributionForS3({
+          bucketName: options.bucket,
+          bucketRegion: options.region,
+          originAccessControlId: oac.Id,
+          aliases,
+          certificateArn: options.certificate,
+          comment: options.comment || `Created by ts-cloud CLI`,
+        })
+
+        spinner.succeed('Distribution created')
+
+        cli.success(`\nDistribution ID: ${result.Id}`)
+        cli.info(`Domain: ${result.DomainName}`)
+        cli.info(`Status: ${result.Status}`)
+        cli.info('\nNote: Distribution deployment may take 15-30 minutes.')
+
+        // Show the S3 bucket policy that needs to be applied
+        cli.info('\nIMPORTANT: Update your S3 bucket policy to allow CloudFront access:')
+        const policy = CloudFrontClient.getS3BucketPolicyForCloudFront(options.bucket, result.ARN)
+        cli.info(JSON.stringify(policy, null, 2))
+      }
+      catch (error: any) {
+        cli.error(`Failed to create distribution: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cdn:invalidate <distributionId>', 'Invalidate CloudFront cache')
+    .option('--paths <paths>', 'Paths to invalidate (comma-separated)', { default: '/*' })
+    .action(async (distributionId: string, options: { paths: string }) => {
+      cli.header('Invalidate CloudFront Cache')
+
+      try {
+        const cloudfront = new CloudFrontClient()
+
+        const paths = options.paths.split(',').map(p => p.trim())
+
+        cli.info(`Distribution: ${distributionId}`)
+        cli.info(`Paths: ${paths.join(', ')}`)
+
+        const confirmed = await cli.confirm('\nCreate invalidation?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Creating invalidation...')
+        spinner.start()
+
+        const result = await cloudfront.createInvalidation({
+          distributionId,
+          paths,
+          callerReference: `cli-${Date.now()}`,
+        })
+
+        spinner.succeed('Invalidation created')
+
+        cli.success(`\nInvalidation ID: ${result.Id}`)
+        cli.info(`Status: ${result.Status}`)
+        cli.info('\nNote: Invalidation typically completes in 5-10 minutes.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to create invalidation: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cdn:disable <distributionId>', 'Disable a CloudFront distribution')
+    .action(async (distributionId: string) => {
+      cli.header('Disable CloudFront Distribution')
+
+      try {
+        const cloudfront = new CloudFrontClient()
+
+        cli.warn(`This will disable distribution: ${distributionId}`)
+        cli.info('The distribution will stop serving content.')
+
+        const confirmed = await cli.confirm('\nDisable this distribution?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Disabling distribution...')
+        spinner.start()
+
+        await cloudfront.disableDistribution(distributionId)
+
+        spinner.succeed('Distribution disabled')
+
+        cli.info('\nNote: Changes may take 15-30 minutes to propagate.')
+        cli.info('To delete the distribution, wait for it to be fully disabled first.')
+      }
+      catch (error: any) {
+        cli.error(`Failed to disable distribution: ${error.message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('cdn:delete <distributionId>', 'Delete a CloudFront distribution')
+    .action(async (distributionId: string) => {
+      cli.header('Delete CloudFront Distribution')
+
+      try {
+        const cloudfront = new CloudFrontClient()
+
+        cli.warn(`This will permanently delete distribution: ${distributionId}`)
+        cli.warn('The distribution must be disabled first.')
+
+        const confirmed = await cli.confirm('\nDelete this distribution?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Checking distribution status...')
+        spinner.start()
+
+        // Get distribution to check status
+        const dist = await cloudfront.getDistribution(distributionId)
+        if (dist.Status !== 'Deployed' || dist.Enabled) {
+          spinner.fail('Distribution must be disabled and deployed before deletion')
+          cli.info('\nRun `cloud cdn:disable` first and wait for status to be "Deployed"')
+          return
+        }
+
+        spinner.text = 'Deleting distribution...'
+
+        await cloudfront.deleteDistribution(distributionId)
+
+        spinner.succeed('Distribution deleted')
+      }
+      catch (error: any) {
+        cli.error(`Failed to delete distribution: ${error.message}`)
+        process.exit(1)
+      }
+    })
+}