@mono-labs/cli 0.0.5

package/lib/commands/prune/index.js

@@ -0,0 +1,12 @@
+import { spawn } from 'child_process'
+
+import { program } from '../../app.js'
+import { pruneRepo } from './prune.js'
+
+program
+	.command('prune')
+	.description('Prune local branches that are not on origin')
+
+	.action(() => {
+		pruneRepo()
+	})

package/lib/commands/prune/prune.js

@@ -0,0 +1,48 @@
+import { execSync } from 'child_process'
+
+const log = (...args) => console.log(...args)
+const err = (...args) => console.error(...args)
+export function pruneRepo() {
+	try {
+		// Fetch and prune remote branches
+		log('Fetching latest branch data from origin...')
+		execSync('git fetch --prune', { stdio: 'inherit' })
+
+		// Get local branches (trim whitespace)
+		const localBranches = execSync("git branch --format '%(refname:short)'")
+			.toString()
+			.trim()
+			.split('\n')
+			.map((branch) => branch.trim().replaceAll("'", ''))
+
+		// Get remote branches (remove "origin/" prefix)
+		const remoteBranches = execSync('git branch -r')
+			.toString()
+			.trim()
+			.split('\n')
+			.map((branch) => branch.replace(/^\s*origin\//, '').trim())
+
+		// Find local branches that are NOT in remote branches
+		const branchesToDelete = localBranches.filter((branch) => !remoteBranches.includes(branch))
+		if (branchesToDelete.length === 0) {
+			log('No local branches to delete.')
+			process.exit(0)
+		}
+
+		// Delete untracked local branches
+		log('Deleting local branches that are not on origin...')
+		branchesToDelete.forEach((branch) => {
+			log(`Attempting to delete: ${branch}`)
+			try {
+				execSync(`git branch -D ${branch}`, { stdio: 'inherit' })
+				log(`Deleted: ${branch}`)
+			} catch (error) {
+				error(`Failed to delete branch ${branch}:`, error.message)
+			}
+		})
+
+		log('Cleanup complete!')
+	} catch (error) {
+		err('An error occurred:', error.message)
+	}
+}

package/lib/commands/reset.js

@@ -0,0 +1,31 @@
+import { spawn } from 'child_process'
+
+import { program } from '../app.js'
+
+function createChild(command) {
+	const child = spawn(command, {
+		stdio: ['inherit', 'pipe', 'pipe'], // Read from terminal, but capture output
+		shell: true,
+		env: {
+			...process.env,
+		},
+	})
+
+	child.stdout.on('data', (data) => {
+		process.stdout.write(data) // pipe to main stdout
+	})
+
+	child.stderr.on('data', (data) => {
+		process.stderr.write(data) // pipe errors
+	})
+	child.on('message', (data) => {
+		console.log(`Message from child process: ${data}`)
+	})
+}
+program
+	.command('reset')
+	.description('Execute eas build command')
+	.option('-s, --soft', 'Pull from live')
+	.action(async (options) => {
+		createChild(`git reset ${options.soft ? '--soft' : '--mixed '} HEAD~1`)
+	})

package/lib/commands/seed/import.js

@@ -0,0 +1,31 @@
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+
+export function importAllDynamoBatches(folderPath, useRemote = false) {
+	const files = fs
+		.readdirSync(folderPath)
+		.filter((file) => file.startsWith('dynamodb-seed-') && file.endsWith('.json'))
+
+	files.sort() // Optional: ensures files run in order
+
+	for (const file of files) {
+		const fullPath = path.resolve(path.join(folderPath, file))
+		console.log(`📝 Importing: ${fullPath}`)
+		console.log('Using remote DynamoDB:', useRemote)
+		const baseCommand = useRemote
+			? `aws dynamodb batch-write-item --request-items file://${fullPath}`
+			: `aws dynamodb batch-write-item --endpoint-url http://localhost:8000 --request-items file://${fullPath}`
+		try {
+			console.log('baseCommand:', baseCommand)
+			console.log(`Executing command: ${baseCommand}`)
+			execSync(baseCommand, {
+				stdio: 'inherit',
+			})
+			console.log(`✅ Successfully imported ${file}\n`)
+		} catch (err) {
+			console.error(`❌ Error with ${file}:`, err.message)
+			break // or continue if you want to skip failed files
+		}
+	}
+}

package/lib/commands/seed/index.js

@@ -0,0 +1,12 @@
+import { spawn } from 'child_process'
+
+import { program } from '../../app.js'
+import { importAllDynamoBatches } from './import.js'
+
+program
+	.command('seed')
+	.description('Execute eas build command')
+	.option('-p, --live', 'Pull from live')
+	.action(async (options) => {
+		importAllDynamoBatches('./docker/seed', options.live)
+	})

package/lib/commands/squash/index.js

@@ -0,0 +1,8 @@
+import { program } from '../../app.js'
+import { squash } from './squash.js'
+
+program
+	.command('squash')
+	.description('Squash x count of commits into one commit')
+
+	.action(() => squash())

package/lib/commands/squash/squash.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { execSync, spawnSync } from 'child_process'
+import fs from 'fs'
+import inquirer from 'inquirer'
+import os from 'os'
+import path from 'path'
+
+async function maybeEditFile() {
+	const { shouldEdit } = await inquirer.prompt([
+		{
+			type: 'confirm',
+			name: 'shouldEdit',
+			message: 'Do you want to edit the commit message in your Git editor?',
+			default: true,
+		},
+	])
+
+	if (shouldEdit) {
+		execSync('git commit --amend')
+	}
+}
+
+async function confirmDangerousSquash() {
+	const { shouldEdit } = await inquirer.prompt([
+		{
+			type: 'confirm',
+			name: 'shouldEdit',
+			message:
+				"You're about to squash on a previously squashed commit.  You will need to manually modify the commit message. Do you want to proceed?",
+			default: true,
+		},
+	])
+
+	return shouldEdit
+}
+
+export async function squash() {
+	const status = execSync('git status --porcelain').toString()
+	if (status.trim() !== '') {
+		console.error('You have unstaged  changes. Please commit or stash them before proceeding.')
+		process.exit(1)
+	}
+	const log = execSync(`git log --reverse --pretty=format:"%h %s" -n ${20}`).toString()
+	console.log('Log:\n', log)
+
+	const commits = log
+		.split('\n')
+		.reverse()
+		.map((line, idx) => {
+			console.log('message', line.slice(8).split('- '))
+			return {
+				name: `${idx} [${line.slice(0, 7)}] : ${line.slice(8)}`,
+				value: idx, // Just the commit message
+				message: line.slice(8).split('- ').join('\n- '),
+			}
+		})
+	console.log(commits)
+
+	const { count } = await inquirer.prompt([
+		{
+			type: 'list',
+			name: 'count',
+			message: 'Select commit to squash down into:',
+			choices: commits,
+		},
+	])
+
+	if (count === 0) {
+		console.log('You may not squash only one commit.')
+		return
+	}
+	let totalMerged = 0
+	const commitMessageGen = commits
+		.slice(0, count + 1)
+		.map((msg) => {
+			return msg.message
+		})
+		.map((msg) => `${msg}`)
+		.join('\n')
+
+	let shouldContinue = true
+	const match = commitMessageGen.match(/Merging (\d+)\s+into singular commit/)
+	if (match) {
+		shouldContinue = await confirmDangerousSquash()
+		console.log('Unable to merge with merged commits')
+		if (!shouldContinue) return
+	}
+
+	console.log('Total merged:', totalMerged)
+	console.log(count + 1 + totalMerged)
+	const commitMessage = `Merging ${count + 1 + totalMerged} into singular commit\n${commitMessageGen}`
+
+	console.log(`Commit message:\n${commitMessage}`)
+
+	// Write message to temp file
+	const tempMessagePath = path.join(os.tmpdir(), 'git_squash_message.txt')
+	fs.writeFileSync(tempMessagePath, commitMessage)
+
+	if (shouldContinue) {
+		const { confirmSquash } = await inquirer.prompt([
+			{
+				type: 'confirm',
+				name: 'confirmSquash',
+				message: 'Do you want to squash these commits?',
+				default: true, // or false if you want "No" as the default
+			},
+		])
+
+		shouldContinue = confirmSquash
+	}
+
+	if (!shouldContinue) return
+	// proceed with
+
+	// GIT_EDITOR override for rebase message
+	const isWin = process.platform === 'win32'
+	const editorScript = path.join(os.tmpdir(), isWin ? 'git-editor.bat' : 'git-editor.sh')
+	const messagePath = path.join(os.tmpdir(), 'commit-message.txt')
+
+	fs.writeFileSync(messagePath, commitMessage)
+
+	if (isWin) {
+		fs.writeFileSync(editorScript, `@echo off\r\ncopy /Y "${messagePath}" %1 > nul\r\n`)
+	} else {
+		fs.writeFileSync(editorScript, `#!/bin/sh\ncat "${messagePath}" > "$1"\n`)
+		fs.chmodSync(editorScript, '755')
+	}
+
+	console.log('Starting interactive rebase...')
+
+	spawnSync('git', ['reset', '--soft', `HEAD~${count + 1}`], { stdio: 'inherit' })
+
+	spawnSync('git', ['commit', '-m', commitMessage], { stdio: 'inherit' })
+
+	const rebaseResult = spawnSync('git', ['rebase', `HEAD~${count}`], {
+		stdio: 'inherit',
+		env: { ...process.env, GIT_EDITOR: editorScript },
+	})
+
+	console.log(`Rebase result: ${rebaseResult.status}`)
+
+	if (rebaseResult.status !== 0) {
+		console.error('Rebase failed. Resolve conflicts and try again.')
+		process.exit(rebaseResult.status)
+	}
+
+	await maybeEditFile()
+
+	console.log('✅ Rebase complete.')
+}

package/lib/commands/submit/index.js

@@ -0,0 +1,38 @@
+import { spawn } from 'child_process'
+
+import { program } from '../../app.js'
+import { generateEnvValues } from '../../app.js'
+import { STAGING_URL } from '../../config.js'
+
+program
+	.command('submit')
+	.description('Execute eas build command')
+	.option('--android', 'Build to target preview profile')
+	.option('--ios', 'Build to target production profile')
+	.action((str, options) => {
+		console.log('its me')
+		console.log('test')
+		//console.log(options);
+		console.log(str)
+
+		let envObj = generateEnvValues(true, '', false)
+
+		envObj.EXPO_PUBLIC_API_URL = `${STAGING_URL}`
+		envObj.EXPO_FORCE_PROD = 'true'
+		envObj.EAS_BUILD_PROFILE = 'production'
+
+		const command = `workspace app eas submit ${str.android ? `--platform android` : `--platform ios`}`
+		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/test/index.js

@@ -0,0 +1,251 @@
+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,
+  getRootHasteJson,
+  getRootJson,
+} from '../loadFromRoot.js'
+
+console.log('getRootDirectory', getRootDirectory())
+console.log('rootJson', getRootJson())
+const objHaste = getRootHasteJson()
+const files = getHasteConfig()
+
+console.log('Haste files', files)
+
+const fileKeys = Object.keys(files)
+
+fileKeys.forEach((key) => {
+  const commandName = key
+
+  console.log('Haste file key', commandName, files[key])
+  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(async (options) => {
+      const configObject = files[commandName] || {}
+      await runHasteCommand(configObject, options)
+
+      //   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 = {}) {
+  return new Promise((resolve, reject) => {
+    // run the whole string via the shell so quotes/pipes work
+    const child = spawn(cmd, {
+      shell: true,
+      stdio: 'inherit',
+      env: { ...process.env, ...envObj },
+    })
+    child.on('error', reject)
+    child.on('exit', (code, signal) => {
+      if (signal) return reject(new Error(`${cmd} exited via signal ${signal}`))
+      if (code === 0) return resolve()
+      reject(new Error(`${cmd} exited with code ${code}`))
+    })
+  })
+}
+
+/** Start a command fully detached (no stdio). */
+function runBackground(cmd, envObj = {}) {
+  const isWin = process.platform === 'win32'
+
+  const child = spawn(cmd, {
+    shell: true,
+    stdio: 'ignore', // no output in this terminal
+    env: { ...process.env, ...envObj },
+    // On POSIX, detach so we can signal the whole group; on Windows, DON'T.
+    detached: !isWin,
+    windowsHide: isWin, // prevent new console window on Windows
+  })
+
+  // Only unref on POSIX when detached; on Windows keep it referenced.
+  if (!isWin) child.unref()
+
+  bgChildren.add(child)
+  child.on('exit', () => bgChildren.delete(child))
+  child.on('error', () => bgChildren.delete(child))
+}
+
+/** 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 devConfig = configObject.environments?.dev ?? {}
+  const productionConfig = configObject.environments?.production ?? {}
+  const envObj = options.stage ? devConfig : productionConfig
+
+  const preactions = configObject.preactions ?? []
+  const actions = configObject.actions ?? []
+
+  // 1) Run preactions SEQUENTIALLY (each waits for previous to finish)
+  for (const cmd of preactions) {
+    console.log(`→ preaction: ${cmd}`)
+    await runForeground(cmd, envObj)
+  }
+
+  // 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)
+  }
+
+  console.log(`→ foreground action (attached): ${fg}`)
+  console.log('envObj', envObj)
+  try {
+    console.log('envObj', envObj)
+    await runForeground(fg, envObj)
+  } finally {
+    // When the foreground ends, clean up background processes too (optional)
+    killAllBackground()
+  }
+}

package/lib/commands/update/eas.js

@@ -0,0 +1,39 @@
+import { execSync } from 'child_process'
+
+export function getEASChannels() {
+	const channelsData = execSync(
+		'yarn eas channel:list --non-interactive --json',
+		{ stdio: ['pipe', 'pipe', 'ignore'] }, // Ignore stderr
+	).toString()
+
+	// Extract valid JSON from any extra noise
+	const jsonStart = channelsData.indexOf('[')
+	const jsonEnd = channelsData.lastIndexOf(']') + 1
+
+	if (jsonStart === -1 || jsonEnd === -1) {
+		throw new Error('JSON output not found in command output')
+	}
+
+	const jsonSlice = channelsData.slice(jsonStart, jsonEnd)
+	const channels = JSON.parse(jsonSlice)
+	return channels
+}
+
+export function getEASBranches() {
+	const channelsData = execSync(
+		'yarn eas branch:list --non-interactive --json',
+		{ stdio: ['pipe', 'pipe', 'ignore'] }, // Ignore stderr
+	).toString()
+
+	// Extract valid JSON from any extra noise
+	const jsonStart = channelsData.indexOf('[')
+	const jsonEnd = channelsData.lastIndexOf(']') + 1
+
+	if (jsonStart === -1 || jsonEnd === -1) {
+		throw new Error('JSON output not found in command output')
+	}
+
+	const jsonSlice = channelsData.slice(jsonStart, jsonEnd)
+	const channels = JSON.parse(jsonSlice)
+	return channels
+}