@mono-labs/cli 0.0.5

package/README.md

@@ -0,0 +1,86 @@
+# Haste CLI Tool
+
+A fast and efficient CLI tool for building and deploying projects.
+
+## Installation
+
+### Local Development
+```bash
+# Install dependencies
+yarn install
+
+# Test the CLI locally
+yarn start --help
+```
+
+### Global Installation
+```bash
+# Install globally using yarn
+yarn global add .
+
+# Or link for development
+yarn link
+```
+
+## Usage
+
+### Build Command
+```bash
+# Basic build
+haste build
+
+# Build with specific environment
+haste build --env production
+
+# Build with watch mode
+haste build --watch
+```
+
+### Deploy Command
+```bash
+# Basic deploy
+haste deploy
+
+# Deploy to specific environment
+haste deploy --env staging
+
+# Force deployment
+haste deploy --force
+```
+
+## Available Commands
+
+- `haste build` - Build the project
+- `haste deploy` - Deploy the project
+- `haste --help` - Show help information
+- `haste --version` - Show version information
+
+## Development
+
+### Project Structure
+```
+haste/
+├── bin/
+│   └── haste.js          # Main CLI entry point
+├── lib/
+│   └── commands/
+│       ├── build.js      # Build command implementation
+│       └── deploy.js     # Deploy command implementation
+├── package.json
+└── README.md
+```
+
+### Adding New Commands
+
+1. Create a new file in `lib/commands/`
+2. Export an `execute` function
+3. Add the command to `bin/haste.js`
+
+### Dependencies
+
+- **commander** - Command-line argument parsing
+- **chalk** - Terminal string styling
+
+## License
+
+MIT

package/bin/haste.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../lib/index.js'

package/index.js

@@ -0,0 +1,3 @@
+const haste = require('./lib/index');
+
+module.exports = haste;

package/lib/app.js

@@ -0,0 +1,28 @@
+import { Command } from 'commander'
+
+import { STAGING_URL } from './config.js'
+
+const version = '0.0.1'
+export const program = new Command()
+
+program.name('haste').description('CLI to manage Haste project').version(version)
+const EXPO_PUBLIC_API_URL =
+	(process.env.EXPO_PUBLIC_API_URL && process.env.EXPO_PUBLIC_API_URL.length > 0) || STAGING_URL
+const CLIENT_NAME = process.env.CLIENT_NAME || 'jawdrop'
+
+export const generateEnvValues = (
+	forceProd = false,
+	ngrokUrl = 'localhost:3000',
+	useAtlas = false,
+) => {
+	return {
+		...process.env,
+		EXPO_PUBLIC_API_URL,
+
+		CLIENT_NAME,
+		EXPO_FORCE_PROD: forceProd,
+		EXPO_PRIVATE_API_URL: ngrokUrl,
+		EXPO_UNSTABLE_ATLAS: useAtlas,
+		EXPO_CLIENT_NAME: CLIENT_NAME,
+	}
+}

package/lib/commands/build/index.js

@@ -0,0 +1,71 @@
+import { spawn } from 'child_process'
+
+import { program } from '../../app.js'
+import { generateEnvValues } from '../../app.js'
+import { STAGING_URL } from '../../config.js'
+
+const allowedPlatforms = ['ios', 'android']
+function selectPlatform(platform) {
+  if (!allowedPlatforms.includes(platform))
+    throw new Error(`Invalid platform selected, must be one of ${allowedPlatforms.join(', ')}`)
+  return platform
+}
+
+function selectProfile(dev, preview, prod, profile) {
+  if (profile && (dev || preview || prod)) {
+    throw new Error('Conflict between profile and dev/preview/prod')
+  }
+  if (dev) return 'development'
+  if (preview) return 'preview'
+  if (prod) return 'production'
+  if (profile) return profile
+  return 'development'
+}
+
+program
+  .command('build')
+  .description('Execute eas build command')
+  .option('-d', 'Build to target development profile')
+  .option('-p', 'Build to target preview profile')
+  .option('--live', 'Build to target production profile')
+  .option('--profile <string>', 'Build profile to use')
+  .option('--os, --platform <string>', 'Platform to build', 'ios')
+  .option('-f, --force', 'Force build to target production server')
+  .action((str, options) => {
+    console.log('its me')
+    const platform = selectPlatform(str.platform)
+    const profile = selectProfile(str.d, str.p, str.live, str.profile)
+    const isDev = profile === 'development'
+    //console.log(options);
+    console.log(`Building ${platform} with profile ${'`'}${profile}${'`'}`)
+    console.log('\n\n\n')
+
+    const EXPO_FORCE_PRODUCTION = str.force || isDev ? 'false' : 'true'
+    console.log('EXPO_FORCE_PRODUCTION', EXPO_FORCE_PRODUCTION)
+
+    let envObj = generateEnvValues(EXPO_FORCE_PRODUCTION, '', false)
+    if (!isDev) {
+      envObj.EXPO_PUBLIC_API_URL = `${STAGING_URL}`
+      envObj.EXPO_FORCE_PROD = 'true'
+    } else {
+      const publicUrl = process.env.EXPO_PUBLIC_API_URL || `${STAGING_URL}`
+      envObj.EXPO_PUBLIC_API_URL = publicUrl
+    }
+    console.log('envObj', envObj)
+    envObj.EAS_BUILD_PROFILE = profile // your custom variable
+
+    const command = `w expo-app eas build --profile ${profile} --platform ${platform}`
+    console.log('Running command:', command)
+    const child = spawn('yarn', [command], {
+      stdio: 'inherit',
+      shell: true, // required if using shell-style commands or cross-platform support
+      env: {
+        ...envObj,
+      },
+    })
+
+    child.on('exit', (code) => {
+      console.log(`Process exited with code ${code}`)
+      process.exit(code ?? 0)
+    })
+  })

package/lib/commands/build-process/index.js

@@ -0,0 +1,412 @@
+import { spawn } from 'child_process'
+import fs from 'fs'
+import { program } from '../../app.js'
+import { generateEnvValues } from '../../app.js'
+import { STAGING_URL } from '../../config.js'
+import { getHasteConfig, getHasteFiles, getRootDirectory, getRootJson } from '../loadFromRoot.js'
+import { config } from 'process'
+
+console.log('getRootDirectory', getRootDirectory())
+console.log('rootJson', getRootJson())
+const files = getHasteConfig()
+
+console.log('Haste files', files)
+
+const fileKeys = Object.keys(files)
+let dataLayer = {}
+
+fileKeys.forEach((key) => {
+  const commandName = key
+
+  console.log('Haste file key', commandName, files[key])
+  const configObject = files[commandName] || {}
+  const optionsData = configObject.options || {}
+  const optionsList = Object.keys(optionsData)
+
+  console.log('optionsList', optionsList, optionsData)
+
+  let currentCommand = program.command(commandName).description('Execute eas build command')
+
+  if (configObject.argument) {
+    console.log('has argument', configObject.argument)
+    // .argument('<input>', 'path to input file') // required
+    // .argument('[output]', 'optional output file') // optional
+    const argumentRequired = configObject.argument.required || false
+    const argCommand = argumentRequired
+      ? `<${configObject.argument.type || 'string'}>`
+      : `[${configObject.argument.type || 'string'}]`
+    currentCommand = currentCommand.argument(argCommand, configObject.argument.description || '')
+  }
+
+  optionsList.forEach((optionKey) => {
+    const type = optionsData[optionKey].type || 'boolean'
+
+    if (type === 'string') {
+      if (optionsData[optionKey].shortcut) {
+        currentCommand = currentCommand.option(
+          `-${optionsData[optionKey].shortcut}, --${optionKey} <${optionKey}>`,
+          optionsData[optionKey].description || ''
+        )
+        console.log('optionKey', optionKey, optionsData[optionKey])
+        dataLayer[optionKey] = optionsData[optionKey].default || ''
+      } else {
+        currentCommand = currentCommand.option(
+          `--${optionKey} <${optionKey}>`,
+          optionsData[optionKey].description || ''
+        )
+        dataLayer[optionKey] = optionsData[optionKey].default || ''
+      }
+    } else {
+      if (optionsData[optionKey].shortcut) {
+        currentCommand = currentCommand.option(
+          `-${optionsData[optionKey].shortcut}, --${optionKey}`,
+          optionsData[optionKey].description || ''
+        )
+        console.log('optionKey', optionKey, optionsData[optionKey])
+        dataLayer[optionKey] = optionsData[optionKey].default || false
+      } else {
+        currentCommand = currentCommand.option(
+          `--${optionKey}`,
+          optionsData[optionKey].description || ''
+        )
+        dataLayer[optionKey] = optionsData[optionKey].default || false
+      }
+    }
+  })
+
+  function verifyOptionValues(optionKey, value) {
+    const optionInfo = optionsData[optionKey]
+    if (optionInfo && optionInfo.options) {
+      if (!optionInfo.options.includes(value)) {
+        throw new Error(
+          `Invalid value for --${optionKey}: ${value}. Valid options are: ${optionInfo.options.join(
+            ', '
+          )}`
+        )
+      }
+    }
+    return value
+  }
+
+  currentCommand.action(async (arg, cmd) => {
+    console.log('test:')
+    console.log('cmd', cmd)
+    console.log('arg', arg)
+    const optionVals = cmd.opts ? cmd.opts() : cmd
+    console.log('arg', arg)
+    console.log('optionVals')
+
+    const opts = optionVals
+    Object.keys(opts).forEach((k) => {
+      opts[k] = verifyOptionValues(k, opts[k])
+    })
+    const argVal = arg ? arg : configObject.argument.default
+    console.log('argVal', argVal)
+    dataLayer = { ...dataLayer, ...opts, arg: argVal }
+    console.log('opts', opts)
+    console.log('firstDataLayer', dataLayer)
+    await runHasteCommand(configObject, opts)
+
+    //   const devConfig = configObject.environments ? configObject.environments.dev : {}
+    //   const productionConfig = configObject.environments ? configObject.environments.production : {}
+    //   let envObj = {}
+    //   if (options.stage) {
+    //     envObj = { ...devConfig }
+    //   } else {
+    //     envObj = { ...productionConfig }
+    //   }
+
+    //   // You can decide what happens when each flag is passed.
+    //   // Example: run `eas build` with different profiles.
+    //   if (options.android) {
+    //     console.log('→ Building Android (preview profile)…')
+    //     //run('eas', ['build', '--platform', 'android', '--profile', 'preview'])
+    //   } else if (options.ios) {
+    //     console.log('→ Building iOS (production profile)…')
+    //     //run('eas', ['build', '--platform', 'ios', '--profile', 'production'])
+    //   } else {
+    //     // console.log('No target specified. Use --android or --ios.')
+    //     // program.help()
+    //     console.log('objHaste.actions', configObject)
+    //     const preactions = configObject['preactions'] || []
+    //     const actions = configObject.actions || []
+    //     console.log('preactions', preactions)
+    //     for (const item of preactions) {
+    //       console.log(`→ Running pre-action: ${item}`)
+    //       await run(item, [], envObj)
+    //     }
+    //     for (const item of actions) {
+    //       console.log(`→ Running action: ${item}`)
+    //       run(item, [], envObj)
+    //     }
+    //   }
+    // })
+  })
+})
+
+// const commandName = 'test'
+// program
+//   .command(commandName)
+//   .description('Execute eas build command')
+//   .option('--android', 'Build to target preview profile')
+//   .option('--ios', 'Build to target production profile')
+//   .option('--stage', 'Set environment to staging')
+//   .action((options) => {
+//     const configObject = objHaste[commandName] || {}
+
+//     const devConfig = configObject.environments ? configObject.environments.dev : {}
+//     const productionConfig = configObject.environments ? configObject.environments.production : {}
+//     let envObj = {}
+//     if (options.stage) {
+//       envObj = { ...devConfig }
+//     } else {
+//       envObj = { ...productionConfig }
+//     }
+
+//     // You can decide what happens when each flag is passed.
+//     // Example: run `eas build` with different profiles.
+//     if (options.android) {
+//       console.log('→ Building Android (preview profile)…')
+//       //run('eas', ['build', '--platform', 'android', '--profile', 'preview'])
+//     } else if (options.ios) {
+//       console.log('→ Building iOS (production profile)…')
+//       //run('eas', ['build', '--platform', 'ios', '--profile', 'production'])
+//     } else {
+//       // console.log('No target specified. Use --android or --ios.')
+//       // program.help()
+//       console.log('objHaste.actions', objHaste)
+//       for (const item of configObject.actions) {
+//         console.log(`→ Running action: ${item}`)
+//         run(item, [], envObj)
+//       }
+//     }
+//   })
+
+const totalClosedActions = 0
+// Utility to spawn and pipe child output
+async function run(cmd, args, envObj = {}, count = 1) {
+  const child = spawn(cmd, args, {
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      ...envObj,
+    },
+  })
+  const isLast = count === totalClosedActions + 1
+
+  const exitAction = () => {
+    totalClosedActions++
+    process.exit(code)
+  }
+  if (!isLast) {
+    child.on('exit', (code) => {
+      exitAction()
+    })
+    child.on('sigint', () => {
+      exitAction()
+    })
+  }
+  if (isLast) {
+    child.on('exit', (code) => {
+      if (count < totalClosedActions) exitAction()
+    })
+    child.on('sigint', () => {
+      if (count < totalClosedActions) {
+        exitAction()
+        process.exit(code)
+      }
+    })
+  }
+}
+
+// Track background processes so we can kill them on exit
+const bgChildren = new Set()
+
+/** Run a command and resolve when it exits (attach stdio so you can see output). */
+function runForeground(cmd, envObj = {}, options = {}) {
+  return new Promise((resolve, reject) => {
+    let lastLine = ''
+    let myTextData = ''
+    const child = spawn(cmd, {
+      shell: true,
+      env: { ...process.env, ...envObj },
+      stdio: ['inherit', 'pipe', 'pipe'], // stdin pass-through, capture out/err
+    })
+
+    const handleData = (chunk, isErr = false) => {
+      const text = chunk.toString()
+      console.log(text.toString().trim())
+      console.log('text', text)
+      myTextData = myTextData.concat(text)
+      console.log('myTextData', myTextData)
+
+      // Track last line
+      const lines = text.trim().split(/\r?\n/)
+      if (lines.length) {
+        lastLine = lines[lines.length - 1]
+      }
+    }
+
+    child.stdout.on('data', (chunk) => handleData(chunk, false))
+    child.stderr.on('data', (chunk) => handleData(chunk, true))
+
+    child.on('error', reject)
+    child.on('exit', (code, signal) => {
+      myTextData.concat('\n<<< CHILD PROCESS EXITED >>>\n')
+      console.log('myTextData', myTextData)
+      //const rx = /\{out\s*:\s*(.+?)\}/gs
+      // ^\{out:field-name \$\{([^}]+)\}\}$
+      const rx = /\{out:([^\s]+) (.*)\}\n/g
+      //const rx = /Project ([^\r\n]*)/
+      console.log('myTextData', myTextData)
+      const match = rx.exec(myTextData)
+
+      const rx3 = /\{out:(?<field>[^\s}]+)\s+(?<value>[^\s}]+)\}/g
+      const results = [...myTextData.matchAll(rx3)].map((m) => {
+        const layerIndex = m.groups.field
+        const matchValue = m.groups.value
+        console.log('matchValue', matchValue)
+        dataLayer[layerIndex] = matchValue
+
+        return {
+          field: m.groups.field,
+          value: m.groups.value,
+        }
+      })
+      console.log(results)
+
+      console.log('match', match)
+
+      if (signal) return reject(new Error(`${cmd} exited via signal ${signal}`))
+      if (code === 0) return resolve(lastLine) // resolve with last line
+      reject(new Error(`${cmd} exited with code ${code}. Last line: ${lastLine}`))
+    })
+  })
+}
+
+function runBackground(cmd, envObj = {}, options = {}, attached = false) {
+  const isWin = process.platform === 'win32'
+  // Expand ${0}, ${1}, ... from dataLayer into env strings
+  const newEnv = {}
+  const commandClone = cmd
+  for (const key of Object.keys(envObj)) {
+    let value = envObj[key]
+    if (typeof value === 'string') {
+      console.log('dataLayer', dataLayer)
+      Object.keys(dataLayer).map((k) => {
+        value = value.replace(new RegExp(`\\$\\{${k}\\}`, 'g'), dataLayer[k])
+      })
+    }
+    newEnv[key] = value
+  }
+
+  console.log('newEnv', newEnv)
+
+  const out = commandClone.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    // keep 0/false, only treat null/undefined as missing
+    const v = dataLayer[key]
+    return v == null ? match : String(v)
+  })
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(out, {
+      shell: true,
+      stdio: attached ? 'inherit' : 'ignore', // no output in this terminal
+      env: { ...process.env, ...newEnv },
+      // On POSIX, detach so we can signal the whole group; on Windows, DON'T.
+      detached: !attached && !isWin,
+      windowsHide: !attached && !isWin, // prevent new console window on Windows
+    })
+
+    // Only unref on POSIX when detached; on Windows keep it referenced.
+    if (!attached && !isWin) child.unref()
+
+    child.once('error', (err) => {
+      bgChildren.delete(child)
+      reject(err)
+    })
+
+    child.once('exit', (code, signal) => {
+      bgChildren.delete(child)
+      if (signal) return reject(new Error(`${cmd} exited via signal ${signal}`))
+      if (code === 0) return resolve()
+      reject(new Error(`${cmd} exited with code ${code}`))
+    })
+  })
+}
+
+/** Kill all background children (called on SIGINT/SIGTERM or when foreground ends). */
+function killAllBackground() {
+  for (const child of Array.from(bgChildren)) {
+    try {
+      if (process.platform === 'win32') {
+        spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { shell: true, stdio: 'ignore' })
+      } else {
+        process.kill(-child.pid, 'SIGTERM') // whole group
+      }
+    } catch {}
+  }
+  bgChildren.clear()
+}
+
+process.on('SIGINT', () => {
+  console.log('\nSIGINT')
+  killAllBackground()
+  process.exit(130)
+})
+process.on('SIGTERM', () => {
+  killAllBackground()
+  process.exit(143)
+})
+
+/** In your commander .action handler */
+async function runHasteCommand(configObject, options = {}) {
+  const environments = configObject.environments
+  const devConfig = configObject.environments?.dev ?? {}
+  const productionConfig = configObject.environments?.stage ?? {}
+  console.log('options', options)
+  const awsProfile = process.env.CDK_DEPLOY_PROFILE || 'default'
+  console.log('prof', awsProfile)
+  const envObj = options.stage ? productionConfig : devConfig
+  envObj['AWS_PROFILE'] = awsProfile
+
+  const preactions = configObject.preactions ?? []
+  const actions = configObject.actions ?? []
+
+  console.log('environments', environments)
+
+  console.log('preactions', preactions)
+
+  // 1) Run preactions SEQUENTIALLY (each waits for previous to finish)
+  let num = 0
+  console.log('envObj', envObj)
+  for (const cmd of preactions) {
+    console.log(`→ preaction: ${cmd}`)
+    await runForeground(cmd, envObj, options)
+    num++
+  }
+
+  // 2) Run actions: background all but the last; attach to the last
+  if (actions.length === 0) return
+
+  const bg = actions.slice(0, -1)
+  const fg = actions[actions.length - 1]
+
+  for (const cmd of bg) {
+    console.log(`→ background action: ${cmd}`)
+    runBackground(cmd, envObj, options)
+  }
+
+  console.log(`→ foreground action (attached): ${fg}`)
+  try {
+    console.log('envObj', envObj)
+    await runBackground(fg, envObj, options, true)
+  } finally {
+    // When the foreground ends, clean up background processes too (optional)
+    killAllBackground()
+  }
+}
+
+//ACTION TYPES: preaction, action
+//COMMAND TYPES: sequence, parallel

package/lib/commands/deploy/index.js

@@ -0,0 +1,44 @@
+import assert from 'assert'
+import { spawn } from 'child_process'
+import { readFileSync } from 'fs'
+
+import { program } from '../../app.js'
+import { join } from 'node:path';
+const packageJSON = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+
+console.log('Deploy command loaded')
+
+const awsObject = packageJSON['aws'] || {}
+
+// const awsProfile = awsObject['profile'] || 'default'
+const accountId = process.env.CDK_DEPLOY_ACCOUNT
+const awsProfile = process.env.CDK_DEPLOY_PROFILE || 'default'
+
+console.log('process.env', process.env)
+console.log('CDK_DEPLOY_ACCOUNT', process.env.CDK_DEPLOY_PROFILE)
+program
+  .command('deploy2')
+  .description('Execute cdk deploy command')
+  .argument('[<string>]', 'Environment to deploy')
+  .option('-d, --dev', 'Deploy to dev environment')
+  .option('-r, --region <region>', 'Region to deploy to')
+  .action((str, options) => {
+    const owner = str || 'dev'
+    const region = options.region || 'us-east-2'
+    console.log(`Deploying to ${owner} environment`)
+    const command = `workspace infra deploy`
+    const inputs = `-c owner=${owner} -c region=${region}`
+    console.log(`Inputs: ${inputs}`)
+    const child = spawn('yarn', [`${command} ${inputs}`], {
+      stdio: 'inherit',
+      shell: true, // required if using shell-style commands or cross-platform support
+      env: {
+        AWS_PROFILE: awsProfile,
+      },
+    })
+
+    child.on('exit', (code) => {
+      console.log(`Process exited with code ${code}`)
+      process.exit(code ?? 0)
+    })
+  })

package/lib/commands/destroy.js

@@ -0,0 +1,27 @@
+import { spawn } from 'child_process'
+
+import { program } from '../app.js'
+
+program
+	.command('destroy')
+	.description('Destroys the current or specified cdk construct')
+	.argument('[<string>]', 'Environment to deploy')
+	.option('-d, --dev', 'Deploy to dev environment')
+	.option('-r, --region <region>', 'Region to deploy to')
+	.action((str, options) => {
+		const owner = str || 'dev'
+		const region = options.region || 'us-east-2'
+		console.log(`Deploying to ${owner} environment`)
+		const command = `workspace infra cdk destroy`
+		const inputs = `-c owner=${owner} -c region=${region}`
+		console.log(`Inputs: ${inputs}`)
+		const child = spawn('yarn', [`${command} ${inputs}`], {
+			stdio: 'inherit',
+			shell: true, // required if using shell-style commands or cross-platform support
+		})
+
+		child.on('exit', (code) => {
+			console.log(`Process exited with code ${code}`)
+			process.exit(code ?? 0)
+		})
+	})