@stacksjs/ts-cloud 0.1.1

package/bin/commands/email.ts

@@ -0,0 +1,423 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+import { SESClient } from '../../src/aws/ses'
+import { loadValidatedConfig } from './shared'
+
+export function registerEmailCommands(app: CLI): void {
+  app
+    .command('email:identities', 'List verified email identities')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('Email Identities')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+        const ses = new SESClient(region)
+
+        const spinner = new cli.Spinner('Fetching identities...')
+        spinner.start()
+
+        const result = await ses.listEmailIdentities()
+        const identities = result.EmailIdentities || []
+
+        spinner.succeed(`Found ${identities.length} identity(s)`)
+
+        if (identities.length === 0) {
+          cli.info('No email identities found')
+          cli.info('Use `cloud email:verify` to verify an email or domain')
+          return
+        }
+
+        // Get verification status for each identity
+        const rows: string[][] = []
+        for (const identity of identities) {
+          const name = identity.IdentityName || 'Unknown'
+          let verificationStatus = 'Unknown'
+          try {
+            const detail = await ses.getEmailIdentity(name)
+            verificationStatus = detail.VerificationStatus || 'Unknown'
+          }
+          catch {
+            // If we can't fetch details, just show what we have
+          }
+          const type = identity.IdentityType === 'EMAIL_ADDRESS' ? 'Email' : identity.IdentityType === 'DOMAIN' ? 'Domain' : (identity.IdentityType || 'Unknown')
+          rows.push([name, type, verificationStatus])
+        }
+
+        cli.table(
+          ['Identity', 'Type', 'Verification Status'],
+          rows,
+        )
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to list identities: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:verify <identity>', 'Verify an email address or domain')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (identity: string, options: { region: string }) => {
+      cli.header('Verify Email Identity')
+
+      try {
+        const ses = new SESClient(options.region)
+
+        const isEmail = identity.includes('@')
+
+        cli.info(`Identity: ${identity}`)
+        cli.info(`Type: ${isEmail ? 'Email Address' : 'Domain'}`)
+
+        const confirmed = await cli.confirm('\nSend verification?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Initiating verification...')
+        spinner.start()
+
+        if (isEmail) {
+          await ses.createEmailIdentity({ EmailIdentity: identity })
+          spinner.succeed('Verification email sent')
+
+          cli.info(`\nA verification email has been sent to ${identity}`)
+          cli.info('Click the link in the email to complete verification.')
+        }
+        else {
+          const result = await ses.verifyDomain(identity)
+          spinner.succeed('Domain verification initiated')
+
+          const dkimTokens = result.dkimTokens || []
+
+          if (dkimTokens.length > 0) {
+            cli.info('\nDKIM Records (for email authentication):')
+            for (const token of dkimTokens) {
+              cli.info(`\n  Name:  ${token}._domainkey.${identity}`)
+              cli.info(`  Type:  CNAME`)
+              cli.info(`  Value: ${token}.dkim.amazonses.com`)
+            }
+          }
+
+          cli.info(`\nVerification Status: ${result.verificationStatus || 'PENDING'}`)
+        }
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to verify identity: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:delete <identity>', 'Delete a verified email identity')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (identity: string, options: { region: string }) => {
+      cli.header('Delete Email Identity')
+
+      try {
+        const ses = new SESClient(options.region)
+
+        cli.warn(`This will remove identity: ${identity}`)
+
+        const confirmed = await cli.confirm('\nDelete this identity?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Deleting identity...')
+        spinner.start()
+
+        await ses.deleteEmailIdentity(identity)
+
+        spinner.succeed('Identity deleted')
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to delete identity: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:send', 'Send a test email')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--from <email>', 'From email address (must be verified)')
+    .option('--to <email>', 'To email address')
+    .option('--subject <text>', 'Email subject')
+    .option('--body <text>', 'Email body (text)')
+    .option('--html <html>', 'Email body (HTML)')
+    .action(async (options: {
+      region: string
+      from?: string
+      to?: string
+      subject?: string
+      body?: string
+      html?: string
+    }) => {
+      cli.header('Send Email')
+
+      try {
+        const ses = new SESClient(options.region)
+
+        const from = options.from || await cli.prompt('From (verified email)')
+        const to = options.to || await cli.prompt('To')
+        const subject = options.subject || await cli.prompt('Subject', 'Test Email from ts-cloud')
+        const body = options.body || await cli.prompt('Body', 'This is a test email sent from ts-cloud CLI.')
+
+        cli.info(`\nFrom: ${from}`)
+        cli.info(`To: ${to}`)
+        cli.info(`Subject: ${subject}`)
+
+        const confirmed = await cli.confirm('\nSend this email?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Sending email...')
+        spinner.start()
+
+        const result = await ses.sendEmail({
+          FromEmailAddress: from,
+          Destination: {
+            ToAddresses: [to],
+          },
+          Content: {
+            Simple: {
+              Subject: {
+                Data: subject,
+              },
+              Body: {
+                Text: {
+                  Data: body,
+                },
+                ...(options.html && {
+                  Html: {
+                    Data: options.html,
+                  },
+                }),
+              },
+            },
+          },
+        })
+
+        spinner.succeed('Email sent')
+
+        cli.success(`\nMessage ID: ${result.MessageId}`)
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to send email: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:templates', 'List email templates')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('Email Templates')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+        const ses = new SESClient(region)
+
+        const spinner = new cli.Spinner('Fetching templates...')
+        spinner.start()
+
+        const result = await ses.listEmailTemplates()
+        const templates = result.TemplatesMetadata || []
+
+        spinner.succeed(`Found ${templates.length} template(s)`)
+
+        if (templates.length === 0) {
+          cli.info('No email templates found')
+          cli.info('Use `cloud email:template:create` to create a template')
+          return
+        }
+
+        cli.table(
+          ['Name', 'Created'],
+          templates.map((t: { TemplateName?: string, CreatedTimestamp?: string }) => [
+            t.TemplateName || 'N/A',
+            t.CreatedTimestamp ? new Date(t.CreatedTimestamp).toLocaleString() : 'N/A',
+          ]),
+        )
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to list templates: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:template:create <name>', 'Create an email template')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .option('--subject <text>', 'Email subject (supports {{variable}} placeholders)')
+    .option('--text <text>', 'Text body')
+    .option('--html <html>', 'HTML body')
+    .option('--html-file <path>', 'HTML body from file')
+    .action(async (name: string, options: {
+      region: string
+      subject?: string
+      text?: string
+      html?: string
+      htmlFile?: string
+    }) => {
+      cli.header('Create Email Template')
+
+      try {
+        const ses = new SESClient(options.region)
+
+        const subject = options.subject || await cli.prompt('Subject template', 'Hello {{name}}')
+        const textBody = options.text || await cli.prompt('Text body', 'Hello {{name}}, this is a test.')
+
+        let htmlBody = options.html
+        if (options.htmlFile) {
+          const file = Bun.file(options.htmlFile)
+          htmlBody = await file.text()
+        }
+
+        cli.info(`\nTemplate Name: ${name}`)
+        cli.info(`Subject: ${subject}`)
+
+        const confirmed = await cli.confirm('\nCreate this template?', true)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Creating template...')
+        spinner.start()
+
+        await ses.createEmailTemplate({
+          TemplateName: name,
+          TemplateContent: {
+            Subject: subject,
+            Text: textBody,
+            Html: htmlBody,
+          },
+        })
+
+        spinner.succeed('Template created')
+
+        cli.info('\nTo send using this template:')
+        cli.info(`  cloud email:send:template --template ${name} --to user@example.com --data '{"name":"John"}'`)
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to create template: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:template:delete <name>', 'Delete an email template')
+    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
+    .action(async (name: string, options: { region: string }) => {
+      cli.header('Delete Email Template')
+
+      try {
+        const ses = new SESClient(options.region)
+
+        cli.warn(`This will delete template: ${name}`)
+
+        const confirmed = await cli.confirm('\nDelete this template?', false)
+        if (!confirmed) {
+          cli.info('Operation cancelled')
+          return
+        }
+
+        const spinner = new cli.Spinner('Deleting template...')
+        spinner.start()
+
+        await ses.deleteEmailTemplate(name)
+
+        spinner.succeed('Template deleted')
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to delete template: ${message}`)
+        process.exit(1)
+      }
+    })
+
+  app
+    .command('email:stats', 'Show SES sending statistics')
+    .option('--region <region>', 'AWS region')
+    .action(async (options: { region?: string }) => {
+      cli.header('Email Statistics')
+
+      try {
+        const config = await loadValidatedConfig()
+        const region = options.region || config.project.region || 'us-east-1'
+        const ses = new SESClient(region)
+
+        const spinner = new cli.Spinner('Fetching statistics...')
+        spinner.start()
+
+        const [quota, stats] = await Promise.all([
+          ses.getSendQuota(),
+          ses.getSendStatistics(),
+        ])
+
+        spinner.succeed('Statistics loaded')
+
+        cli.info('\nSending Quota:')
+        cli.info(`  Max 24-hour Send: ${quota.Max24HourSend || 0}`)
+        cli.info(`  Max Send Rate: ${quota.MaxSendRate || 0} emails/second`)
+        cli.info(`  Sent Last 24h: ${quota.SentLast24Hours || 0}`)
+
+        const remaining = (quota.Max24HourSend || 0) - (quota.SentLast24Hours || 0)
+        cli.info(`  Remaining: ${remaining}`)
+
+        if (stats.SendDataPoints && stats.SendDataPoints.length > 0) {
+          cli.info('\nRecent Statistics:')
+
+          // Aggregate stats
+          let totalDelivered = 0
+          let totalBounces = 0
+          let totalComplaints = 0
+          let totalRejects = 0
+
+          for (const point of stats.SendDataPoints) {
+            totalDelivered += point.DeliveryAttempts || 0
+            totalBounces += point.Bounces || 0
+            totalComplaints += point.Complaints || 0
+            totalRejects += point.Rejects || 0
+          }
+
+          cli.info(`  Total Attempts: ${totalDelivered}`)
+          cli.info(`  Bounces: ${totalBounces}`)
+          cli.info(`  Complaints: ${totalComplaints}`)
+          cli.info(`  Rejects: ${totalRejects}`)
+
+          if (totalDelivered > 0) {
+            const bounceRate = ((totalBounces / totalDelivered) * 100).toFixed(2)
+            const complaintRate = ((totalComplaints / totalDelivered) * 100).toFixed(2)
+            cli.info(`\n  Bounce Rate: ${bounceRate}%`)
+            cli.info(`  Complaint Rate: ${complaintRate}%`)
+
+            if (Number.parseFloat(bounceRate) > 5) {
+              cli.warn('\n  Warning: Bounce rate is high (>5%). This may affect your sender reputation.')
+            }
+            if (Number.parseFloat(complaintRate) > 0.1) {
+              cli.warn('\n  Warning: Complaint rate is high (>0.1%). This may affect your sender reputation.')
+            }
+          }
+        }
+      }
+      catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error)
+        cli.error(`Failed to get statistics: ${message}`)
+        process.exit(1)
+      }
+    })
+}

package/bin/commands/environment.ts

@@ -0,0 +1,285 @@
+import type { CLI } from '@stacksjs/clapp'
+import * as cli from '../../src/utils/cli'
+
+export function registerEnvironmentCommands(app: CLI): void {
+  app
+    .command('env:create <name>', 'Create new environment')
+    .option('--clone <source>', 'Clone from existing environment')
+    .action(async (name: string, options?: { clone?: string }) => {
+      cli.header(`Creating Environment: ${name}`)
+
+      const validEnvs = ['production', 'staging', 'development', 'preview', 'test']
+      if (!validEnvs.includes(name.toLowerCase())) {
+        cli.warn(`Warning: Creating non-standard environment name`)
+        cli.info(`Standard names: ${validEnvs.join(', ')}`)
+      }
+
+      if (options?.clone) {
+        cli.info(`Cloning from: ${options.clone}`)
+      }
+
+      const confirm = await cli.confirm('\nCreate this environment?', true)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const spinner = new cli.Spinner('Creating environment infrastructure...')
+      spinner.start()
+
+      // TODO: Create CloudFormation stack for new environment
+      // TODO: If cloning, copy configuration from source environment
+      await new Promise(resolve => setTimeout(resolve, 3000))
+
+      spinner.succeed('Environment created successfully')
+
+      cli.success('\nEnvironment created!')
+      cli.info(`Environment ${name} is now available`)
+
+      cli.info('\nNext steps:')
+      cli.info(`  - Deploy to environment: cloud deploy --env ${name}`)
+      cli.info(`  - Switch to environment: cloud env:switch ${name}`)
+    })
+
+  app
+    .command('env:list', 'List environments')
+    .action(async () => {
+      cli.header('Environments')
+
+      const spinner = new cli.Spinner('Fetching environments...')
+      spinner.start()
+
+      // TODO: Fetch from CloudFormation stacks or config
+      await new Promise(resolve => setTimeout(resolve, 1500))
+
+      spinner.stop()
+
+      cli.table(
+        ['Environment', 'Status', 'Region', 'Last Deployed', 'Active'],
+        [
+          ['production', 'Active', 'us-east-1', '2 hours ago', ''],
+          ['staging', 'Active', 'us-east-1', '1 day ago', '*'],
+          ['development', 'Active', 'us-west-2', '3 days ago', ''],
+          ['preview-pr-123', 'Active', 'us-east-1', '5 hours ago', ''],
+        ],
+      )
+
+      cli.info('\nTip: Use `cloud env:switch NAME` to switch active environment')
+      cli.info('Tip: Use `cloud env:create NAME` to create new environment')
+    })
+
+  app
+    .command('env:switch <name>', 'Switch active environment')
+    .action(async (name: string) => {
+      cli.header(`Switching to Environment: ${name}`)
+
+      cli.info(`Switching to: ${name}`)
+
+      const spinner = new cli.Spinner('Updating environment configuration...')
+      spinner.start()
+
+      // TODO: Update config to set active environment
+      await new Promise(resolve => setTimeout(resolve, 1000))
+
+      spinner.succeed('Environment switched successfully')
+
+      cli.success(`\nNow using environment: ${name}`)
+      cli.info(`All commands will now target the ${name} environment`)
+
+      cli.info('\nEnvironment details:')
+      cli.info(`  - Region: us-east-1`)
+      cli.info(`  - Status: Active`)
+      cli.info(`  - Last deployed: 1 day ago`)
+    })
+
+  app
+    .command('env:clone <source> <target>', 'Clone environment')
+    .action(async (source: string, target: string) => {
+      cli.header('Cloning Environment')
+
+      cli.info(`Source: ${source}`)
+      cli.info(`Target: ${target}`)
+
+      cli.warn('\nThis will copy:')
+      cli.info('  - Infrastructure configuration')
+      cli.info('  - Environment variables')
+      cli.info('  - Database schema (not data)')
+
+      const confirm = await cli.confirm('\nClone environment?', true)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const spinner = new cli.Spinner('Cloning environment...')
+      spinner.start()
+
+      // TODO: Copy CloudFormation stack and config
+      await new Promise(resolve => setTimeout(resolve, 5000))
+
+      spinner.succeed('Environment cloned')
+
+      cli.success(`\nEnvironment ${target} created from ${source}!`)
+      cli.info('Deploy with: cloud deploy --env ' + target)
+    })
+
+  app
+    .command('env:promote <source> <target>', 'Promote environment')
+    .action(async (source: string, target: string) => {
+      cli.header('Promoting Environment')
+
+      cli.info(`From: ${source}`)
+      cli.info(`To: ${target}`)
+
+      cli.warn('\nThis will:')
+      cli.info('  - Deploy code from source to target')
+      cli.info('  - Update target configuration')
+      cli.info('  - Run database migrations if any')
+
+      const confirm = await cli.confirm('\nPromote to ' + target + '?', false)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const spinner = new cli.Spinner('Promoting environment...')
+      spinner.start()
+
+      // TODO: Deploy source to target
+      await new Promise(resolve => setTimeout(resolve, 6000))
+
+      spinner.succeed('Promotion complete')
+
+      cli.success(`\n${source} promoted to ${target}!`)
+    })
+
+  app
+    .command('env:compare <env1> <env2>', 'Compare configurations')
+    .action(async (env1: string, env2: string) => {
+      cli.header('Comparing Environments')
+
+      cli.info(`Environment 1: ${env1}`)
+      cli.info(`Environment 2: ${env2}`)
+
+      const spinner = new cli.Spinner('Analyzing configurations...')
+      spinner.start()
+
+      // TODO: Compare CloudFormation stacks and config
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      spinner.stop()
+
+      cli.info('\nConfiguration Differences:\n')
+
+      cli.table(
+        ['Setting', env1, env2, 'Match'],
+        [
+          ['Instance Type', 't3.medium', 't3.small', 'X'],
+          ['Database Size', 'db.t3.medium', 'db.t3.micro', 'X'],
+          ['Auto Scaling', 'Enabled', 'Disabled', 'X'],
+          ['Region', 'us-east-1', 'us-east-1', '*'],
+          ['Node Version', '20.x', '20.x', '*'],
+        ],
+      )
+
+      cli.info('\nFound 3 differences')
+    })
+
+  app
+    .command('env:sync <source> <target>', 'Sync configuration')
+    .action(async (source: string, target: string) => {
+      cli.header('Syncing Configuration')
+
+      cli.info(`Source: ${source}`)
+      cli.info(`Target: ${target}`)
+
+      cli.warn('\nThis will sync configuration (not resources or data)')
+
+      const confirm = await cli.confirm('\nSync configuration?', true)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const spinner = new cli.Spinner('Syncing configuration...')
+      spinner.start()
+
+      // TODO: Sync config files
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      spinner.succeed('Configuration synced')
+
+      cli.success('\nConfiguration synchronized!')
+    })
+
+  app
+    .command('env:preview <branch>', 'Create preview environment from branch')
+    .action(async (branch: string) => {
+      cli.header(`Creating Preview Environment for ${branch}`)
+
+      const envName = `preview-${branch.replace(/[^a-z0-9]/gi, '-').toLowerCase()}`
+
+      cli.info(`Environment name: ${envName}`)
+      cli.info(`Branch: ${branch}`)
+
+      const confirm = await cli.confirm('\nCreate preview environment?', true)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const spinner = new cli.Spinner('Creating preview environment...')
+      spinner.start()
+
+      // TODO: Create temporary CloudFormation stack
+      await new Promise(resolve => setTimeout(resolve, 8000))
+
+      spinner.succeed('Preview environment created')
+
+      cli.success('\nPreview environment ready!')
+      cli.info(`URL: https://${envName}.preview.example.com`)
+      cli.info('\nThis environment will auto-delete after 7 days')
+    })
+
+  app
+    .command('env:cleanup', 'Remove stale preview environments')
+    .action(async () => {
+      cli.header('Cleaning Up Preview Environments')
+
+      const spinner = new cli.Spinner('Finding stale preview environments...')
+      spinner.start()
+
+      // TODO: Find old preview stacks
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      spinner.stop()
+
+      cli.info('\nFound 3 stale preview environments:\n')
+
+      cli.table(
+        ['Environment', 'Created', 'Age', 'Status'],
+        [
+          ['preview-feature-123', '2024-10-15', '30 days', 'Inactive'],
+          ['preview-bugfix-456', '2024-10-20', '25 days', 'Inactive'],
+          ['preview-test-789', '2024-11-01', '14 days', 'Inactive'],
+        ],
+      )
+
+      const confirm = await cli.confirm('\nDelete these environments?', true)
+      if (!confirm) {
+        cli.info('Operation cancelled')
+        return
+      }
+
+      const cleanupSpinner = new cli.Spinner('Deleting stale environments...')
+      cleanupSpinner.start()
+
+      // TODO: Delete CloudFormation stacks
+      await new Promise(resolve => setTimeout(resolve, 4000))
+
+      cleanupSpinner.succeed('Cleanup complete')
+
+      cli.success('\n3 preview environments deleted!')
+      cli.info('Estimated monthly savings: $87')
+    })
+}