@stacksjs/ts-cloud 0.1.1

package/bin/commands/shared.ts

@@ -0,0 +1,97 @@
+import { existsSync } from 'node:fs'
+import type { CloudConfig } from '@stacksjs/ts-cloud-types'
+import { loadCloudConfig } from '../../src/config'
+import { createDnsProvider, DnsProviderFactory } from '../../src/dns'
+import type { DnsProviderConfig, DnsProvider } from '../../src/dns/types'
+
+/**
+ * Load and validate the cloud config, ensuring project config exists.
+ * Returns the config with project guaranteed to exist.
+ */
+export async function loadValidatedConfig(): Promise<CloudConfig> {
+  const cloudConfig = await loadCloudConfig()
+  if (!cloudConfig.project) {
+    throw new Error('Missing required project configuration in cloud.config.ts')
+  }
+  return cloudConfig as CloudConfig
+}
+
+/**
+ * Resolve DNS provider configuration from CLI options and environment variables
+ */
+export function resolveDnsProviderConfig(providerName?: string): DnsProviderConfig | null {
+  // Explicit provider from CLI option
+  if (providerName) {
+    switch (providerName.toLowerCase()) {
+      case 'porkbun': {
+        const apiKey = process.env.PORKBUN_API_KEY
+        const secretKey = process.env.PORKBUN_SECRET_KEY
+        if (!apiKey || !secretKey) {
+          throw new Error('PORKBUN_API_KEY and PORKBUN_SECRET_KEY environment variables are required for Porkbun provider')
+        }
+        return { provider: 'porkbun', apiKey, secretKey }
+      }
+      case 'godaddy': {
+        const apiKey = process.env.GODADDY_API_KEY
+        const apiSecret = process.env.GODADDY_API_SECRET
+        if (!apiKey || !apiSecret) {
+          throw new Error('GODADDY_API_KEY and GODADDY_API_SECRET environment variables are required for GoDaddy provider')
+        }
+        const environment = (process.env.GODADDY_ENVIRONMENT as 'production' | 'ote') || 'production'
+        return { provider: 'godaddy', apiKey, apiSecret, environment }
+      }
+      case 'route53': {
+        const region = process.env.AWS_REGION || 'us-east-1'
+        const hostedZoneId = process.env.AWS_HOSTED_ZONE_ID
+        return { provider: 'route53', region, hostedZoneId }
+      }
+      default:
+        throw new Error(`Unknown DNS provider: ${providerName}. Supported: porkbun, godaddy, route53`)
+    }
+  }
+
+  // Auto-detect from environment
+  const factory = new DnsProviderFactory().loadFromEnv()
+  const providers = factory.getAllProviders()
+
+  if (providers.length === 0) {
+    return null
+  }
+
+  // Return the first configured provider's config
+  if (process.env.PORKBUN_API_KEY && process.env.PORKBUN_SECRET_KEY) {
+    return {
+      provider: 'porkbun',
+      apiKey: process.env.PORKBUN_API_KEY,
+      secretKey: process.env.PORKBUN_SECRET_KEY,
+    }
+  }
+  if (process.env.GODADDY_API_KEY && process.env.GODADDY_API_SECRET) {
+    return {
+      provider: 'godaddy',
+      apiKey: process.env.GODADDY_API_KEY,
+      apiSecret: process.env.GODADDY_API_SECRET,
+      environment: (process.env.GODADDY_ENVIRONMENT as 'production' | 'ote') || 'production',
+    }
+  }
+  if (process.env.AWS_ACCESS_KEY_ID || process.env.AWS_REGION) {
+    return {
+      provider: 'route53',
+      region: process.env.AWS_REGION || 'us-east-1',
+      hostedZoneId: process.env.AWS_HOSTED_ZONE_ID,
+    }
+  }
+
+  return null
+}
+
+/**
+ * Get a DNS provider instance from configuration
+ */
+export function getDnsProvider(providerName?: string): DnsProvider {
+  const config = resolveDnsProviderConfig(providerName)
+  if (!config) {
+    throw new Error('No DNS provider configured. Set environment variables for Porkbun (PORKBUN_API_KEY, PORKBUN_SECRET_KEY), GoDaddy (GODADDY_API_KEY, GODADDY_API_SECRET), or Route53 (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)')
+  }
+  return createDnsProvider(config)
+}

package/bin/commands/ssl.ts

@@ -0,0 +1,138 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+import { ACMClient } from '../../src/aws/acm'
+
+export function registerSslCommands(app: CLI): void {
+  app
+    .command('ssl:list', 'List all SSL certificates')
+    .option('--region <region>', 'AWS region (default: us-east-1)')
+    .action(async (options?: { region?: string }) => {
+      cli.header('SSL Certificates')
+
+      const region = options?.region || 'us-east-1'
+      const spinner = new cli.Spinner('Fetching certificates from ACM...')
+      spinner.start()
+
+      try {
+        const acm = new ACMClient(region)
+
+        // List all certificates
+        const result = await acm.listCertificates()
+
+        if (result.CertificateSummaryList.length === 0) {
+          spinner.succeed('No certificates found')
+          cli.info(`\nNo SSL certificates found in region ${region}`)
+          cli.info('Use \'cloud domain:ssl <domain>\' to request a new certificate')
+          return
+        }
+
+        // Get details for each certificate
+        const certDetails = await Promise.all(
+          result.CertificateSummaryList.map(async (cert) => {
+            const details = await acm.describeCertificate({ CertificateArn: cert.CertificateArn })
+            return details
+          }),
+        )
+
+        spinner.succeed(`Found ${certDetails.length} certificate(s)`)
+
+        // Helper to format AWS timestamp (seconds since epoch)
+        const formatDate = (timestamp: string | number | undefined): string => {
+          if (!timestamp) return 'N/A'
+          // AWS returns seconds since epoch, JS Date expects milliseconds
+          const ts = typeof timestamp === 'string' ? Number.parseFloat(timestamp) : timestamp
+          const ms = ts < 1e12 ? ts * 1000 : ts // Convert if seconds
+          return new Date(ms).toISOString().split('T')[0]
+        }
+
+        // Format the table data
+        const tableData = certDetails.map((cert) => {
+          const expiry = formatDate(cert.NotAfter)
+          const typeDisplay = cert.Type === 'AMAZON_ISSUED' ? 'Amazon Issued' : cert.Type || 'Unknown'
+          const inUse = cert.Status === 'ISSUED' ? 'Available' : cert.Status || 'Unknown'
+
+          return [
+            cert.DomainName,
+            cert.Status || 'Unknown',
+            expiry,
+            typeDisplay,
+            inUse,
+          ]
+        })
+
+        cli.table(
+          ['Domain', 'Status', 'Expiry', 'Type', 'State'],
+          tableData,
+        )
+
+        cli.info('\nACM certificates are automatically renewed by AWS')
+        cli.info(`Region: ${region}`)
+      }
+      catch (error: any) {
+        spinner.fail('Failed to fetch certificates')
+        cli.error(error.message)
+      }
+    })
+
+  app
+    .command('ssl:renew <domain>', 'Renew SSL certificate')
+    .option('--region <region>', 'AWS region (default: us-east-1)')
+    .action(async (domain: string, options?: { region?: string }) => {
+      cli.header(`Checking SSL Certificate for ${domain}`)
+
+      const region = options?.region || 'us-east-1'
+      cli.info(`Domain: ${domain}`)
+      cli.info(`Region: ${region}`)
+
+      const spinner = new cli.Spinner('Checking certificate status...')
+      spinner.start()
+
+      try {
+        const acm = new ACMClient(region)
+
+        // Find certificate by domain
+        const cert = await acm.findCertificateByDomain(domain)
+
+        if (!cert) {
+          spinner.fail('Certificate not found')
+          cli.error(`No certificate found for domain: ${domain}`)
+          cli.info('Use \'cloud domain:ssl <domain>\' to request a new certificate')
+          return
+        }
+
+        spinner.succeed('Certificate found')
+
+        cli.info('\nCertificate is managed by AWS Certificate Manager')
+        cli.info('ACM certificates are automatically renewed 60 days before expiry')
+        cli.warn('\nNo manual renewal needed for ACM certificates')
+
+        // Helper to format AWS timestamp (seconds since epoch)
+        const formatDate = (timestamp: string | number | undefined): string => {
+          if (!timestamp) return 'N/A'
+          const ts = typeof timestamp === 'string' ? Number.parseFloat(timestamp) : timestamp
+          const ms = ts < 1e12 ? ts * 1000 : ts
+          return new Date(ms).toISOString().split('T')[0]
+        }
+
+        const expiry = formatDate(cert.NotAfter)
+        const issued = formatDate(cert.IssuedAt)
+
+        cli.info('\nCertificate details:')
+        cli.info(`  - Domain: ${cert.DomainName}`)
+        cli.info(`  - Status: ${cert.Status}`)
+        cli.info(`  - Issued: ${issued}`)
+        cli.info(`  - Expiry: ${expiry}`)
+        cli.info(`  - Type: ${cert.Type || 'Unknown'}`)
+        cli.info(`  - ARN: ${cert.CertificateArn}`)
+        cli.info(`  - Auto-renewal: ${cert.Type === 'AMAZON_ISSUED' ? 'Enabled' : 'N/A (imported)'}`)
+
+        if (cert.SubjectAlternativeNames && cert.SubjectAlternativeNames.length > 1) {
+          cli.info(`  - SANs: ${cert.SubjectAlternativeNames.join(', ')}`)
+        }
+      }
+      catch (error: any) {
+        spinner.fail('Failed to check certificate')
+        cli.error(error.message)
+      }
+    })
+}

package/bin/commands/stack.ts

@@ -0,0 +1,325 @@
+import type { CLI } from '@stacksjs/clapp'
+import { writeFileSync, statSync } from 'node:fs'
+import * as cli from '../../src/utils/cli'
+import { CloudFormationClient } from '../../src/aws/cloudformation'
+import { loadValidatedConfig } from './shared'
+
+export function registerStackCommands(app: CLI): void {
+  app
+    .command('stack:list', 'List all CloudFormation stacks')
+    .action(async () => {
+      cli.header('CloudFormation Stacks')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Loading stacks...')
+        spinner.start()
+
+        const result = await cfn.listStacks([
+          'CREATE_COMPLETE',
+          'UPDATE_COMPLETE',
+          'ROLLBACK_COMPLETE',
+          'UPDATE_ROLLBACK_COMPLETE',
+          'CREATE_IN_PROGRESS',
+          'UPDATE_IN_PROGRESS',
+        ])
+
+        spinner.succeed(`Found ${result.StackSummaries.length} stacks`)
+
+        if (result.StackSummaries.length === 0) {
+          cli.info('No stacks found')
+          return
+        }
+
+        // Display stacks in a table
+        const headers = ['Stack Name', 'Status', 'Created', 'Updated']
+        const rows = result.StackSummaries.map(stack => [
+          stack.StackName,
+          stack.StackStatus,
+          new Date(stack.CreationTime).toLocaleString(),
+          stack.LastUpdatedTime ? new Date(stack.LastUpdatedTime).toLocaleString() : 'Never',
+        ])
+
+        cli.table(headers, rows)
+      }
+      catch (error: any) {
+        cli.error(`Failed to list stacks: ${error.message}`)
+      }
+    })
+
+  app
+    .command('stack:describe STACK_NAME', 'Describe a CloudFormation stack')
+    .action(async (stackName: string) => {
+      cli.header(`Stack: ${stackName}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Loading stack details...')
+        spinner.start()
+
+        const result = await cfn.describeStacks({ stackName })
+
+        if (!result.Stacks || result.Stacks.length === 0) {
+          spinner.fail('Stack not found')
+          return
+        }
+
+        const stack = result.Stacks[0]
+        spinner.succeed('Stack details loaded')
+
+        // Display stack info
+        cli.info(`\nStack Information:`)
+        cli.info(`  - Name: ${stack.StackName}`)
+        cli.info(`  - Status: ${stack.StackStatus}`)
+        cli.info(`  - Created: ${new Date(stack.CreationTime).toLocaleString()}`)
+        if (stack.LastUpdatedTime) {
+          cli.info(`  - Updated: ${new Date(stack.LastUpdatedTime).toLocaleString()}`)
+        }
+
+        // Display parameters
+        if (stack.Parameters && stack.Parameters.length > 0) {
+          cli.info('\nParameters:')
+          for (const param of stack.Parameters) {
+            cli.info(`  - ${param.ParameterKey}: ${param.ParameterValue}`)
+          }
+        }
+
+        // Display outputs
+        if (stack.Outputs && stack.Outputs.length > 0) {
+          cli.info('\nOutputs:')
+          for (const output of stack.Outputs) {
+            cli.info(`  - ${output.OutputKey}: ${output.OutputValue}`)
+            if (output.Description) {
+              cli.info(`    ${output.Description}`)
+            }
+          }
+        }
+
+        // Display tags
+        if (stack.Tags && stack.Tags.length > 0) {
+          cli.info('\nTags:')
+          for (const tag of stack.Tags) {
+            cli.info(`  - ${tag.Key}: ${tag.Value}`)
+          }
+        }
+
+        // List resources
+        cli.step('\nLoading stack resources...')
+        const resources = await cfn.listStackResources(stackName)
+
+        if (resources.StackResourceSummaries.length > 0) {
+          cli.info(`\nResources (${resources.StackResourceSummaries.length}):`)
+          const resourceHeaders = ['Logical ID', 'Type', 'Status']
+          const resourceRows = resources.StackResourceSummaries.slice(0, 10).map(resource => [
+            resource.LogicalResourceId,
+            resource.ResourceType,
+            resource.ResourceStatus,
+          ])
+
+          cli.table(resourceHeaders, resourceRows)
+
+          if (resources.StackResourceSummaries.length > 10) {
+            cli.info(`\n... and ${resources.StackResourceSummaries.length - 10} more resources`)
+          }
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to describe stack: ${error.message}`)
+      }
+    })
+
+  app
+    .command('stack:delete STACK_NAME', 'Delete a CloudFormation stack')
+    .action(async (stackName: string) => {
+      cli.header(`Delete Stack: ${stackName}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        cli.warn('This will permanently delete the stack and all its resources!')
+
+        const confirmed = await cli.confirm('\nAre you sure you want to delete this stack?', false)
+        if (!confirmed) {
+          cli.info('Deletion cancelled')
+          return
+        }
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Deleting stack...')
+        spinner.start()
+
+        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 deleted successfully!')
+      }
+      catch (error: any) {
+        cli.error(`Failed to delete stack: ${error.message}`)
+      }
+    })
+
+  app
+    .command('stack:events STACK_NAME', 'Show stack events')
+    .option('--limit <number>', 'Limit number of events', { default: '20' })
+    .action(async (stackName: string, options?: { limit?: string }) => {
+      cli.header(`Stack Events: ${stackName}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Loading events...')
+        spinner.start()
+
+        const result = await cfn.describeStackEvents(stackName)
+
+        spinner.succeed(`Found ${result.StackEvents.length} events`)
+
+        const limit = options?.limit ? Number.parseInt(options.limit) : 20
+        const events = result.StackEvents.slice(0, limit)
+
+        if (events.length === 0) {
+          cli.info('No events found')
+          return
+        }
+
+        // Display events
+        const headers = ['Time', 'Resource', 'Status', 'Reason']
+        const rows = events.map(event => [
+          new Date(event.Timestamp).toLocaleString(),
+          event.LogicalResourceId,
+          event.ResourceStatus,
+          event.ResourceStatusReason || '',
+        ])
+
+        cli.table(headers, rows)
+      }
+      catch (error: any) {
+        cli.error(`Failed to load events: ${error.message}`)
+      }
+    })
+
+  app
+    .command('stack:outputs STACK_NAME', 'Show stack outputs')
+    .action(async (stackName: string) => {
+      cli.header(`Stack Outputs: ${stackName}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Loading stack outputs...')
+        spinner.start()
+
+        const result = await cfn.describeStacks({ stackName })
+
+        if (!result.Stacks || result.Stacks.length === 0) {
+          spinner.fail('Stack not found')
+          return
+        }
+
+        const stack = result.Stacks[0]
+        spinner.succeed('Stack outputs loaded')
+
+        if (!stack.Outputs || stack.Outputs.length === 0) {
+          cli.info('No outputs found for this stack')
+          return
+        }
+
+        // Display outputs in a table
+        const headers = ['Key', 'Value', 'Description', 'Export Name']
+        const rows = stack.Outputs.map(output => [
+          output.OutputKey || '',
+          output.OutputValue || '',
+          output.Description || '',
+          output.ExportName || '',
+        ])
+
+        cli.table(headers, rows)
+
+        // Also display in key=value format for easy copying
+        cli.info('\nCopy-friendly format:')
+        for (const output of stack.Outputs) {
+          cli.info(`${output.OutputKey}=${output.OutputValue}`)
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to load outputs: ${error.message}`)
+      }
+    })
+
+  app
+    .command('stack:export STACK_NAME', 'Export stack template')
+    .option('--output <file>', 'Output file path')
+    .option('--format <format>', 'Output format (json or yaml)', { default: 'json' })
+    .action(async (stackName: string, options?: { output?: string, format?: string }) => {
+      cli.header(`Export Stack: ${stackName}`)
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = config.project.region || 'us-east-1'
+
+        const cfn = new CloudFormationClient(region)
+
+        const spinner = new cli.Spinner('Fetching stack template...')
+        spinner.start()
+
+        const result = await cfn.getTemplate(stackName)
+
+        if (!result.TemplateBody) {
+          spinner.fail('Template not found')
+          return
+        }
+
+        spinner.succeed('Template fetched')
+
+        const format = options?.format || 'json'
+        let templateContent = result.TemplateBody
+
+        // Parse and re-format if needed
+        if (format === 'json') {
+          const template = JSON.parse(templateContent)
+          templateContent = JSON.stringify(template, null, 2)
+        }
+
+        // Save to file or display
+        if (options?.output) {
+          const outputPath = options.output
+          writeFileSync(outputPath, templateContent, 'utf-8')
+          cli.success(`Template exported to: ${outputPath}`)
+
+          // Show file size
+          const stats = statSync(outputPath)
+          const sizeInKB = (stats.size / 1024).toFixed(2)
+          cli.info(`File size: ${sizeInKB} KB`)
+        }
+        else {
+          // Display template
+          cli.info('\nTemplate:')
+          console.log(templateContent)
+        }
+      }
+      catch (error: any) {
+        cli.error(`Failed to export template: ${error.message}`)
+      }
+    })
+}