@stacksjs/ts-cloud 0.1.3 → 0.1.6

package/bin/commands/tunnel.ts

@@ -1,489 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import * as cli from '../../src/utils/cli'
-
-export function registerTunnelCommands(app: CLI): void {
-  app
-    .command('tunnel', 'Start a local tunnel to expose your local server')
-    .option('--port <number>', 'Local port to expose', { default: '3000' })
-    .option('--subdomain <name>', 'Custom subdomain (if available)')
-    .option('--host <hostname>', 'Local hostname', { default: 'localhost' })
-    .option('--server <url>', 'Tunnel server URL', { default: 'localtunnel.dev' })
-    .option('--verbose', 'Enable verbose logging')
-    .action(async (options: { port: string; subdomain?: string; host: string; server: string; verbose?: boolean }) => {
-      cli.header('Local Tunnel')
-
-      const port = Number.parseInt(options.port)
-
-      cli.info(`Local server: ${options.host}:${port}`)
-      cli.info(`Tunnel server: ${options.server}`)
-
-      if (options.subdomain) {
-        cli.info(`Requested subdomain: ${options.subdomain}`)
-      }
-
-      const spinner = new cli.Spinner('Connecting to tunnel server...')
-      spinner.start()
-
-      try {
-        // Try to dynamically import localtunnels
-        let TunnelClient: any
-
-        try {
-          // @ts-expect-error -- localtunnels is an optional dependency
-          const localtunnels = await import('localtunnels')
-          TunnelClient = localtunnels.TunnelClient
-        }
-        catch {
-          spinner.fail('localtunnels package not found')
-          cli.info('\nTo use tunnels, install the localtunnels package:')
-          cli.info('  bun add localtunnels')
-          cli.info('\nOr use the standalone CLI:')
-          cli.info('  bunx localtunnels --port 3000')
-          return
-        }
-
-        const serverHost = options.server.replace(/^(wss?|https?):\/\//, '')
-        const secure = options.server.startsWith('wss://') || options.server.startsWith('https://') || serverHost === 'localtunnel.dev'
-
-        const client = new TunnelClient({
-          localPort: port,
-          localHost: options.host,
-          subdomain: options.subdomain,
-          host: serverHost,
-          port: secure ? 443 : 80,
-          secure,
-          verbose: options.verbose,
-        })
-
-        client.on('connected', (info: { url: string; subdomain: string }) => {
-          spinner.succeed('Connected!')
-          cli.success(`\nYour tunnel URL: ${info.url}`)
-          cli.info(`Subdomain: ${info.subdomain}`)
-          cli.info(`\nForwarding: ${info.url} -> http://${options.host}:${port}`)
-          cli.info('\nPress Ctrl+C to stop the tunnel')
-        })
-
-        client.on('request', (req: { method: string; url: string }) => {
-          if (options.verbose) {
-            cli.info(`→ ${req.method} ${req.url}`)
-          }
-        })
-
-        client.on('response', (res: { status: number; size: number; duration?: number }) => {
-          if (options.verbose) {
-            cli.info(`← ${res.status} (${res.size} bytes${res.duration ? `, ${res.duration}ms` : ''})`)
-          }
-        })
-
-        client.on('reconnecting', (info: { attempt: number; maxAttempts: number }) => {
-          cli.info(`Reconnecting... (attempt ${info.attempt}/${info.maxAttempts})`)
-        })
-
-        client.on('error', (error: Error) => {
-          cli.error(`Tunnel error: ${error.message}`)
-        })
-
-        client.on('close', () => {
-          cli.info('\nTunnel closed')
-        })
-
-        // Handle process signals for graceful shutdown
-        const cleanup = () => {
-          cli.info('\nShutting down tunnel...')
-          client.disconnect()
-          process.exit(0)
-        }
-
-        process.on('SIGINT', cleanup)
-        process.on('SIGTERM', cleanup)
-
-        await client.connect()
-
-        // Keep the process running
-        await new Promise(() => {})
-      }
-      catch (error: any) {
-        spinner.fail('Failed to connect')
-        cli.error(`Error: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('tunnel:status', 'Check tunnel server status')
-    .option('--server <url>', 'Tunnel server URL', { default: 'https://localtunnel.dev' })
-    .action(async (options: { server: string }) => {
-      cli.header('Tunnel Server Status')
-
-      const spinner = new cli.Spinner('Checking server status...')
-      spinner.start()
-
-      try {
-        const serverUrl = options.server.startsWith('http')
-          ? options.server
-          : `https://${options.server}`
-
-        const response = await fetch(`${serverUrl}/status`, {
-          method: 'GET',
-          headers: { Accept: 'application/json' },
-        })
-
-        if (response.ok) {
-          const status = await response.json() as Record<string, any>
-          spinner.succeed('Server is online')
-
-          cli.info(`\nServer: ${options.server}`)
-          cli.info(`Status: ${status.status || 'operational'}`)
-
-          if (status.version) {
-            cli.info(`Version: ${status.version}`)
-          }
-
-          if (status.connections !== undefined) {
-            cli.info(`Active connections: ${status.connections}`)
-          }
-
-          if (status.uptime) {
-            cli.info(`Uptime: ${status.uptime}`)
-          }
-
-          if (status.activeSubdomains?.length) {
-            cli.info(`Active subdomains: ${status.activeSubdomains.join(', ')}`)
-          }
-        }
-        else {
-          spinner.fail(`Server returned status ${response.status}`)
-        }
-      }
-      catch (error: any) {
-        spinner.fail('Failed to check server status')
-        cli.error(`Error: ${error.message}`)
-        cli.info('\nThe tunnel server may be offline or unreachable.')
-      }
-    })
-
-  app
-    .command('tunnel:info', 'Show tunnel configuration and setup info')
-    .action(async () => {
-      cli.header('Local Tunnel Information')
-
-      cli.info('ts-cloud uses localtunnels for secure tunnel connections.')
-      cli.info('')
-      cli.info('Default server: localtunnel.dev')
-      cli.info('')
-      cli.info('Usage:')
-      cli.info('  cloud tunnel --port 3000              # Expose port 3000')
-      cli.info('  cloud tunnel --port 8080 --subdomain myapp')
-      cli.info('')
-      cli.info('Features:')
-      cli.info('  - Secure WebSocket-based tunnels')
-      cli.info('  - Custom subdomains (when available)')
-      cli.info('  - Automatic reconnection')
-      cli.info('  - Request logging')
-      cli.info('  - Binary data support')
-      cli.info('')
-      cli.info('Self-hosted tunnel server:')
-      cli.info('  You can run your own tunnel server using localtunnels.')
-      cli.info('  See: https://github.com/stacksjs/localtunnels')
-      cli.info('')
-      cli.info('Environment variables:')
-      cli.info('  TUNNEL_SERVER - Custom tunnel server URL')
-      cli.info('  TUNNEL_SUBDOMAIN - Default subdomain to request')
-    })
-
-  app
-    .command('tunnel:deploy', 'Deploy tunnel infrastructure to AWS')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--prefix <prefix>', 'Resource name prefix', { default: 'localtunnel' })
-    .option('--verbose', 'Enable verbose logging')
-    .action(async (options: { region: string; prefix: string; verbose?: boolean }) => {
-      cli.header('Deploy Tunnel Infrastructure')
-
-      cli.info(`Region: ${options.region}`)
-      cli.info(`Prefix: ${options.prefix}`)
-      cli.info('')
-
-      cli.info('This will deploy:')
-      cli.info('  - DynamoDB tables for connection tracking')
-      cli.info('  - Lambda functions for handling requests')
-      cli.info('  - Lambda Function URLs for public access')
-      cli.info('')
-
-      const confirmed = await cli.confirm('Deploy tunnel infrastructure?', false)
-      if (!confirmed) {
-        cli.info('Operation cancelled')
-        return
-      }
-
-      const spinner = new cli.Spinner('Deploying infrastructure...')
-      spinner.start()
-
-      try {
-        // Try to import the deploy function from localtunnels
-        let deployTunnelInfrastructure: any
-
-        try {
-          // @ts-expect-error -- localtunnels is an optional dependency
-          const cloudModule = await import('localtunnels/cloud')
-          deployTunnelInfrastructure = cloudModule.deployTunnelInfrastructure
-        }
-        catch {
-          spinner.fail('localtunnels package not found')
-          cli.info('\nTo deploy tunnel infrastructure, install localtunnels:')
-          cli.info('  bun add localtunnels')
-          cli.info('\nOr deploy using the localtunnels CLI directly:')
-          cli.info('  bunx localtunnels deploy --region us-east-1')
-          return
-        }
-
-        const result = await deployTunnelInfrastructure({
-          region: options.region,
-          prefix: options.prefix,
-          verbose: options.verbose,
-        })
-
-        spinner.succeed('Deployment complete!')
-
-        cli.info('')
-        cli.info('Resources created:')
-        cli.info(`  DynamoDB Tables:`)
-        cli.info(`    - ${result.connectionsTable}`)
-        cli.info(`    - ${result.responsesTable}`)
-        cli.info('')
-        cli.info(`  Lambda Functions:`)
-        cli.info(`    - ${result.functions.http}`)
-        cli.info(`    - ${result.functions.message}`)
-        cli.info('')
-
-        if (result.httpUrl || result.wsUrl) {
-          cli.info('Endpoints:')
-          if (result.httpUrl) {
-            cli.info(`  HTTP URL: ${result.httpUrl}`)
-          }
-          if (result.wsUrl) {
-            cli.info(`  WebSocket URL: ${result.wsUrl}`)
-          }
-        }
-      }
-      catch (error: any) {
-        spinner.fail('Deployment failed')
-        cli.error(`Error: ${error.message}`)
-        if (options.verbose) {
-          console.error(error.stack)
-        }
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('tunnel:destroy', 'Destroy tunnel infrastructure from AWS')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--prefix <prefix>', 'Resource name prefix', { default: 'localtunnel' })
-    .option('--verbose', 'Enable verbose logging')
-    .action(async (options: { region: string; prefix: string; verbose?: boolean }) => {
-      cli.header('Destroy Tunnel Infrastructure')
-
-      cli.info(`Region: ${options.region}`)
-      cli.info(`Prefix: ${options.prefix}`)
-      cli.info('')
-
-      cli.warn('This will permanently delete:')
-      cli.warn('  - All DynamoDB tables and data')
-      cli.warn('  - All Lambda functions')
-      cli.warn('  - All IAM roles and policies')
-      cli.info('')
-
-      const confirmed = await cli.confirm('Are you sure you want to destroy this infrastructure?', false)
-      if (!confirmed) {
-        cli.info('Operation cancelled')
-        return
-      }
-
-      const spinner = new cli.Spinner('Destroying infrastructure...')
-      spinner.start()
-
-      try {
-        let destroyTunnelInfrastructure: any
-
-        try {
-          // @ts-expect-error -- localtunnels is an optional dependency
-          const cloudModule = await import('localtunnels/cloud')
-          destroyTunnelInfrastructure = cloudModule.destroyTunnelInfrastructure
-        }
-        catch {
-          spinner.fail('localtunnels package not found')
-          cli.info('\nTo destroy tunnel infrastructure, install localtunnels:')
-          cli.info('  bun add localtunnels')
-          cli.info('\nOr destroy using the localtunnels CLI directly:')
-          cli.info('  bunx localtunnels destroy --region us-east-1')
-          return
-        }
-
-        await destroyTunnelInfrastructure({
-          region: options.region,
-          prefix: options.prefix,
-          verbose: options.verbose,
-        })
-
-        spinner.succeed('Infrastructure destroyed!')
-      }
-      catch (error: any) {
-        spinner.fail('Destruction failed')
-        cli.error(`Error: ${error.message}`)
-        if (options.verbose) {
-          console.error(error.stack)
-        }
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('tunnel:logs', 'View tunnel server logs')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--prefix <prefix>', 'Resource name prefix', { default: 'localtunnel' })
-    .option('--tail', 'Tail the logs')
-    .action(async (options: { region: string; prefix: string; tail?: boolean }) => {
-      cli.header('Tunnel Server Logs')
-
-      cli.info('Tunnel server log groups:')
-      cli.info(`  - /aws/lambda/${options.prefix}-connect`)
-      cli.info(`  - /aws/lambda/${options.prefix}-disconnect`)
-      cli.info(`  - /aws/lambda/${options.prefix}-message`)
-      cli.info(`  - /aws/lambda/${options.prefix}-http`)
-      cli.info('')
-
-      cli.info('To view logs:')
-      cli.info(`  aws logs tail /aws/lambda/${options.prefix}-http --region ${options.region}${options.tail ? ' --follow' : ''}`)
-      cli.info('')
-
-      cli.info('Or use CloudWatch Insights:')
-      cli.info(`  1. Go to CloudWatch > Logs Insights`)
-      cli.info(`  2. Select the tunnel log groups`)
-      cli.info(`  3. Run queries like:`)
-      cli.info(`     fields @timestamp, @message | filter @message like /error/i`)
-    })
-
-  app
-    .command('tunnel:test <url>', 'Test a tunnel connection')
-    .action(async (url: string) => {
-      cli.header('Test Tunnel Connection')
-
-      const spinner = new cli.Spinner(`Testing ${url}...`)
-      spinner.start()
-
-      try {
-        const startTime = Date.now()
-        const response = await fetch(url, {
-          method: 'GET',
-          headers: {
-            'User-Agent': 'ts-cloud-tunnel-test',
-          },
-        })
-
-        const elapsed = Date.now() - startTime
-
-        spinner.succeed(`Connected in ${elapsed}ms`)
-
-        cli.info(`\nStatus: ${response.status} ${response.statusText}`)
-        cli.info('\nResponse headers:')
-        response.headers.forEach((value, key) => {
-          cli.info(`  ${key}: ${value}`)
-        })
-
-        const body = await response.text()
-        if (body.length > 0) {
-          cli.info('\nResponse body (first 500 chars):')
-          console.log(body.substring(0, 500))
-          if (body.length > 500) {
-            cli.info(`... (${body.length - 500} more characters)`)
-          }
-        }
-      }
-      catch (error: any) {
-        spinner.fail('Connection failed')
-        cli.error(`Error: ${error.message}`)
-      }
-    })
-
-  app
-    .command('tunnel:server', 'Start a self-hosted tunnel server')
-    .option('--port <number>', 'Port to listen on', { default: '3000' })
-    .option('--host <hostname>', 'Host to bind to', { default: '0.0.0.0' })
-    .option('--domain <domain>', 'Domain for tunnel URLs', { default: 'localhost' })
-    .option('--verbose', 'Enable verbose logging')
-    .action(async (options: { port: string; host: string; domain: string; verbose?: boolean }) => {
-      cli.header('Local Tunnel Server')
-
-      const port = Number.parseInt(options.port)
-
-      cli.info(`Listening on: ${options.host}:${port}`)
-      cli.info(`Domain: ${options.domain}`)
-      cli.info('')
-
-      const spinner = new cli.Spinner('Starting tunnel server...')
-      spinner.start()
-
-      try {
-        let TunnelServer: any
-
-        try {
-          // @ts-expect-error -- localtunnels is an optional dependency
-          const localtunnels = await import('localtunnels')
-          TunnelServer = localtunnels.TunnelServer
-        }
-        catch {
-          spinner.fail('localtunnels package not found')
-          cli.info('\nTo run a tunnel server, install localtunnels:')
-          cli.info('  bun add localtunnels')
-          cli.info('\nOr use the standalone CLI:')
-          cli.info('  bunx localtunnels server --port 3000')
-          return
-        }
-
-        const server = new TunnelServer({
-          port,
-          host: options.host,
-          verbose: options.verbose,
-        })
-
-        server.on('connection', (info: { subdomain: string; totalConnections: number }) => {
-          cli.info(`+ Client connected: ${info.subdomain} (total: ${info.totalConnections})`)
-        })
-
-        server.on('disconnection', (info: { subdomain: string }) => {
-          cli.info(`- Client disconnected: ${info.subdomain}`)
-        })
-
-        // Handle process signals for graceful shutdown
-        const cleanup = () => {
-          cli.info('\nShutting down server...')
-          server.stop()
-          process.exit(0)
-        }
-
-        process.on('SIGINT', cleanup)
-        process.on('SIGTERM', cleanup)
-
-        await server.start()
-
-        spinner.succeed('Server running!')
-
-        cli.info('')
-        cli.info(`WebSocket URL: ws://${options.host === '0.0.0.0' ? 'localhost' : options.host}:${port}`)
-        cli.info(`HTTP URL: http://${options.host === '0.0.0.0' ? 'localhost' : options.host}:${port}`)
-        cli.info('')
-        cli.info('Clients can connect with:')
-        cli.info(`  cloud tunnel --port 3000 --server ${options.host === '0.0.0.0' ? 'localhost' : options.host}:${port}`)
-        cli.info('')
-        cli.info('Press Ctrl+C to stop the server')
-
-        // Keep the process running
-        await new Promise(() => {})
-      }
-      catch (error: any) {
-        spinner.fail('Failed to start server')
-        cli.error(`Error: ${error.message}`)
-        process.exit(1)
-      }
-    })
-}

package/bin/commands/utils.ts

@@ -1,202 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import { existsSync } from 'node:fs'
-import * as cli from '../../src/utils/cli'
-import { CloudFormationClient } from '../../src/aws/cloudformation'
-import { ACMClient } from '../../src/aws/acm'
-
-export function registerUtilsCommands(app: CLI, version: string): void {
-  app
-    .command('upgrade', 'Upgrade CLI to latest version')
-    .action(async () => {
-      cli.header('Upgrading ts-cloud CLI')
-
-      const spinner = new cli.Spinner('Checking for updates...')
-      spinner.start()
-
-      // TODO: Check npm/GitHub for latest version
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      spinner.stop()
-
-      cli.info('\nCurrent version: 0.1.0')
-      cli.info('Latest version: 0.2.0')
-
-      const confirm = await cli.confirm('\nUpgrade to latest version?', true)
-      if (!confirm) {
-        cli.info('Operation cancelled')
-        return
-      }
-
-      const upgradeSpinner = new cli.Spinner('Upgrading...')
-      upgradeSpinner.start()
-
-      // TODO: Run npm/bun upgrade command
-      await new Promise(resolve => setTimeout(resolve, 3000))
-
-      upgradeSpinner.succeed('Upgrade completed successfully')
-
-      cli.success('\nts-cloud CLI upgraded to v0.2.0!')
-
-      cli.info('\nWhat\'s new in v0.2.0:')
-      cli.info('  - New cost optimization commands')
-      cli.info('  - Improved team collaboration features')
-      cli.info('  - Better error messages')
-      cli.info('  - Performance improvements')
-
-      cli.info('\nTip: Run `cloud --help` to see all available commands')
-    })
-
-  app
-    .command('doctor', 'Check system requirements and AWS credentials')
-    .action(async () => {
-      cli.header('System Diagnostics')
-
-      // Check Bun
-      cli.step('Checking Bun...')
-      cli.success(`Bun ${process.versions.bun}`)
-
-      // Check AWS CLI
-      cli.step('Checking AWS CLI...')
-      const hasAwsCli = await cli.checkAwsCli()
-      if (hasAwsCli) {
-        cli.success('AWS CLI is installed')
-      }
-      else {
-        cli.error('AWS CLI is not installed')
-        cli.info('Install: https://aws.amazon.com/cli/')
-      }
-
-      // Check AWS credentials
-      cli.step('Checking AWS credentials...')
-      const hasCredentials = await cli.checkAwsCredentials()
-      if (hasCredentials) {
-        cli.success('AWS credentials are configured')
-        const accountId = await cli.getAwsAccountId()
-        if (accountId) {
-          cli.info(`Account ID: ${accountId}`)
-        }
-      }
-      else {
-        cli.error('AWS credentials are not configured')
-        cli.info('Run: aws configure')
-      }
-
-      // Check CloudFront access (list)
-      cli.step('Checking CloudFront list access...')
-      let cloudfrontListOk = false
-      try {
-        const { CloudFrontClient } = await import('../../src/aws/cloudfront')
-        const cloudfront = new CloudFrontClient()
-        await cloudfront.listDistributions()
-        cli.success('CloudFront list access is enabled')
-        cloudfrontListOk = true
-      }
-      catch (error: any) {
-        cli.warn(`CloudFront list check failed: ${error.message}`)
-      }
-
-      // Check CloudFront create access (via CloudFormation - the common issue point)
-      if (cloudfrontListOk) {
-        cli.step('Checking CloudFront create access...')
-        try {
-          // Try to validate a CloudFormation template with CloudFront resource
-          const cfn = new CloudFormationClient('us-east-1')
-          const testTemplate = JSON.stringify({
-            AWSTemplateFormatVersion: '2010-09-09',
-            Description: 'Test CloudFront access',
-            Resources: {
-              TestOAC: {
-                Type: 'AWS::CloudFront::OriginAccessControl',
-                Properties: {
-                  OriginAccessControlConfig: {
-                    Name: 'test-oac-validation',
-                    OriginAccessControlOriginType: 's3',
-                    SigningBehavior: 'always',
-                    SigningProtocol: 'sigv4',
-                  },
-                },
-              },
-            },
-          })
-          await cfn.validateTemplate(testTemplate)
-          cli.success('CloudFront create access appears enabled')
-        }
-        catch (error: any) {
-          if (error.message?.includes('403') || error.message?.includes('AccessDenied') || error.message?.includes('must be verified')) {
-            cli.error('CloudFront create access denied - account verification required')
-            cli.info('')
-            cli.info('Your AWS account needs to be verified for CloudFront.')
-            cli.info('This is required before you can create CloudFront distributions.')
-            cli.info('')
-            cli.info('To verify your account:')
-            cli.info('  1. Go to: https://console.aws.amazon.com/support/home#/')
-            cli.info('  2. Create a support case')
-            cli.info('  3. Select: Service limit increase > CloudFront')
-            cli.info('  4. Request: "Please verify my account for CloudFront access"')
-            cli.info('')
-            cli.info('Verification usually takes 1-2 business days.')
-          }
-          else {
-            // Template validation might fail for other reasons, that's ok
-            cli.success('CloudFront create access appears enabled (validation passed)')
-          }
-        }
-      }
-
-      // Check S3 access
-      cli.step('Checking S3 access...')
-      try {
-        const { S3Client } = await import('../../src/aws/s3')
-        const s3 = new S3Client('us-east-1')
-        await s3.listBuckets()
-        cli.success('S3 access is enabled')
-      }
-      catch (error: any) {
-        cli.warn(`S3 check failed: ${error.message}`)
-      }
-
-      // Check ACM access
-      cli.step('Checking ACM (SSL certificates) access...')
-      try {
-        const acm = new ACMClient('us-east-1')
-        await acm.listCertificates()
-        cli.success('ACM access is enabled')
-      }
-      catch (error: any) {
-        cli.warn(`ACM check failed: ${error.message}`)
-      }
-
-      // Check for cloud.config.ts
-      cli.step('Checking configuration...')
-      if (existsSync('cloud.config.ts')) {
-        cli.success('cloud.config.ts found')
-      }
-      else {
-        cli.warn('cloud.config.ts not found')
-        cli.info('Run: cloud init')
-      }
-    })
-
-  app
-    .command('regions', 'List available AWS regions')
-    .action(async () => {
-      cli.header('AWS Regions')
-
-      const spinner = new cli.Spinner('Fetching regions...')
-      spinner.start()
-
-      const regions = await cli.getAwsRegions()
-      spinner.stop()
-
-      regions.forEach((region) => {
-        console.log(`  ${region}`)
-      })
-    })
-
-  app
-    .command('version', 'Show the version of the CLI')
-    .alias('v')
-    .action(() => {
-      console.log(`ts-cloud v${version}`)
-    })
-}