@take-out/scripts 0.1.37 → 0.1.38-1772433507984

package/src/run.ts

@@ -1,32 +1,14 @@
 #!/usr/bin/env bun
 
 /**
- * @description Run multiple scripts in parallel
+ * @description Run multiple scripts in parallel using run-group for proper process management
  */
 
-import { spawn } from 'node:child_process'
 import fs from 'node:fs'
-import { join, relative, resolve } from 'node:path'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-import { handleProcessExit } from '@take-out/scripts/helpers/handleProcessExit'
-
-import { getIsExiting } from './helpers/run'
-import { checkNodeVersion } from './node-version-check'
-
-const colors = [
-  '\x1b[38;5;245m',
-  '\x1b[38;5;240m',
-  '\x1b[38;5;250m',
-  '\x1b[38;5;243m',
-  '\x1b[38;5;248m',
-  '\x1b[38;5;238m',
-  '\x1b[38;5;252m',
-]
-
-const reset = '\x1b[0m'
-
-// eslint-disable-next-line no-control-regex
-const ansiPattern = /\x1b\[[0-9;]*m/g
+const __dirname = dirname(fileURLToPath(import.meta.url))
 
 const args = process.argv.slice(2)
 const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
@@ -50,40 +32,22 @@ for (let i = 0; i < args.length; i++) {
 }
 
 const noRoot = args.includes('--no-root')
-const runBun = args.includes('--bun')
-const watch = args.includes('--watch')
 const flagsLast = args.includes('--flags=last')
 
-const MAX_RESTARTS = 3
-
 const parentRunningScripts = process.env.BUN_RUN_SCRIPTS
   ? process.env.BUN_RUN_SCRIPTS.split(',')
   : []
 
-interface ManagedProcess {
-  proc: ReturnType<typeof spawn>
-  name: string
-  cwd: string
-  prefixLabel: string
-  extraArgs: string[]
-  index: number
-  shortcut: string
-}
-
-const managedProcesses: ManagedProcess[] = []
-const { addChildProcess, exit } = handleProcessExit()
-
-function getPrefix(index: number): string {
-  const managed = managedProcesses[index]
-  if (!managed) return ''
-  const color = colors[index % colors.length]
-  const sc = managed.shortcut || String(index + 1)
-  return `${color}${sc} ${managed.prefixLabel}${reset}`
-}
-
 if (runCommands.length === 0) {
   console.error('Please provide at least one script name to run')
-  exit(1)
+  process.exit(1)
+}
+
+interface ResolvedCommand {
+  name: string
+  command: string
+  cwd: string
+  args: string[]
 }
 
 async function readPackageJson(directoryPath: string) {
@@ -179,6 +143,15 @@ async function findWorkspaceDirectories(): Promise<string[]> {
   })
 }
 
+async function getScriptCommand(
+  directoryPath: string,
+  scriptName: string
+): Promise<string | null> {
+  const packageJson = await readPackageJson(directoryPath)
+  if (!packageJson?.scripts?.[scriptName]) return null
+  return packageJson.scripts[scriptName]
+}
+
 async function findAvailableScripts(
   directoryPath: string,
   scriptNames: string[]
@@ -194,218 +167,180 @@ async function findAvailableScripts(
   )
 }
 
-async function mapWorkspacesToScripts(
-  scriptNames: string[]
-): Promise<Map<string, { scripts: string[]; packageName: string }>> {
+async function resolveAllCommands(): Promise<ResolvedCommand[]> {
+  const commands: ResolvedCommand[] = []
+  const lastScript = runCommands[runCommands.length - 1]
+
+  // root scripts
+  if (!noRoot) {
+    const filteredCommands = runCommands.filter(
+      (name) => !parentRunningScripts.includes(name)
+    )
+
+    for (const name of filteredCommands) {
+      const command = await getScriptCommand('.', name)
+      if (command) {
+        const scriptArgs = !flagsLast || name === lastScript ? forwardArgs : []
+        commands.push({
+          name,
+          command,
+          cwd: '.',
+          args: scriptArgs,
+        })
+      }
+    }
+  }
+
+  // workspace scripts
   const workspaceDirs = await findWorkspaceDirectories()
-  const workspaceScriptMap = new Map<string, { scripts: string[]; packageName: string }>()
 
   for (const dir of workspaceDirs) {
-    const availableScripts = await findAvailableScripts(dir, scriptNames)
-
-    if (availableScripts.length > 0) {
-      const packageJson = await readPackageJson(dir)
-      const packageName = packageJson?.name || dir
-      workspaceScriptMap.set(dir, {
-        scripts: availableScripts,
-        packageName,
-      })
+    const availableScripts = await findAvailableScripts(dir, runCommands)
+    const filteredScripts = availableScripts.filter(
+      (scriptName) => !parentRunningScripts.includes(scriptName)
+    )
+
+    for (const scriptName of filteredScripts) {
+      const command = await getScriptCommand(dir, scriptName)
+      if (command) {
+        const packageJson = await readPackageJson(dir)
+        const packageName = packageJson?.name || dir
+        const scriptArgs = !flagsLast || scriptName === lastScript ? forwardArgs : []
+
+        commands.push({
+          name: `${packageName} ${scriptName}`,
+          command,
+          cwd: dir,
+          args: scriptArgs,
+        })
+      }
     }
   }
 
-  return workspaceScriptMap
+  return commands
 }
 
-const runScript = async (
-  name: string,
-  cwd = '.',
-  prefixLabel: string = name,
-  restarts = 0,
-  extraArgs: string[] = [],
-  managedIndex?: number
-) => {
-  const index = managedIndex ?? managedProcesses.length
-
-  const runArgs = ['run', '--silent', runBun ? '--bun' : '', name, ...extraArgs].filter(
-    Boolean
-  )
+function findRunGroup(): string | null {
+  // check local first (in takeout monorepo)
+  const localPath = join(__dirname, 'run-group', 'run-group')
+  if (fs.existsSync(localPath)) return localPath
 
-  const allRunningScripts = [...parentRunningScripts, ...runCommands].join(',')
-
-  const proc = spawn('bun', runArgs, {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    shell: false,
-    detached: true,
-    env: {
-      ...process.env,
-      FORCE_COLOR: '3',
-      BUN_RUN_PARENT_SCRIPT: name,
-      BUN_RUN_SCRIPTS: allRunningScripts,
-      TKO_SILENT: '1',
-    } as any,
-    cwd: resolve(cwd),
-  })
+  // check installed package
+  const installedPath = join(__dirname, '..', 'run-group', 'run-group')
+  if (fs.existsSync(installedPath)) return installedPath
 
-  const managed: ManagedProcess = {
-    proc,
-    name,
-    cwd,
-    prefixLabel,
-    extraArgs,
-    index,
-    shortcut: '',
-  }
+  return null
+}
 
-  if (managedIndex !== undefined) {
-    managedProcesses[managedIndex] = managed
-  } else {
-    managedProcesses.push(managed)
-  }
+// fallback: use node spawn when run-group binary not available
+async function runWithNodeFallback(commands: ResolvedCommand[]) {
+  const { spawn } = await import('node:child_process')
+  const { handleProcessExit } = await import('@take-out/scripts/helpers/handleProcessExit')
+
+  const colors = [
+    '\x1b[36m', '\x1b[35m', '\x1b[32m', '\x1b[33m', '\x1b[34m', '\x1b[31m',
+  ]
+  const reset = '\x1b[0m'
+
+  const { addChildProcess } = handleProcessExit()
+  let exitCode = 0
+
+  const procs = commands.map((cmd, i) => {
+    const color = colors[i % colors.length]
+    const prefix = `${color}[${cmd.name}]${reset}`
+    const fullCwd = resolve(cmd.cwd)
+    const fullCommand = cmd.args.length > 0
+      ? `${cmd.command} ${cmd.args.join(' ')}`
+      : cmd.command
+
+    const proc = spawn('sh', ['-c', fullCommand], {
+      cwd: fullCwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        FORCE_COLOR: '3',
+        TKO_SILENT: '1',
+        BUN_RUN_SCRIPTS: runCommands.join(','),
+      },
+    })
 
-  addChildProcess(proc)
+    addChildProcess(proc)
 
-  proc.stdout!.on('data', (data) => {
-    if (getIsExiting()) return
-    const lines = data.toString().split('\n')
-    for (const line of lines) {
-      const stripped = line.replace(ansiPattern, '')
-      if (stripped.startsWith('$ ')) continue
-      if (line) console.info(`${getPrefix(index)} ${line}`)
-    }
-  })
+    proc.stdout?.on('data', (data) => {
+      for (const line of data.toString().split('\n')) {
+        if (line) console.log(`${prefix} ${line}`)
+      }
+    })
 
-  proc.stderr!.on('data', (data) => {
-    if (getIsExiting()) return
-    const lines = data.toString().split('\n')
-    for (const line of lines) {
-      const stripped = line.replace(ansiPattern, '')
-      if (stripped.startsWith('$ ')) continue
-      if (line) console.error(`${getPrefix(index)} ${line}`)
-    }
-  })
+    proc.stderr?.on('data', (data) => {
+      for (const line of data.toString().split('\n')) {
+        if (line) console.error(`${prefix} ${line}`)
+      }
+    })
 
-  proc.on('error', (error) => {
-    console.error(`${getPrefix(index)} Failed to start: ${error.message}`)
+    return new Promise<number>((resolve) => {
+      proc.on('close', (code) => resolve(code || 0))
+    })
   })
 
-  proc.on('close', (code) => {
-    if (getIsExiting()) return
+  const codes = await Promise.all(procs)
+  exitCode = Math.max(...codes)
+  process.exit(exitCode)
+}
 
-    if (code && code !== 0) {
-      console.error(`${getPrefix(index)} Process exited with code ${code}`)
+async function main() {
+  const commands = await resolveAllCommands()
 
-      if (watch && restarts < MAX_RESTARTS) {
-        const newRestarts = restarts + 1
-        console.info(`Restarting process ${name} (${newRestarts}/${MAX_RESTARTS} times)`)
-        runScript(name, cwd, prefixLabel, newRestarts, extraArgs, index)
-      } else {
-        exit(1)
-      }
-    }
-  })
+  if (commands.length === 0) {
+    console.error('No matching scripts found')
+    process.exit(0)
+  }
 
-  return proc
-}
+  const runGroupPath = findRunGroup()
 
-function computeShortcuts() {
-  const initials = managedProcesses.map((p) => {
-    const words = p.prefixLabel
-      .toLowerCase()
-      .split(/[^a-z]+/)
-      .filter(Boolean)
-    return words.map((w) => w[0]).join('')
-  })
+  // fallback to node if binary not available
+  if (!runGroupPath) {
+    return runWithNodeFallback(commands)
+  }
 
-  const lengths = new Array(managedProcesses.length).fill(1) as number[]
+  // build run-group command
+  // format: run-group -p -t @name <cmd1> --- @name2 <cmd2> --- ...
+  const runGroupArgs: string[] = ['-p', '-t']
 
-  for (let round = 0; round < 5; round++) {
-    const shortcuts = initials.map((init, i) => init.slice(0, lengths[i]) || init)
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i]!
+    const fullCwd = resolve(cmd.cwd)
 
-    let hasCollision = false
-    const groups = new Map<string, number[]>()
-    for (let i = 0; i < shortcuts.length; i++) {
-      const key = shortcuts[i]!
-      if (!groups.has(key)) groups.set(key, [])
-      groups.get(key)!.push(i)
-    }
+    // wrap command with cd and env setup
+    // use sh -c to handle complex commands with &&, ||, etc
+    const envSetup = `FORCE_COLOR=3 TKO_SILENT=1 BUN_RUN_SCRIPTS=${runCommands.join(',')}`
+    const fullCommand = cmd.args.length > 0
+      ? `${cmd.command} ${cmd.args.join(' ')}`
+      : cmd.command
 
-    for (const [, indices] of groups) {
-      if (indices.length <= 1) continue
-      hasCollision = true
-      for (const idx of indices) {
-        lengths[idx]!++
-      }
-    }
+    // use @name prefix for display name in parallel mode
+    runGroupArgs.push(`@${cmd.name}`)
+    runGroupArgs.push('sh', '-c', `cd "${fullCwd}" && ${envSetup} ${fullCommand}`)
 
-    if (!hasCollision) {
-      for (let i = 0; i < managedProcesses.length; i++) {
-        managedProcesses[i]!.shortcut = shortcuts[i]!
-      }
-      return
+    if (i < commands.length - 1) {
+      runGroupArgs.push('---')
     }
   }
 
-  for (let i = 0; i < managedProcesses.length; i++) {
-    const sc = initials[i]!.slice(0, lengths[i]) || initials[i]!
-    managedProcesses[i]!.shortcut = sc || String(i + 1)
-  }
-}
-
-async function main() {
-  checkNodeVersion().catch((err) => {
-    console.error(err.message)
-    exit(1)
-  })
+  // exec run-group (replaces this process)
+  const { execFileSync } = await import('node:child_process')
 
   try {
-    if (runCommands.length > 0) {
-      const lastScript = runCommands[runCommands.length - 1]
-
-      if (!noRoot) {
-        const filteredCommands = runCommands.filter(
-          (name) => !parentRunningScripts.includes(name)
-        )
-        const scriptPromises = filteredCommands.map((name) => {
-          const scriptArgs = !flagsLast || name === lastScript ? forwardArgs : []
-          return runScript(name, '.', name, 0, scriptArgs)
-        })
-
-        await Promise.all(scriptPromises)
-      }
-
-      const workspaceScriptMap = await mapWorkspacesToScripts(runCommands)
-
-      for (const [workspace, { scripts, packageName }] of workspaceScriptMap.entries()) {
-        const filteredScripts = scripts.filter(
-          (scriptName) => !parentRunningScripts.includes(scriptName)
-        )
-        const workspaceScriptPromises = filteredScripts.map((scriptName) => {
-          const scriptArgs = !flagsLast || scriptName === lastScript ? forwardArgs : []
-          return runScript(
-            scriptName,
-            workspace,
-            `${packageName} ${scriptName}`,
-            0,
-            scriptArgs
-          )
-        })
-
-        await Promise.all(workspaceScriptPromises)
-      }
-    }
-
-    if (managedProcesses.length === 0) {
-      exit(0)
-    } else {
-      computeShortcuts()
-    }
-  } catch (error) {
-    console.error(`Error running scripts: ${error}`)
-    exit(1)
+    execFileSync(runGroupPath, runGroupArgs, {
+      stdio: 'inherit',
+      env: process.env,
+    })
+  } catch (error: any) {
+    process.exit(error.status || 1)
   }
 }
 
 main().catch((error) => {
   console.error(`Error running scripts: ${error}`)
-  exit(1)
+  process.exit(1)
 })