@stacksjs/ts-cloud 0.1.3 → 0.1.5

package/bin/commands/events.ts

@@ -1,424 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import * as cli from '../../src/utils/cli'
-import { EventBridgeClient } from '../../src/aws/eventbridge'
-import { loadValidatedConfig } from './shared'
-
-export function registerEventsCommands(app: CLI): void {
-  app
-    .command('events:list', 'List all EventBridge rules')
-    .option('--region <region>', 'AWS region')
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .action(async (options: { region?: string; bus: string }) => {
-      cli.header('EventBridge Rules')
-
-      try {
-        const config = await loadValidatedConfig()
-        const region = options.region || config.project.region || 'us-east-1'
-        const eventbridge = new EventBridgeClient(region)
-
-        const spinner = new cli.Spinner('Fetching rules...')
-        spinner.start()
-
-        const result = await eventbridge.listRules({ EventBusName: options.bus })
-        const rules = result.Rules || []
-
-        spinner.succeed(`Found ${rules.length} rule(s)`)
-
-        if (rules.length === 0) {
-          cli.info('No EventBridge rules found')
-          cli.info('Use `cloud events:create` to create a new rule')
-          return
-        }
-
-        cli.table(
-          ['Name', 'State', 'Schedule/Pattern', 'Description'],
-          rules.map(rule => [
-            rule.Name || 'N/A',
-            rule.State || 'N/A',
-            rule.ScheduleExpression || (rule.EventPattern ? 'Event Pattern' : 'N/A'),
-            (rule.Description || '').substring(0, 40),
-          ]),
-        )
-      }
-      catch (error: any) {
-        cli.error(`Failed to list rules: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:create <name>', 'Create a new EventBridge rule')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .option('--schedule <expression>', 'Schedule expression (rate or cron)')
-    .option('--pattern <json>', 'Event pattern JSON')
-    .option('--pattern-file <path>', 'Event pattern from JSON file')
-    .option('--description <text>', 'Rule description')
-    .option('--disabled', 'Create in disabled state')
-    .action(async (name: string, options: {
-      region: string
-      bus: string
-      schedule?: string
-      pattern?: string
-      patternFile?: string
-      description?: string
-      disabled?: boolean
-    }) => {
-      cli.header('Create EventBridge Rule')
-
-      try {
-        if (!options.schedule && !options.pattern && !options.patternFile) {
-          cli.error('Either --schedule or --pattern/--pattern-file is required')
-          cli.info('\nExamples:')
-          cli.info('  Schedule: --schedule "rate(5 minutes)"')
-          cli.info('  Pattern:  --pattern \'{"source": ["aws.ec2"]}\'')
-          return
-        }
-
-        const eventbridge = new EventBridgeClient(options.region)
-
-        let eventPattern: string | undefined
-
-        if (options.patternFile) {
-          const file = Bun.file(options.patternFile)
-          eventPattern = await file.text()
-        }
-        else if (options.pattern) {
-          eventPattern = options.pattern
-        }
-
-        cli.info(`Name: ${name}`)
-        cli.info(`Event Bus: ${options.bus}`)
-        if (options.schedule) {
-          cli.info(`Schedule: ${options.schedule}`)
-        }
-        if (eventPattern) {
-          cli.info(`Event Pattern: ${eventPattern}`)
-        }
-        cli.info(`State: ${options.disabled ? 'DISABLED' : 'ENABLED'}`)
-
-        const confirmed = await cli.confirm('\nCreate this rule?', true)
-        if (!confirmed) {
-          cli.info('Operation cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Creating rule...')
-        spinner.start()
-
-        const result = await eventbridge.putRule({
-          Name: name,
-          EventBusName: options.bus,
-          ScheduleExpression: options.schedule,
-          EventPattern: eventPattern,
-          Description: options.description,
-          State: options.disabled ? 'DISABLED' : 'ENABLED',
-        })
-
-        spinner.succeed('Rule created')
-
-        cli.success(`\nRule ARN: ${result.RuleArn}`)
-        cli.info('\nNote: Add targets to the rule with `cloud events:target`')
-      }
-      catch (error: any) {
-        cli.error(`Failed to create rule: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:delete <name>', 'Delete an EventBridge rule')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .option('--force', 'Remove all targets and delete rule')
-    .action(async (name: string, options: { region: string; bus: string; force?: boolean }) => {
-      cli.header('Delete EventBridge Rule')
-
-      try {
-        const eventbridge = new EventBridgeClient(options.region)
-
-        cli.warn(`This will delete rule: ${name}`)
-
-        const confirmed = await cli.confirm('\nDelete this rule?', false)
-        if (!confirmed) {
-          cli.info('Operation cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Checking targets...')
-        spinner.start()
-
-        // Check for targets
-        const targets = await eventbridge.listTargetsByRule({
-          Rule: name,
-          EventBusName: options.bus,
-        })
-
-        if (targets.Targets && targets.Targets.length > 0) {
-          if (!options.force) {
-            spinner.fail('Rule has targets')
-            cli.info(`\nThe rule has ${targets.Targets.length} target(s).`)
-            cli.info('Use --force to remove targets and delete the rule.')
-            return
-          }
-
-          spinner.text = 'Removing targets...'
-
-          await eventbridge.removeTargets({
-            Rule: name,
-            EventBusName: options.bus,
-            Ids: targets.Targets.map(t => t.Id!),
-          })
-        }
-
-        spinner.text = 'Deleting rule...'
-
-        await eventbridge.deleteRule({
-          Name: name,
-          EventBusName: options.bus,
-        })
-
-        spinner.succeed('Rule deleted')
-      }
-      catch (error: any) {
-        cli.error(`Failed to delete rule: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:describe <name>', 'Show EventBridge rule details')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .action(async (name: string, options: { region: string; bus: string }) => {
-      cli.header(`Rule: ${name}`)
-
-      try {
-        const eventbridge = new EventBridgeClient(options.region)
-
-        const spinner = new cli.Spinner('Fetching rule...')
-        spinner.start()
-
-        const rule = await eventbridge.describeRule({
-          Name: name,
-          EventBusName: options.bus,
-        })
-
-        if (!rule) {
-          spinner.fail('Rule not found')
-          return
-        }
-
-        // Get targets
-        const targets = await eventbridge.listTargetsByRule({
-          Rule: name,
-          EventBusName: options.bus,
-        })
-
-        spinner.succeed('Rule loaded')
-
-        cli.info('\nRule Information:')
-        cli.info(`  Name: ${rule.Name}`)
-        cli.info(`  ARN: ${rule.Arn}`)
-        cli.info(`  State: ${rule.State}`)
-        cli.info(`  Event Bus: ${rule.EventBusName}`)
-
-        if (rule.Description) {
-          cli.info(`  Description: ${rule.Description}`)
-        }
-
-        if (rule.ScheduleExpression) {
-          cli.info(`\nSchedule Expression: ${rule.ScheduleExpression}`)
-        }
-
-        if (rule.EventPattern) {
-          cli.info('\nEvent Pattern:')
-          console.log(JSON.stringify(JSON.parse(rule.EventPattern), null, 2))
-        }
-
-        if (targets.Targets && targets.Targets.length > 0) {
-          cli.info(`\nTargets (${targets.Targets.length}):`)
-          for (const target of targets.Targets) {
-            cli.info(`  - ${target.Id}: ${target.Arn}`)
-            if (target.Input) {
-              cli.info(`    Input: ${target.Input}`)
-            }
-          }
-        }
-        else {
-          cli.info('\nNo targets configured.')
-        }
-      }
-      catch (error: any) {
-        cli.error(`Failed to get rule: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:target <ruleName>', 'Add a target to an EventBridge rule')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .option('--id <id>', 'Target ID')
-    .option('--arn <arn>', 'Target ARN (Lambda, SQS, SNS, etc.)')
-    .option('--role <arn>', 'IAM role ARN (for some targets)')
-    .option('--input <json>', 'Constant JSON input')
-    .option('--input-path <path>', 'JSONPath expression for input')
-    .action(async (ruleName: string, options: {
-      region: string
-      bus: string
-      id?: string
-      arn?: string
-      role?: string
-      input?: string
-      inputPath?: string
-    }) => {
-      cli.header('Add EventBridge Target')
-
-      try {
-        if (!options.arn) {
-          cli.error('--arn is required')
-          return
-        }
-
-        const eventbridge = new EventBridgeClient(options.region)
-
-        const targetId = options.id || `target-${Date.now()}`
-
-        cli.info(`Rule: ${ruleName}`)
-        cli.info(`Target ID: ${targetId}`)
-        cli.info(`Target ARN: ${options.arn}`)
-
-        const confirmed = await cli.confirm('\nAdd this target?', true)
-        if (!confirmed) {
-          cli.info('Operation cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Adding target...')
-        spinner.start()
-
-        const target: any = {
-          Id: targetId,
-          Arn: options.arn,
-        }
-
-        if (options.role) {
-          target.RoleArn = options.role
-        }
-
-        if (options.input) {
-          target.Input = options.input
-        }
-
-        if (options.inputPath) {
-          target.InputPath = options.inputPath
-        }
-
-        await eventbridge.putTargets({
-          Rule: ruleName,
-          EventBusName: options.bus,
-          Targets: [target],
-        })
-
-        spinner.succeed('Target added')
-
-        cli.success(`\nTarget ${targetId} added to rule ${ruleName}`)
-      }
-      catch (error: any) {
-        cli.error(`Failed to add target: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:buses', 'List event buses')
-    .option('--region <region>', 'AWS region')
-    .action(async (options: { region?: string }) => {
-      cli.header('Event Buses')
-
-      try {
-        const config = await loadValidatedConfig()
-        const region = options.region || config.project.region || 'us-east-1'
-        const eventbridge = new EventBridgeClient(region)
-
-        const spinner = new cli.Spinner('Fetching event buses...')
-        spinner.start()
-
-        const result = await eventbridge.listEventBuses()
-        const buses = result.EventBuses || []
-
-        spinner.succeed(`Found ${buses.length} event bus(es)`)
-
-        if (buses.length === 0) {
-          cli.info('No event buses found')
-          return
-        }
-
-        cli.table(
-          ['Name', 'ARN', 'Policy'],
-          buses.map(bus => [
-            bus.Name || 'N/A',
-            bus.Arn || 'N/A',
-            bus.Policy ? 'Custom' : 'Default',
-          ]),
-        )
-      }
-      catch (error: any) {
-        cli.error(`Failed to list event buses: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:enable <name>', 'Enable an EventBridge rule')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .action(async (name: string, options: { region: string; bus: string }) => {
-      cli.header('Enable EventBridge Rule')
-
-      try {
-        const eventbridge = new EventBridgeClient(options.region)
-
-        const spinner = new cli.Spinner('Enabling rule...')
-        spinner.start()
-
-        await eventbridge.enableRule({
-          Name: name,
-          EventBusName: options.bus,
-        })
-
-        spinner.succeed('Rule enabled')
-      }
-      catch (error: any) {
-        cli.error(`Failed to enable rule: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  app
-    .command('events:disable <name>', 'Disable an EventBridge rule')
-    .option('--region <region>', 'AWS region', { default: 'us-east-1' })
-    .option('--bus <name>', 'Event bus name', { default: 'default' })
-    .action(async (name: string, options: { region: string; bus: string }) => {
-      cli.header('Disable EventBridge Rule')
-
-      try {
-        const eventbridge = new EventBridgeClient(options.region)
-
-        const spinner = new cli.Spinner('Disabling rule...')
-        spinner.start()
-
-        await eventbridge.disableRule({
-          Name: name,
-          EventBusName: options.bus,
-        })
-
-        spinner.succeed('Rule disabled')
-      }
-      catch (error: any) {
-        cli.error(`Failed to disable rule: ${error.message}`)
-        process.exit(1)
-      }
-    })
-}

package/bin/commands/firewall.ts

@@ -1,145 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import * as cli from '../../src/utils/cli'
-
-export function registerFirewallCommands(app: CLI): void {
-  app
-    .command('firewall:rules', 'List WAF rules')
-    .option('--env <environment>', 'Environment (production, staging, development)')
-    .action(async (options?: { env?: string }) => {
-      cli.header('WAF Rules')
-
-      const environment = options?.env || 'production'
-
-      cli.info(`Environment: ${environment}\n`)
-
-      cli.table(
-        ['Rule', 'Priority', 'Action', 'Requests Blocked'],
-        [
-          ['Rate Limit', '1', 'Block', '1,234'],
-          ['Geo Block (CN, RU)', '2', 'Block', '567'],
-          ['SQL Injection', '3', 'Block', '89'],
-          ['XSS Prevention', '4', 'Block', '23'],
-        ],
-      )
-    })
-
-  app
-    .command('firewall:block <ip>', 'Block an IP address')
-    .option('--reason <reason>', 'Reason for blocking')
-    .action(async (ip: string, options?: { reason?: string }) => {
-      cli.header(`Blocking IP Address`)
-
-      const reason = options?.reason || 'Manual block'
-
-      cli.info(`IP: ${ip}`)
-      cli.info(`Reason: ${reason}`)
-
-      const confirm = await cli.confirm('\nBlock this IP address?', true)
-      if (!confirm) {
-        cli.info('Operation cancelled')
-        return
-      }
-
-      const spinner = new cli.Spinner('Adding IP to WAF block list...')
-      spinner.start()
-
-      // TODO: Add IP to WAF IP set
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      spinner.succeed(`IP ${ip} blocked successfully`)
-
-      cli.success('\nIP blocked!')
-      cli.info('The IP address will be blocked within 60 seconds')
-    })
-
-  app
-    .command('firewall:unblock <ip>', 'Unblock an IP address')
-    .action(async (ip: string) => {
-      cli.header(`Unblocking IP Address`)
-
-      cli.info(`IP: ${ip}`)
-
-      const confirm = await cli.confirm('\nUnblock this IP address?', true)
-      if (!confirm) {
-        cli.info('Operation cancelled')
-        return
-      }
-
-      const spinner = new cli.Spinner('Removing IP from WAF block list...')
-      spinner.start()
-
-      // TODO: Remove IP from WAF IP set
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      spinner.succeed(`IP ${ip} unblocked successfully`)
-
-      cli.success('\nIP unblocked!')
-    })
-
-  app
-    .command('firewall:countries', 'Manage geo-blocking')
-    .option('--add <countries>', 'Comma-separated country codes to block (e.g., CN,RU)')
-    .option('--remove <countries>', 'Comma-separated country codes to unblock')
-    .option('--list', 'List currently blocked countries')
-    .action(async (options?: { add?: string, remove?: string, list?: boolean }) => {
-      cli.header('Geo-Blocking Management')
-
-      if (options?.list) {
-        cli.info('Currently blocked countries:\n')
-        cli.table(
-          ['Country Code', 'Country Name', 'Blocked Since'],
-          [
-            ['CN', 'China', '2024-01-15'],
-            ['RU', 'Russia', '2024-01-15'],
-            ['KP', 'North Korea', '2024-01-10'],
-          ],
-        )
-      }
-      else if (options?.add) {
-        const countries = options.add.split(',').map(c => c.trim().toUpperCase())
-
-        cli.info(`Countries to block: ${countries.join(', ')}`)
-
-        const confirm = await cli.confirm('\nBlock these countries?', true)
-        if (!confirm) {
-          cli.info('Operation cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Updating geo-blocking rules...')
-        spinner.start()
-
-        // TODO: Update WAF geo match statement
-        await new Promise(resolve => setTimeout(resolve, 2000))
-
-        spinner.succeed('Geo-blocking rules updated')
-
-        cli.success('\nCountries blocked!')
-      }
-      else if (options?.remove) {
-        const countries = options.remove.split(',').map(c => c.trim().toUpperCase())
-
-        cli.info(`Countries to unblock: ${countries.join(', ')}`)
-
-        const confirm = await cli.confirm('\nUnblock these countries?', true)
-        if (!confirm) {
-          cli.info('Operation cancelled')
-          return
-        }
-
-        const spinner = new cli.Spinner('Updating geo-blocking rules...')
-        spinner.start()
-
-        // TODO: Update WAF geo match statement
-        await new Promise(resolve => setTimeout(resolve, 2000))
-
-        spinner.succeed('Geo-blocking rules updated')
-
-        cli.success('\nCountries unblocked!')
-      }
-      else {
-        cli.info('Use --list, --add, or --remove options')
-        cli.info('Example: cloud firewall:countries --add CN,RU')
-      }
-    })
-}

package/bin/commands/function.ts

@@ -1,116 +0,0 @@
-import type { CLI } from '@stacksjs/clapp'
-import * as cli from '../../src/utils/cli'
-
-export function registerFunctionCommands(app: CLI): void {
-  app
-    .command('function:list', 'List all Lambda functions')
-    .action(async () => {
-      cli.header('Listing Functions')
-
-      const functions = [
-        ['api-handler', '128 MB', '30s', '15', 'nodejs20.x'],
-        ['worker', '512 MB', '60s', '3', 'nodejs20.x'],
-      ]
-
-      cli.table(
-        ['Name', 'Memory', 'Timeout', 'Invocations (24h)', 'Runtime'],
-        functions,
-      )
-    })
-
-  app
-    .command('function:logs <name>', 'View function logs')
-    .option('--tail', 'Tail logs in real-time')
-    .option('--filter <pattern>', 'Filter logs by pattern')
-    .action(async (name: string) => {
-      cli.header(`Logs for ${name}`)
-      cli.info('Streaming logs...')
-      // TODO: Implement log streaming
-    })
-
-  app
-    .command('function:invoke <name>', 'Test function invocation')
-    .option('--payload <json>', 'Event payload as JSON')
-    .action(async (name: string, options?: { payload?: string }) => {
-      cli.header(`Invoking ${name}`)
-
-      const spinner = new cli.Spinner('Invoking function...')
-      spinner.start()
-
-      // TODO: Implement invocation
-      await new Promise(resolve => setTimeout(resolve, 1000))
-
-      spinner.succeed('Function invoked successfully')
-    })
-
-  app
-    .command('function:create <name>', 'Create a new Lambda function')
-    .option('--runtime <runtime>', 'Runtime (nodejs20.x, python3.12, etc.)', { default: 'nodejs20.x' })
-    .option('--memory <mb>', 'Memory allocation in MB', { default: '128' })
-    .option('--timeout <seconds>', 'Timeout in seconds', { default: '30' })
-    .option('--handler <handler>', 'Function handler', { default: 'index.handler' })
-    .action(async (name: string, options?: { runtime?: string, memory?: string, timeout?: string, handler?: string }) => {
-      cli.header(`Creating Lambda Function: ${name}`)
-
-      const runtime = options?.runtime || 'nodejs20.x'
-      const memory = options?.memory || '128'
-      const timeout = options?.timeout || '30'
-      const handler = options?.handler || 'index.handler'
-
-      cli.info(`Runtime: ${runtime}`)
-      cli.info(`Memory: ${memory} MB`)
-      cli.info(`Timeout: ${timeout}s`)
-      cli.info(`Handler: ${handler}`)
-
-      const spinner = new cli.Spinner('Creating function...')
-      spinner.start()
-
-      // TODO: Create function directory structure
-      // TODO: Generate basic function code
-      // TODO: Create IAM role for function
-      // TODO: Package and upload to Lambda
-
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      spinner.succeed(`Function ${name} created successfully`)
-
-      cli.success('\nFunction created!')
-      cli.info('\nNext steps:')
-      cli.info(`  - Edit the function code in functions/${name}/index.js`)
-      cli.info(`  - cloud function:deploy ${name} - Deploy the function`)
-      cli.info(`  - cloud function:invoke ${name} - Test the function`)
-    })
-
-  app
-    .command('function:deploy <name>', 'Deploy specific Lambda function')
-    .option('--env <environment>', 'Environment (production, staging, development)')
-    .action(async (name: string, options?: { env?: string }) => {
-      cli.header(`Deploying Function: ${name}`)
-
-      const environment = options?.env || 'production'
-
-      cli.info(`Environment: ${environment}`)
-
-      const spinner = new cli.Spinner('Packaging function...')
-      spinner.start()
-
-      // TODO: Package function code
-      // TODO: Upload to S3
-      // TODO: Update Lambda function code
-      // TODO: Publish new version
-
-      spinner.text = 'Uploading to Lambda...'
-      await new Promise(resolve => setTimeout(resolve, 1500))
-
-      spinner.text = 'Updating function configuration...'
-      await new Promise(resolve => setTimeout(resolve, 1000))
-
-      spinner.succeed(`Function ${name} deployed successfully`)
-
-      cli.success('\nDeployment complete!')
-      cli.info('\nFunction details:')
-      cli.info(`  - ARN: arn:aws:lambda:us-east-1:123456789:function:${name}`)
-      cli.info(`  - Version: $LATEST`)
-      cli.info(`  - Last Modified: ${new Date().toISOString()}`)
-    })
-}