@stacksjs/buddy 0.58.48 → 0.58.49

package/src/commands/cloud.ts

@@ -0,0 +1,305 @@
+import process from 'node:process'
+import { intro, italic, log, outro, prompts, runCommand, runCommandSync, underline } from '@stacksjs/cli'
+import { addJumpBox, deleteCdkRemnants, deleteIamUsers, deleteJumpBox, deleteLogGroups, deleteParameterStore, deleteStacksBuckets, deleteStacksFunctions, getJumpBoxInstanceId } from '@stacksjs/cloud'
+import { path as p } from '@stacksjs/path'
+import type { CLI, CloudCliOptions } from '@stacksjs/types'
+import { ExitCode } from '@stacksjs/types'
+import { loop } from '@stacksjs/utils'
+
+export function cloud(buddy: CLI) {
+  const descriptions = {
+    cloud: 'Interact with the Stacks Cloud',
+    ssh: 'SSH into the Stacks Cloud',
+    add: 'Add a resource to the Stacks Cloud',
+    remove: 'Removes the Stacks Cloud. In case it fails, try again',
+    optimizeCost: 'Removes certain resources that may be re-applied at a later time',
+    cleanUp: 'Removes all resources that were retained during the cloud deletion',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('cloud', descriptions.cloud)
+    .option('--ssh', descriptions.ssh, { default: false })
+    .option('--connect', descriptions.ssh, { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: CloudCliOptions) => {
+      if (options.ssh || options.connect) {
+        const startTime = performance.now()
+        const jumpBoxId = await getJumpBoxInstanceId()
+        const result = await runCommand(`aws ssm start-session --target ${jumpBoxId}`, {
+          ...options,
+          cwd: p.projectPath(),
+          stdin: 'pipe',
+        })
+
+        if (result.isErr()) {
+          await outro('While running the cloud command, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+
+        await outro('Exited', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+
+      log.info('Not implemented yet. Please use the --ssh (or --connect) flag to connect to the Stacks Cloud.')
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('cloud:add', descriptions.add)
+    .option('--jump-box', 'Remove the jump-box', { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: CloudCliOptions) => {
+      const startTime = await intro('buddy cloud:add')
+
+      if (options.jumpBox) {
+        const { confirm } = await prompts({
+          name: 'confirm',
+          type: 'confirm',
+          message: 'Would you like to add a jump-box to your cloud?',
+        })
+
+        if (!confirm) {
+          await outro('Exited', { startTime, useSeconds: true })
+          process.exit(ExitCode.Success)
+        }
+
+        log.info('The jump-box is getting added to your cloud resources...')
+        log.info('This takes a few moments, please be patient.')
+        // sleep for 2 seconds to get the user to read the message
+        await new Promise(resolve => setTimeout(resolve, 2000))
+
+        const result = await addJumpBox()
+
+        if (result.isErr()) {
+          await outro('While running the cloud:add command, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+
+        log.info(italic('View the jump-box in the AWS console:'))
+        log.info(underline('https://us-east-1.console.aws.amazon.com/ec2/home?region=us-east-1#Instances:instanceState=running'))
+        log.info(italic('Once it finished initializing, you may SSH into it:'))
+        log.info(underline(('buddy cloud --ssh')))
+
+        await outro('Your jump-box was added.', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+
+      log.info('This functionality is not yet implemented.')
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('cloud:remove', descriptions.remove)
+    .alias('cloud:destroy')
+    .alias('cloud:rm')
+    .alias('undeploy')
+    .option('--jump-box', 'Remove the jump-box', { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: CloudCliOptions) => {
+      const startTime = await intro('buddy cloud:remove')
+
+      if (options.jumpBox) {
+        const { confirm } = await prompts({
+          name: 'confirm',
+          type: 'confirm',
+          message: 'Would you like to remove your jump-box for now?',
+        })
+
+        if (!confirm) {
+          await outro('Exited', { startTime, useSeconds: true })
+          process.exit(ExitCode.Success)
+        }
+
+        const result = await deleteJumpBox()
+
+        if (result.isErr()) {
+          await outro('While removing your jump-box, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+
+        await outro('Your jump-box was removed.', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+
+      // eslint-disable-next-line no-console
+      console.log(`   ${italic('ℹ️   Removing your cloud resources takes a while to complete.')}`)
+      // eslint-disable-next-line no-console
+      console.log(`   ${italic('Please note, your backups will not yet be deleted. Though,')}`)
+      // eslint-disable-next-line no-console
+      console.log(`   ${italic('Backups are scheduled to delete themselves in 30 days.')}`)
+
+      // sleep for 2 seconds to get the user to read the message
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      const result = await runCommand(`bunx cdk destroy`, {
+        ...options,
+        cwd: p.cloudPath(),
+        stdin: 'inherit',
+      })
+
+      if (result.isErr()) {
+        await outro('While running the cloud:remove ("undeploy") command, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await runCommand('buddy cloud:cleanup', {
+        ...options,
+        cwd: p.projectPath(),
+        stdin: 'inherit',
+      })
+
+      // TODO: this should not be necessary but for some reason some buckets with versions aren't properly getting deleted
+      // and because of that, we simply run the command several times, because eventually the versions will be deleted
+      // and consequently the buckets will be deleted
+      // the reason we are using 7 as the number of times to run the command is because it's the most amount of times I have had to run it to get it to delete everything
+      try {
+        log.info('Finalizing the removal of your cloud resources.')
+        log.info('This will take a few moments...')
+        loop(7, () => {
+          runCommandSync('buddy cloud:cleanup', {
+            ...options,
+            cwd: p.projectPath(),
+            stdout: 'ignore',
+          })
+        })
+
+        await outro('Your cloud has been removed', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+      catch (error) {
+        await outro('While cleaning up the cloud, there was an issue', { startTime, useSeconds: true }, error as Error)
+        process.exit(ExitCode.FatalError)
+      }
+    })
+
+  buddy
+    .command('cloud:optimize-cost', descriptions.optimizeCost)
+    .option('--jump-box', 'Remove the jump-box', { default: true })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: CloudCliOptions) => {
+      const startTime = await intro('buddy cloud:remove')
+
+      if (options.jumpBox) {
+        const { confirm } = await prompts({
+          name: 'confirm',
+          type: 'confirm',
+          message: 'Would you like to remove your jump-box to optimize your costs?',
+        })
+
+        if (!confirm) {
+          await outro('Exited', { startTime, useSeconds: true })
+          process.exit(ExitCode.Success)
+        }
+
+        await deleteJumpBox()
+
+        await outro('Your jump-box was removed & cost optimizations are applied.', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+
+      await outro('No cost optimization was applied', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('cloud:cleanup', descriptions.cleanUp)
+    .alias('cloud:clean-up')
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async () => {
+      const startTime = await intro('buddy cloud:cleanup')
+
+      log.info(`Cleaning up your cloud resources will take a while to complete. Please be patient.`)
+
+      // sleep for 2 seconds to get the user to read the message
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      log.info('Removing any jump-boxes...')
+      const result = await deleteJumpBox()
+
+      if (result.isErr()) {
+        if (result.error !== 'Jump-box not found') {
+          await outro('While removing your jump-box, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+      }
+
+      log.info('Removing any retained S3 buckets...')
+      const result2 = await deleteStacksBuckets()
+
+      if (result2.isErr()) {
+        await outro('While deleting the retained S3 buckets, there was an issue', { startTime, useSeconds: true }, result2.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      log.info('Removing any retained Lambda functions...')
+      const result3 = await deleteStacksFunctions()
+
+      if (result3.isErr()) {
+        if (result3.error !== 'No stacks functions found')
+          await outro('While deleting the Origin Request Lambda function, there was an issue', { startTime, useSeconds: true }, result3.error)
+
+        process.exit(ExitCode.FatalError)
+      }
+
+      log.info(result3.value)
+
+      log.info('Removing any remaining Stacks logs...')
+      const result4 = await deleteLogGroups()
+      // TODO: investigate other regions for edge (cloudfront) logs
+
+      if (result4.isErr()) {
+        await outro('While deleting the Stacks log groups, there was an issue', { startTime, useSeconds: true }, result4.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      // log.info('Removing any Backup Vaults...')
+      // const result5 = await deleteBackupVaults()
+
+      // if (result5.isErr()) {
+      //   await outro('While deleting the Backup Vaults, there was an issue', { startTime, useSeconds: true }, result5.error)
+      //   process.exit(ExitCode.FatalError)
+      // }
+
+      log.info('Removing any stored parameters...')
+      const result7 = await deleteParameterStore()
+
+      if (result7.isErr()) {
+        await outro('While deleting the Stacks log groups, there was an issue', { startTime, useSeconds: true }, result7.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      log.info('Removing any CDK remnants...')
+      const result6 = await deleteCdkRemnants()
+
+      if (result6.isErr()) {
+        await outro('While deleting the Stacks log groups, there was an issue', { startTime, useSeconds: true }, result6.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      log.info('Removing any IAM users...')
+      const result8 = await deleteIamUsers()
+
+      if (result8.isErr()) {
+        await outro('While deleting the Stacks log groups, there was an issue', { startTime, useSeconds: true }, result8.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      // TODO: needs to delete all Backup Vaults
+      // TODO: needs to delete all KMS keys
+
+      await outro('AWS resources have been removed', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('cloud:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/commit.ts

@@ -0,0 +1,24 @@
+import process from 'node:process'
+import type { CLI, FreshOptions } from '@stacksjs/types'
+import { runCommit } from '@stacksjs/actions'
+
+export function commit(buddy: CLI) {
+  const descriptions = {
+    commit: 'Commit your stashed changes',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('commit', descriptions.commit)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: FreshOptions) => {
+      await runCommit(options)
+    })
+
+  buddy.on('commit:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}

package/src/commands/configure.ts

@@ -0,0 +1,68 @@
+import process from 'node:process'
+import type { CLI, ConfigureOptions } from '@stacksjs/types'
+import { log, outro, runCommand } from '@stacksjs/cli'
+import { path as p } from '@stacksjs/path'
+import { config } from '@stacksjs/config'
+import { ExitCode } from '@stacksjs/types'
+
+export function configure(buddy: CLI) {
+  const descriptions = {
+    configure: 'Configure options',
+    aws: 'Configure the AWS connection',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('configure', descriptions.configure)
+    .option('--aws', descriptions.aws, { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options?: ConfigureOptions) => {
+      if (options?.aws) {
+        const startTime = performance.now()
+        const result = await runCommand('aws configure', {
+          ...options,
+          cwd: p.projectPath(),
+          stdin: 'inherit',
+        })
+
+        if (result.isErr()) {
+          await outro('While running the configure command, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+
+        await outro('Exited', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+
+      log.info('Not implemented yet. Please use the --aws flag to configure AWS.')
+      process.exit(ExitCode.Success)
+    })
+
+  buddy
+    .command('configure:aws', descriptions.aws)
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options?: ConfigureOptions) => {
+      const startTime = performance.now()
+      const result = await runCommand(`aws configure --profile ${config.app.url}`, {
+        ...options,
+        cwd: p.cloudPath(),
+        stdin: 'inherit',
+      })
+
+      if (result.isErr()) {
+        await outro('While running the cloud command, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Exited', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('configure:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(ExitCode.FatalError)
+  })
+}

package/src/commands/create.ts

@@ -0,0 +1,131 @@
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, CreateOptions } from '@stacksjs/types'
+import { bold, cyan, dim, intro, log, runCommand } from '@stacksjs/cli'
+import { useOnline } from '@stacksjs/utils'
+import { isFolder } from '@stacksjs/storage'
+import { resolve } from '@stacksjs/path'
+import { Action } from '@stacksjs/enums'
+import { runAction } from '@stacksjs/actions'
+
+export function create(buddy: CLI) {
+  const descriptions = {
+    command: 'Create a new Stacks project',
+    ui: 'Are you building a UI?',
+    components: 'Are you building UI components?',
+    webComponents: 'Automagically built optimized custom elements/web components?',
+    vue: 'Automagically built a Vue component library?',
+    views: 'How about views?',
+    functions: 'Are you developing functions/composables?',
+    api: 'Are you building an API?',
+    database: 'Do you need a database?',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('new <name>', descriptions.command)
+    .option('-u, --ui', descriptions.ui, { default: true }) // if no, disregard remainder of questions wrt UI
+    .option('-c, --components', descriptions.components, { default: true }) // if no, -v and -w would be false
+    .option('-w, --web-components', descriptions.webComponents, { default: true })
+    .option('-v, --vue', descriptions.vue, { default: true })
+    .option('-p, --views', descriptions.views, { default: true }) // i.e. `buddy dev`
+    .option('-f, --functions', descriptions.functions, { default: true }) // if no, API would be false
+    .option('-a, --api', descriptions.api, { default: true }) // APIs need an HTTP server & assumes functions is true
+    .option('-d, --database', descriptions.database, { default: true })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    // .option('--auth', 'Scaffold an authentication?', { default: true })
+    .action(async (options: CreateOptions) => {
+      const startTime = await intro('stacks new')
+      const name = options.name
+      const path = resolve(process.cwd(), name)
+
+      isFolderCheck(path)
+      onlineCheck()
+      const result = await download(name, path, options)
+
+      if (result?.isErr()) {
+        log.error(result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await ensureEnv(path, options)
+      await install(path, options)
+
+      if (startTime) {
+        const time = performance.now() - startTime
+        log.success(dim(`[${time.toFixed(2)}ms] Completed`))
+      }
+
+      log.info(bold('Welcome to the Stacks Framework! ⚛️'))
+      log.info('To learn more, visit https://stacksjs.org')
+
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('new:*', () => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}
+
+function isFolderCheck(path: string) {
+  if (isFolder(path)) {
+    log.error(`Path ${path} already exists`)
+    process.exit(ExitCode.FatalError)
+  }
+}
+
+function onlineCheck() {
+  const online = useOnline()
+  if (!online) {
+    log.info('It appears you are disconnected from the internet.')
+    log.info('The Stacks setup requires a brief internet connection for setup.')
+    log.info('For instance, it installs your dependencies from.')
+    process.exit(ExitCode.FatalError)
+  }
+}
+
+async function download(name: string, path: string, options: CreateOptions) {
+  log.info('Setting up your stack.')
+  const result = await runCommand(`bunx giget stacks ${name}`, options)
+  log.success(`Successfully scaffolded your project at ${cyan(path)}`)
+
+  return result
+}
+
+async function ensureEnv(path: string, options: CreateOptions) {
+  log.info('Ensuring your environment is ready...')
+  await runCommand('pkgx --update ', { ...options, cwd: path })
+  log.success('Environment is ready')
+}
+
+async function install(path: string, options: CreateOptions) {
+  log.info('Installing & setting up Stacks')
+  let result = await runCommand('bun install', { ...options, cwd: path })
+
+  if (result?.isErr()) {
+    log.error(result.error)
+    process.exit()
+  }
+
+  result = await runCommand('cp .env.example .env', { ...options, cwd: path })
+
+  if (result?.isErr()) {
+    log.error(result.error)
+    process.exit(ExitCode.FatalError)
+  }
+
+  await runAction(Action.KeyGenerate, { ...options, cwd: path })
+
+  // TODO: we should ask quite a few questions here, similar how we do in `buddy new my-project`, so we can generate a custom pkgx.yaml file
+
+  result = await runCommand('git init', { ...options, cwd: path }) // do we need this? or does giget do this already?
+  if (result.isErr()) {
+    log.error(result.error)
+    process.exit(ExitCode.FatalError)
+  }
+
+  log.success('Installed & set-up 🚀')
+}

package/src/commands/deploy.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+import process from 'node:process'
+import { ExitCode } from '@stacksjs/types'
+import type { CLI, DeployOptions } from '@stacksjs/types'
+import { runAction } from '@stacksjs/actions'
+import { intro, italic, log, outro } from '@stacksjs/cli'
+import { Action } from '@stacksjs/enums'
+import { app } from '@stacksjs/config'
+import { addDomain, hasUserDomainBeenAddedToCloud } from '@stacksjs/dns'
+
+export function deploy(buddy: CLI) {
+  const descriptions = {
+    deploy: 'Reinstalls your npm dependencies',
+    project: 'Target a specific project',
+    verbose: 'Enable verbose output',
+  }
+
+  buddy
+    .command('deploy', descriptions.deploy)
+    .option('--domain', 'Specify a domain to deploy to', { default: undefined })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: DeployOptions) => {
+      const startTime = await intro('buddy deploy')
+      const domain = options.domain || app.url
+
+      if (!domain) {
+        log.info('We could not identify a domain to deploy to.')
+        log.info('Please set your .env or ./config/app.ts properly.')
+        console.log('')
+        log.info('Alternatively, specify a domain to deploy via the `--domain` flag.')
+        console.log('')
+        log.info('   ➡️  Example: `buddy deploy --domain example.com`')
+        console.log('')
+        process.exit(ExitCode.FatalError)
+      }
+
+      // TODO: we can improve this check at some point, otherwise domains that legitimately include the word localhost will fail
+      if (domain.includes('localhost')) {
+        log.info('You are deploying to a local environment.')
+        log.info('Please set your .env or ./config/app.ts properly.')
+        console.log('')
+        log.info('Alternatively, specify a domain to deploy via the `--domain` flag.')
+        console.log('')
+        log.info('   ➡️  Example: `buddy deploy --domain example.com`')
+        console.log('')
+        process.exit(ExitCode.FatalError)
+      }
+
+      if (await hasUserDomainBeenAddedToCloud(domain)) {
+        log.success('Your domain is properly configured.')
+        log.info('Your cloud is deploying...')
+
+        console.log(`${italic('This may take a while...')}`)
+        await new Promise(resolve => setTimeout(resolve, 2000))
+        options.domain = domain
+
+        // now that we know the domain has been added to the users (AWS) cloud, we can deploy
+        const result = await runAction(Action.Deploy, options)
+
+        if (result.isErr()) {
+          await outro('While running the `buddy deploy`, there was an issue', { startTime, useSeconds: true }, result.error)
+          process.exit(ExitCode.FatalError)
+        }
+
+        await outro('Deployment succeeded.', { startTime, useSeconds: true })
+
+        process.exit(ExitCode.Success)
+      }
+
+      // if the domain hasn't been added to the user's (AWS) cloud, we will add it for them
+      // and then exit the process with prompts for the user to update their nameservers
+      console.log('')
+      log.info(`  👋  It appears to be your first ${italic(domain)} deployment.`)
+      console.log('')
+      log.info(italic('Let’s ensure it is all connected properly.'))
+      log.info(italic('One moment...'))
+      console.log('')
+
+      options.domain = domain
+      const result = await addDomain({
+        ...options,
+        deploy: true,
+        startTime,
+      })
+
+      if (result.isErr()) {
+        await outro('While running the `buddy deploy`, there was an issue', { startTime, useSeconds: true }, result.error)
+        process.exit(ExitCode.FatalError)
+      }
+
+      await outro('Added your domain.', { startTime, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
+  buddy.on('deploy:*', () => {
+    log.error('Invalid command: %s\nSee --help for a list of available commands.', buddy.args.join(' '))
+    process.exit(1)
+  })
+}