@stacksjs/ts-cloud 0.1.2 → 0.1.5

package/bin/commands/cache.ts

@@ -1,294 +0,0 @@
-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

@@ -1,281 +0,0 @@
-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)
-      }
-    })
-}