@take-out/scripts 0.1.39 → 0.1.40

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
-  "main": "./src/run.ts",
+  "main": "./src/cmd.ts",
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./src/run.ts",
-      "default": "./src/run.ts"
+      "types": "./src/cmd.ts",
+      "default": "./src/cmd.ts"
     },
     "./package.json": "./package.json",
     "./helpers/*": {
@@ -30,7 +30,8 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "@lydell/node-pty": "^1.2.0-beta.3",
-    "@take-out/helpers": "0.1.39",
+    "@take-out/helpers": "0.1.40",
+    "@take-out/run": "0.1.40",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/build-initial.ts

@@ -25,7 +25,7 @@ await cmd`bootstrap project workspace and build initial packages`.run(
         await $`cd packages/helpers && bun run build`
 
         // then build all other packages in parallel
-        await $`bun ./packages/scripts/src/run.ts build --no-root`
+        await $`bun ./packages/run/src/run.ts build --no-root`
       }
     }
 

package/src/dev-tunnel.ts

@@ -7,7 +7,7 @@ import { cmd } from './cmd'
 await cmd`set up cloudflare dev tunnel for local development`
   .args('--port number')
   .run(async ({ args, run, os, path }) => {
-    const { handleProcessExit } = await import('./helpers/handleProcessExit')
+    const { handleProcessExit } = await import('@take-out/run/helpers/handleProcessExit')
 
     handleProcessExit()
 

package/src/helpers/run.ts

@@ -1,23 +1,17 @@
-import { spawn, type ChildProcess } from 'node:child_process'
+import { spawn } from 'node:child_process'
 import { cpus } from 'node:os'
 
-import type { Timer } from '@take-out/helpers'
-
-export type ProcessType = ChildProcess
-export type ProcessHandler = (process: ProcessType) => void
-
-// track if we're in cleanup state (another process failed)
-let isInExitCleanup = false
-
-export function setExitCleanupState(state: boolean) {
-  isInExitCleanup = state
-}
+import {
+  getIsExiting,
+  notifyProcessHandlers,
+  type ProcessHandler,
+  type ProcessType,
+} from '@take-out/run/helpers/process-state'
 
-export function getIsExiting() {
-  return isInExitCleanup
-}
+import type { Timer } from '@take-out/helpers'
 
-const processHandlers = new Set<ProcessHandler>()
+export type { ProcessHandler, ProcessType }
+export { getIsExiting }
 
 const colors = [
   '\x1b[36m', // cyan
@@ -105,7 +99,7 @@ export async function run(
         shell.unref()
       }
 
-      processHandlers.forEach((cb) => cb(shell))
+      notifyProcessHandlers(shell)
 
       if (timeout) {
         timeoutId = setTimeout(() => {
@@ -206,7 +200,7 @@ export async function run(
             ? `Command timed out after ${timeout}ms: ${command}`
             : `Command failed with exit code ${exitCode}: ${command}`
 
-        if (!silent && !isInExitCleanup) {
+        if (!silent && !getIsExiting()) {
           console.error(`run() error: ${errorMsg}: ${stderr || ''}`)
         }
 
@@ -218,14 +212,14 @@ export async function run(
       return { stdout, stderr, exitCode }
     } catch (error) {
       clearTimeout(timeoutId)
-      if (!silent && !isInExitCleanup) {
+      if (!silent && !getIsExiting()) {
         // only show the error message, not the full object if it's our error
         if (error instanceof Error && (error as any).cause?.exitCode !== undefined) {
           // this is our controlled error, already logged above
         } else {
           console.error(`Error running command: ${command}`, error)
         }
-      } else if (!silent && isInExitCleanup) {
+      } else if (!silent && getIsExiting()) {
         // simple message when being killed due to another error
         const shortCmd = command.split(' ')[0]
         console.error(`${shortCmd} exiting due to earlier error`)
@@ -235,10 +229,6 @@ export async function run(
   }
 }
 
-export const addProcessHandler = (cb: ProcessHandler) => {
-  processHandlers.add(cb)
-}
-
 export async function waitForRun(name: string) {
   if (running[name] === undefined) {
     throw new Error(`Can't wait before task runs: ${name}`)

package/src/release.ts

@@ -340,7 +340,7 @@ await cmd`publish takeout packages to npm`
 
         if (!skipTest) {
           await run(`bun lint`)
-          await run(`bun check:all`)
+          await run(`bun check`)
           // only in packages
           // await run(`bun test`)
         }

package/src/helpers/handleProcessExit.ts

@@ -1,171 +0,0 @@
-import {
-  addProcessHandler,
-  setExitCleanupState,
-  type ProcessHandler,
-  type ProcessType,
-} from './run'
-
-type ExitCallback = (info: { signal: NodeJS.Signals | string }) => void | Promise<void>
-
-interface HandleProcessExitReturn {
-  addChildProcess: ProcessHandler
-  cleanup: () => Promise<void>
-  exit: (code?: number) => Promise<void>
-}
-
-// kill an entire process group (works because children are spawned with detached: true,
-// which makes them process group leaders). negative pid = kill the whole group.
-// this is synchronous, no pgrep needed, no races.
-function killProcessGroup(
-  pid: number,
-  signal: NodeJS.Signals = 'SIGTERM',
-  forceful: boolean = false
-): void {
-  // kill the process group (negative pid)
-  try {
-    process.kill(-pid, signal)
-  } catch (_) {
-    // group may already be gone, try the individual process
-    try {
-      process.kill(pid, signal)
-    } catch (_) {
-      // process already gone
-    }
-  }
-
-  if (forceful && signal !== 'SIGKILL') {
-    // schedule a SIGKILL followup
-    setTimeout(() => {
-      try {
-        process.kill(-pid, 'SIGKILL')
-      } catch (_) {}
-      try {
-        process.kill(pid, 'SIGKILL')
-      } catch (_) {}
-    }, 100)
-  }
-}
-
-let isHandling = false
-
-export function handleProcessExit({
-  onExit,
-}: {
-  onExit?: ExitCallback
-} = {}): HandleProcessExitReturn {
-  if (isHandling) {
-    throw new Error(`Only one handleProcessExit per process should be registered!`)
-  }
-
-  isHandling = true
-  const processes: ProcessType[] = []
-  let cleanupPromise: Promise<void> | null = null
-
-  const cleanup = (signal: NodeJS.Signals | string = 'SIGTERM'): Promise<void> => {
-    // return existing cleanup promise if already running, so process.exit
-    // override waits for the real cleanup instead of exiting early
-    if (cleanupPromise) return cleanupPromise
-
-    cleanupPromise = doCleanup(signal)
-    return cleanupPromise
-  }
-
-  const doCleanup = async (signal: NodeJS.Signals | string) => {
-    setExitCleanupState(true)
-
-    if (onExit) {
-      try {
-        await onExit({ signal })
-      } catch (error) {
-        console.error('Error in exit callback:', error)
-      }
-    }
-
-    if (processes.length === 0) {
-      return
-    }
-
-    // kill process groups synchronously - no pgrep, no races
-    // detached: true makes each child a process group leader,
-    // so kill(-pid) gets the entire group in one syscall
-    const isInterrupt = signal === 'SIGINT'
-    const killSignal = isInterrupt ? 'SIGTERM' : (signal as NodeJS.Signals)
-
-    for (const proc of processes) {
-      if (proc.pid) {
-        killProcessGroup(proc.pid, killSignal, isInterrupt)
-      }
-    }
-
-    // brief wait for graceful shutdown
-    await new Promise((res) => setTimeout(res, isInterrupt ? 80 : 200))
-
-    // force kill any remaining
-    for (const proc of processes) {
-      if (proc.pid && !proc.exitCode) {
-        killProcessGroup(proc.pid, 'SIGKILL')
-      }
-    }
-  }
-
-  const addChildProcess = (proc: ProcessType) => {
-    processes.push(proc)
-  }
-
-  addProcessHandler(addChildProcess)
-
-  let finalized = false
-
-  const finalizeWithSignal = (signal: NodeJS.Signals, fallbackCode: number) => {
-    if (finalized) return
-    finalized = true
-    process.off('SIGINT', sigintHandler)
-    process.off('SIGTERM', sigtermHandler)
-    process.off('beforeExit', beforeExitHandler)
-    process.exit = originalExit
-
-    try {
-      process.kill(process.pid, signal)
-    } catch {
-      originalExit(fallbackCode)
-    }
-  }
-
-  const sigtermHandler = () => {
-    cleanup('SIGTERM').then(() => {
-      finalizeWithSignal('SIGTERM', 143)
-    })
-  }
-
-  const sigintHandler = () => {
-    cleanup('SIGINT').then(() => {
-      finalizeWithSignal('SIGINT', 130)
-    })
-  }
-
-  // intercept process.exit to ensure cleanup completes before exiting.
-  // if cleanup is already running, this awaits the SAME promise instead of
-  // early-returning and calling originalExit prematurely.
-  const originalExit = process.exit
-  process.exit = ((code?: number) => {
-    cleanup('SIGTERM').then(() => {
-      originalExit(code)
-    })
-  }) as typeof process.exit
-
-  const beforeExitHandler = () => cleanup('SIGTERM')
-  process.on('beforeExit', beforeExitHandler)
-  process.on('SIGINT', sigintHandler)
-  process.on('SIGTERM', sigtermHandler)
-
-  const exit = async (code: number = 0) => {
-    await cleanup('SIGTERM')
-    process.exit(code)
-  }
-
-  return {
-    addChildProcess,
-    cleanup,
-    exit,
-  }
-}

package/src/run-pty.mjs

@@ -1,413 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs'
-import { join, relative, resolve } from 'node:path'
-
-import pty from '@lydell/node-pty'
-
-const colors = [
-  '\x1b[38;5;81m',
-  '\x1b[38;5;209m',
-  '\x1b[38;5;156m',
-  '\x1b[38;5;183m',
-  '\x1b[38;5;222m',
-  '\x1b[38;5;117m',
-]
-const reset = '\x1b[0m'
-const dim = '\x1b[2m'
-
-const args = process.argv.slice(2)
-const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
-const runCommands = []
-const forwardArgs = []
-
-for (let i = 0; i < args.length; i++) {
-  const arg = args[i]
-  if (arg.startsWith('--')) {
-    if (ownFlags.includes(arg)) continue
-    forwardArgs.push(arg)
-    const nextArg = args[i + 1]
-    if (nextArg && !nextArg.startsWith('--')) {
-      forwardArgs.push(nextArg)
-      i++
-    }
-  } else {
-    runCommands.push(arg)
-  }
-}
-
-const noRoot = args.includes('--no-root')
-const runBun = args.includes('--bun')
-const flagsLast = args.includes('--flags=last')
-
-const processes = []
-let focusedIndex = -1 // -1 = interleaved/dashboard
-
-function getPrefix(index) {
-  const p = processes[index]
-  if (!p) return ''
-  const color = colors[index % colors.length]
-  return `${color}${p.shortcut}${reset}`
-}
-
-if (runCommands.length === 0) {
-  console.error('Usage: run-pty <script1> [script2] ...')
-  process.exit(1)
-}
-
-async function readPackageJson(dir) {
-  try {
-    return JSON.parse(await fs.promises.readFile(join(dir, 'package.json'), 'utf8'))
-  } catch {
-    return null
-  }
-}
-
-async function getWorkspacePatterns() {
-  const pkg = await readPackageJson('.')
-  if (!pkg?.workspaces) return []
-  return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || []
-}
-
-async function findPackageJsonDirs(base, depth = 3) {
-  if (depth <= 0) return []
-  const results = []
-  try {
-    if (
-      await fs.promises
-        .access(join(base, 'package.json'))
-        .then(() => true)
-        .catch(() => false)
-    ) {
-      results.push(base)
-    }
-    const entries = await fs.promises.readdir(base, { withFileTypes: true })
-    for (const e of entries) {
-      if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') {
-        results.push(...(await findPackageJsonDirs(join(base, e.name), depth - 1)))
-      }
-    }
-  } catch {}
-  return results
-}
-
-async function findWorkspaceScripts(scripts) {
-  const patterns = await getWorkspacePatterns()
-  if (!patterns.length) return new Map()
-  const dirs = await findPackageJsonDirs('.')
-  const result = new Map()
-  for (const dir of dirs) {
-    if (dir === '.') continue
-    const rel = relative('.', dir).replace(/\\/g, '/')
-    const matches = patterns.some((p) => {
-      const np = p.replace(/\\/g, '/').replace(/^\.\//, '')
-      return np.endsWith('/*')
-        ? rel.startsWith(np.slice(0, -1))
-        : rel === np || rel.startsWith(np + '/')
-    })
-    if (!matches) continue
-    const pkg = await readPackageJson(dir)
-    if (!pkg?.scripts) continue
-    const available = scripts.filter((s) => typeof pkg.scripts[s] === 'string')
-    if (available.length) result.set(dir, { scripts: available, name: pkg.name || dir })
-  }
-  return result
-}
-
-function spawnScript(name, cwd, label, extraArgs, index) {
-  const runArgs = ['run', '--silent', runBun ? '--bun' : '', name, ...extraArgs].filter(
-    Boolean
-  )
-  const terminal = pty.spawn('bun', runArgs, {
-    cwd: resolve(cwd),
-    cols: process.stdout.columns || 80,
-    rows: process.stdout.rows || 24,
-    env: { ...process.env, FORCE_COLOR: '3' },
-  })
-
-  const idx = index ?? processes.length
-  const managed = {
-    terminal,
-    name,
-    cwd,
-    label,
-    extraArgs,
-    index: idx,
-    shortcut: '',
-    killed: false,
-  }
-
-  if (index !== undefined) processes[index] = managed
-  else processes.push(managed)
-
-  terminal.onData((data) => {
-    if (focusedIndex === -1) {
-      // interleaved - prefix each line, skip bun's $ command echo
-      const lines = data.split(/\r?\n/)
-      for (const line of lines) {
-        if (!line) continue
-        // eslint-disable-next-line no-control-regex
-        const stripped = line.replace(/\x1b\[[0-9;]*m/g, '')
-        if (stripped.startsWith('$ ')) continue
-        process.stdout.write(`${getPrefix(idx)} ${line}\n`)
-      }
-    } else if (focusedIndex === idx) {
-      // focused - raw output
-      process.stdout.write(data)
-    }
-  })
-
-  terminal.onExit(({ exitCode }) => {
-    if (managed.killed) return
-    if (focusedIndex === idx) {
-      focusedIndex = -1
-      showDashboard()
-    }
-    if (exitCode !== 0) {
-      console.error(`${getPrefix(idx)} exited ${exitCode}`)
-    }
-  })
-
-  return managed
-}
-
-function computeShortcuts() {
-  // use last word of label
-  for (let i = 0; i < processes.length; i++) {
-    const p = processes[i]
-    const words = p.label
-      .toLowerCase()
-      .split(/[^a-z]+/)
-      .filter(Boolean)
-    const lastWord = words[words.length - 1] || words[0] || String(i)
-
-    // find unique shortcut
-    let shortcut = lastWord[0]
-    let len = 1
-    while (
-      processes.slice(0, i).some((q) => q.shortcut === shortcut) &&
-      len < lastWord.length
-    ) {
-      len++
-      shortcut = lastWord.slice(0, len)
-    }
-    p.shortcut = shortcut
-  }
-}
-
-function showDashboard() {
-  const tabs = processes
-    .map((p, i) => {
-      const color = colors[i % colors.length]
-      return `${color}[${p.shortcut}]${reset} ${p.label.split(' ').pop()}${p.killed ? dim + ' ✗' + reset : ''}`
-    })
-    .join('  ')
-  console.log(`\n${tabs}`)
-  console.log(
-    `${dim}press shortcut to focus, r+shortcut restart, k+shortcut kill, ctrl+c exit${reset}\n`
-  )
-}
-
-let pendingAction = null // 'r' or 'k'
-
-function handleInput(data) {
-  const str = data.toString()
-
-  // ctrl+c exit
-  if (str === '\x03') {
-    cleanup()
-    return
-  }
-
-  // ctrl+z toggle focus
-  if (str === '\x1a') {
-    if (focusedIndex >= 0) {
-      focusedIndex = -1
-      showDashboard()
-    } else {
-      showDashboard()
-    }
-    return
-  }
-
-  // if focused, forward to process
-  if (focusedIndex >= 0) {
-    const p = processes[focusedIndex]
-    if (p && !p.killed) {
-      p.terminal.write(str)
-    }
-    return
-  }
-
-  // dashboard mode
-  if (str === 'r') {
-    pendingAction = 'restart'
-    process.stdout.write(`${dim}restart which? ${reset}`)
-    return
-  }
-  if (str === 'k') {
-    pendingAction = 'kill'
-    process.stdout.write(`${dim}kill which? ${reset}`)
-    return
-  }
-
-  // check for shortcut match
-  const match = processes.find((p) => p.shortcut === str.toLowerCase())
-  if (match) {
-    if (pendingAction === 'restart') {
-      pendingAction = null
-      console.log(match.shortcut)
-      match.killed = true
-      killProcessTree(match.terminal.pid)
-      setTimeout(() => {
-        spawnScript(match.name, match.cwd, match.label, match.extraArgs, match.index)
-        console.log(`${getPrefix(match.index)} restarted`)
-      }, 100)
-    } else if (pendingAction === 'kill') {
-      pendingAction = null
-      console.log(match.shortcut)
-      if (!match.killed) {
-        match.killed = true
-        killProcessTree(match.terminal.pid)
-        console.log(`${getPrefix(match.index)} killed`)
-      }
-    } else {
-      // focus
-      focusedIndex = match.index
-      console.log(`${dim}focused: ${match.label} (ctrl+z to unfocus)${reset}\n`)
-    }
-    return
-  }
-
-  // escape cancels pending
-  if (str === '\x1b' && pendingAction) {
-    pendingAction = null
-    console.log('cancelled')
-  }
-}
-
-// kill entire process group to prevent orphans
-function killProcessTree(pid) {
-  if (!pid) return
-  // try killing process group first (negative pid)
-  try {
-    process.kill(-pid, 'SIGTERM')
-  } catch {}
-  // also kill direct process
-  try {
-    process.kill(pid, 'SIGTERM')
-  } catch {}
-  // schedule force kill
-  setTimeout(() => {
-    try {
-      process.kill(-pid, 'SIGKILL')
-    } catch {}
-    try {
-      process.kill(pid, 'SIGKILL')
-    } catch {}
-  }, 100)
-}
-
-function cleanup() {
-  // restore terminal to cooked mode before exiting
-  if (process.stdin.isTTY && process.stdin.setRawMode) {
-    try {
-      process.stdin.setRawMode(false)
-    } catch {}
-  }
-  // reset terminal attributes (colors, etc)
-  process.stdout.write('\x1b[0m\n')
-
-  for (const p of processes) {
-    if (!p.killed) {
-      p.killed = true
-      killProcessTree(p.terminal.pid)
-    }
-  }
-
-  // wait for kills to complete before exit
-  setTimeout(() => process.exit(0), 150)
-}
-
-async function main() {
-  const lastScript = runCommands[runCommands.length - 1]
-
-  if (!noRoot) {
-    const pkg = await readPackageJson('.')
-    if (pkg?.scripts) {
-      for (const name of runCommands) {
-        if (typeof pkg.scripts[name] === 'string') {
-          spawnScript(
-            name,
-            '.',
-            name,
-            !flagsLast || name === lastScript ? forwardArgs : []
-          )
-        }
-      }
-    }
-  }
-
-  const wsScripts = await findWorkspaceScripts(runCommands)
-  for (const [dir, { scripts, name }] of wsScripts) {
-    for (const script of scripts) {
-      spawnScript(
-        script,
-        dir,
-        `${name} ${script}`,
-        !flagsLast || script === lastScript ? forwardArgs : []
-      )
-    }
-  }
-
-  if (processes.length === 0) {
-    console.error('No scripts found')
-    process.exit(1)
-  }
-
-  computeShortcuts()
-  showDashboard()
-
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true)
-    process.stdin.resume()
-    process.stdin.on('data', handleInput)
-  }
-
-  process.stdout.on('resize', () => {
-    for (const p of processes) {
-      if (!p.killed) {
-        try {
-          p.terminal.resize(process.stdout.columns || 80, process.stdout.rows || 24)
-        } catch {
-          // pty already closed
-        }
-      }
-    }
-  })
-
-  process.on('SIGINT', cleanup)
-  process.on('SIGTERM', cleanup)
-}
-
-// restore terminal on any unexpected exit
-function restoreTerminal() {
-  if (process.stdin.isTTY && process.stdin.setRawMode) {
-    try {
-      process.stdin.setRawMode(false)
-    } catch {}
-  }
-  process.stdout.write('\x1b[0m')
-}
-
-process.on('uncaughtException', (e) => {
-  restoreTerminal()
-  console.error(e)
-  process.exit(1)
-})
-
-main().catch((e) => {
-  restoreTerminal()
-  console.error(e)
-  process.exit(1)
-})

package/src/run.ts

@@ -1,411 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * @description Run multiple scripts in parallel
- */
-
-import { spawn } from 'node:child_process'
-import fs from 'node:fs'
-import { join, relative, resolve } from 'node:path'
-
-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 args = process.argv.slice(2)
-const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
-const runCommands: string[] = []
-const forwardArgs: string[] = []
-
-for (let i = 0; i < args.length; i++) {
-  const arg = args[i]!
-
-  if (arg.startsWith('--')) {
-    if (ownFlags.includes(arg)) continue
-    forwardArgs.push(arg)
-    const nextArg = args[i + 1]
-    if (nextArg && !nextArg.startsWith('--')) {
-      forwardArgs.push(nextArg)
-      i++
-    }
-  } else {
-    runCommands.push(arg)
-  }
-}
-
-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)
-}
-
-async function readPackageJson(directoryPath: string) {
-  try {
-    const packageJsonPath = join(directoryPath, 'package.json')
-    const content = await fs.promises.readFile(packageJsonPath, 'utf8')
-    return JSON.parse(content)
-  } catch {
-    return null
-  }
-}
-
-async function getWorkspacePatterns(): Promise<string[]> {
-  try {
-    const packageJson = await readPackageJson('.')
-    if (!packageJson || !packageJson.workspaces) return []
-
-    return Array.isArray(packageJson.workspaces)
-      ? packageJson.workspaces
-      : packageJson.workspaces.packages || []
-  } catch {
-    return []
-  }
-}
-
-async function hasPackageJson(path: string): Promise<boolean> {
-  try {
-    await fs.promises.access(join(path, 'package.json'))
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function findPackageJsonDirs(basePath: string, maxDepth = 3): Promise<string[]> {
-  if (maxDepth <= 0) return []
-
-  try {
-    const entries = await fs.promises.readdir(basePath, { withFileTypes: true })
-    const results: string[] = []
-
-    if (await hasPackageJson(basePath)) {
-      results.push(basePath)
-    }
-
-    const subDirPromises = entries
-      .filter(
-        (entry) =>
-          entry.isDirectory() &&
-          !entry.name.startsWith('.') &&
-          entry.name !== 'node_modules'
-      )
-      .map(async (dir) => {
-        const path = join(basePath, dir.name)
-        return findPackageJsonDirs(path, maxDepth - 1)
-      })
-
-    const subdirResults = await Promise.all(subDirPromises)
-    return [...results, ...subdirResults.flat()]
-  } catch {
-    return []
-  }
-}
-
-async function findWorkspaceDirectories(): Promise<string[]> {
-  const patterns = await getWorkspacePatterns()
-  if (!patterns.length) return []
-
-  const allPackageDirs = await findPackageJsonDirs('.')
-
-  const normalizePath = (path: string): string => {
-    const normalized = path.replace(/\\/g, '/')
-    return normalized.startsWith('./') ? normalized.substring(2) : normalized
-  }
-
-  return allPackageDirs.filter((dir) => {
-    if (dir === '.') return false
-
-    const relativePath = relative('.', dir)
-    return patterns.some((pattern) => {
-      const normalizedPattern = normalizePath(pattern)
-      const normalizedPath = normalizePath(relativePath)
-
-      if (normalizedPattern.endsWith('/*')) {
-        const prefix = normalizedPattern.slice(0, -1)
-        return normalizedPath.startsWith(prefix)
-      }
-      return (
-        normalizedPath === normalizedPattern ||
-        normalizedPath.startsWith(normalizedPattern + '/')
-      )
-    })
-  })
-}
-
-async function findAvailableScripts(
-  directoryPath: string,
-  scriptNames: string[]
-): Promise<string[]> {
-  const packageJson = await readPackageJson(directoryPath)
-
-  if (!packageJson || !packageJson.scripts) {
-    return []
-  }
-
-  return scriptNames.filter(
-    (scriptName) => typeof packageJson.scripts?.[scriptName] === 'string'
-  )
-}
-
-async function mapWorkspacesToScripts(
-  scriptNames: string[]
-): Promise<Map<string, { scripts: string[]; packageName: string }>> {
-  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,
-      })
-    }
-  }
-
-  return workspaceScriptMap
-}
-
-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
-  )
-
-  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),
-  })
-
-  const managed: ManagedProcess = {
-    proc,
-    name,
-    cwd,
-    prefixLabel,
-    extraArgs,
-    index,
-    shortcut: '',
-  }
-
-  if (managedIndex !== undefined) {
-    managedProcesses[managedIndex] = managed
-  } else {
-    managedProcesses.push(managed)
-  }
-
-  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.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.on('error', (error) => {
-    console.error(`${getPrefix(index)} Failed to start: ${error.message}`)
-  })
-
-  proc.on('close', (code) => {
-    if (getIsExiting()) return
-
-    if (code && code !== 0) {
-      console.error(`${getPrefix(index)} Process exited with code ${code}`)
-
-      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)
-      }
-    }
-  })
-
-  return proc
-}
-
-function computeShortcuts() {
-  const initials = managedProcesses.map((p) => {
-    const words = p.prefixLabel
-      .toLowerCase()
-      .split(/[^a-z]+/)
-      .filter(Boolean)
-    return words.map((w) => w[0]).join('')
-  })
-
-  const lengths = new Array(managedProcesses.length).fill(1) as number[]
-
-  for (let round = 0; round < 5; round++) {
-    const shortcuts = initials.map((init, i) => init.slice(0, lengths[i]) || init)
-
-    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)
-    }
-
-    for (const [, indices] of groups) {
-      if (indices.length <= 1) continue
-      hasCollision = true
-      for (const idx of indices) {
-        lengths[idx]!++
-      }
-    }
-
-    if (!hasCollision) {
-      for (let i = 0; i < managedProcesses.length; i++) {
-        managedProcesses[i]!.shortcut = shortcuts[i]!
-      }
-      return
-    }
-  }
-
-  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)
-  })
-
-  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)
-  }
-}
-
-main().catch((error) => {
-  console.error(`Error running scripts: ${error}`)
-  exit(1)
-})