@take-out/scripts 0.1.38-1772433507984 → 0.1.38-1772439111798

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.38-1772433507984",
+  "version": "0.1.38-1772439111798",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -20,7 +20,6 @@
     }
   },
   "scripts": {
-    "postinstall": "cd src/run-group && (clang -O2 -o run-group run-group.c 2>/dev/null || gcc -O2 -o run-group run-group.c 2>/dev/null || true)",
     "lint": "oxlint src",
     "lint:fix": "oxfmt src && oxlint --fix --fix-suggestions src",
     "typecheck": "tko run typecheck"
@@ -31,7 +30,7 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "@lydell/node-pty": "^1.2.0-beta.3",
-    "@take-out/helpers": "0.1.38-1772433507984",
+    "@take-out/helpers": "0.1.38-1772439111798",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/helpers/run.ts

@@ -1,39 +1,8 @@
 import { spawn, type ChildProcess } from 'node:child_process'
-import { existsSync } from 'node:fs'
 import { cpus } from 'node:os'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 
 import type { Timer } from '@take-out/helpers'
 
-// find run-group binary for proper process group management
-let _runGroupBin: string | null | undefined
-function findRunGroupBinary(): string | null {
-  if (_runGroupBin !== undefined) return _runGroupBin
-
-  // check relative to this file (in packages/scripts/bin/)
-  try {
-    const __dirname = dirname(fileURLToPath(import.meta.url))
-    const localBin = resolve(__dirname, '..', 'bin', 'run-group')
-    if (existsSync(localBin)) {
-      _runGroupBin = localBin
-      return _runGroupBin
-    }
-  } catch {}
-
-  // check in node_modules
-  try {
-    const nmBin = resolve(process.cwd(), 'node_modules', '@take-out', 'scripts', 'bin', 'run-group')
-    if (existsSync(nmBin)) {
-      _runGroupBin = nmBin
-      return _runGroupBin
-    }
-  } catch {}
-
-  _runGroupBin = null
-  return null
-}
-
 export type ProcessType = ChildProcess
 export type ProcessHandler = (process: ProcessType) => void
 
@@ -50,39 +19,6 @@ export function getIsExiting() {
 
 const processHandlers = new Set<ProcessHandler>()
 
-// track all spawned child processes for cleanup on exit
-const activeProcesses = new Set<ChildProcess>()
-
-// install cleanup handlers once
-let cleanupInstalled = false
-function installCleanupHandlers() {
-  if (cleanupInstalled) return
-  cleanupInstalled = true
-
-  const cleanup = () => {
-    for (const proc of activeProcesses) {
-      try {
-        // kill the process group to ensure child processes are also killed
-        if (proc.pid) {
-          process.kill(-proc.pid, 'SIGTERM')
-        }
-      } catch {
-        // process may already be dead
-      }
-    }
-  }
-
-  process.on('exit', cleanup)
-  process.on('SIGINT', () => {
-    cleanup()
-    process.exit(130)
-  })
-  process.on('SIGTERM', () => {
-    cleanup()
-    process.exit(143)
-  })
-}
-
 const colors = [
   '\x1b[36m', // cyan
   '\x1b[35m', // magenta
@@ -157,22 +93,13 @@ export async function run(
     let timeoutId: Timer | undefined
     let didTimeOut = false
 
-    // find run-group binary (handles process group cleanup properly)
-    const runGroupBin = findRunGroupBinary()
-
     try {
-      // use run-group to wrap the command - it handles process groups and cleanup
-      const shell = runGroupBin
-        ? spawn(runGroupBin, ['bash', '-c', command], {
-            env: { ...process.env, ...env },
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-          })
-        : spawn('bash', ['-c', command], {
-            env: { ...process.env, ...env },
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-          })
+      const shell = spawn('bash', ['-c', command], {
+        env: { ...process.env, ...env },
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: detached ?? false,
+      })
 
       if (detached) {
         shell.unref()

package/src/run-pty.mjs

@@ -258,7 +258,7 @@ function handleInput(data) {
       pendingAction = null
       console.log(match.shortcut)
       match.killed = true
-      match.terminal.kill()
+      killProcessTree(match.terminal.pid)
       setTimeout(() => {
         spawnScript(match.name, match.cwd, match.label, match.extraArgs, match.index)
         console.log(`${getPrefix(match.index)} restarted`)
@@ -268,7 +268,7 @@ function handleInput(data) {
       console.log(match.shortcut)
       if (!match.killed) {
         match.killed = true
-        match.terminal.kill()
+        killProcessTree(match.terminal.pid)
         console.log(`${getPrefix(match.index)} killed`)
       }
     } else {
@@ -286,6 +286,24 @@ function handleInput(data) {
   }
 }
 
+// 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) {
@@ -299,10 +317,12 @@ function cleanup() {
   for (const p of processes) {
     if (!p.killed) {
       p.killed = true
-      p.terminal.kill()
+      killProcessTree(p.terminal.pid)
     }
   }
-  process.exit(0)
+
+  // wait for kills to complete before exit
+  setTimeout(() => process.exit(0), 150)
 }
 
 async function main() {

package/src/run.ts

@@ -1,14 +1,32 @@
 #!/usr/bin/env bun
 
 /**
- * @description Run multiple scripts in parallel using run-group for proper process management
+ * @description Run multiple scripts in parallel
  */
 
+import { spawn } from 'node:child_process'
 import fs from 'node:fs'
-import { dirname, join, relative, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { join, relative, resolve } from 'node:path'
 
-const __dirname = dirname(fileURLToPath(import.meta.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 args = process.argv.slice(2)
 const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
@@ -32,22 +50,40 @@ 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(',')
   : []
 
-if (runCommands.length === 0) {
-  console.error('Please provide at least one script name to run')
-  process.exit(1)
-}
-
-interface ResolvedCommand {
+interface ManagedProcess {
+  proc: ReturnType<typeof spawn>
   name: string
-  command: string
   cwd: string
-  args: 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) {
@@ -143,15 +179,6 @@ 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[]
@@ -167,180 +194,218 @@ async function findAvailableScripts(
   )
 }
 
-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
+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, 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,
-        })
-      }
+    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 commands
+  return workspaceScriptMap
 }
 
-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 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
+  )
 
-  // check installed package
-  const installedPath = join(__dirname, '..', 'run-group', 'run-group')
-  if (fs.existsSync(installedPath)) return installedPath
+  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),
+  })
 
-  return null
-}
+  const managed: ManagedProcess = {
+    proc,
+    name,
+    cwd,
+    prefixLabel,
+    extraArgs,
+    index,
+    shortcut: '',
+  }
 
-// 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(','),
-      },
-    })
+  if (managedIndex !== undefined) {
+    managedProcesses[managedIndex] = managed
+  } else {
+    managedProcesses.push(managed)
+  }
 
-    addChildProcess(proc)
+  addChildProcess(proc)
 
-    proc.stdout?.on('data', (data) => {
-      for (const line of data.toString().split('\n')) {
-        if (line) console.log(`${prefix} ${line}`)
-      }
-    })
+  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) => {
-      for (const line of data.toString().split('\n')) {
-        if (line) console.error(`${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}`)
+    }
+  })
 
-    return new Promise<number>((resolve) => {
-      proc.on('close', (code) => resolve(code || 0))
-    })
+  proc.on('error', (error) => {
+    console.error(`${getPrefix(index)} Failed to start: ${error.message}`)
   })
 
-  const codes = await Promise.all(procs)
-  exitCode = Math.max(...codes)
-  process.exit(exitCode)
-}
+  proc.on('close', (code) => {
+    if (getIsExiting()) return
 
-async function main() {
-  const commands = await resolveAllCommands()
+    if (code && code !== 0) {
+      console.error(`${getPrefix(index)} Process exited with code ${code}`)
 
-  if (commands.length === 0) {
-    console.error('No matching scripts found')
-    process.exit(0)
-  }
+      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)
+      }
+    }
+  })
 
-  const runGroupPath = findRunGroup()
+  return proc
+}
 
-  // fallback to node if binary not available
-  if (!runGroupPath) {
-    return runWithNodeFallback(commands)
-  }
+function computeShortcuts() {
+  const initials = managedProcesses.map((p) => {
+    const words = p.prefixLabel
+      .toLowerCase()
+      .split(/[^a-z]+/)
+      .filter(Boolean)
+    return words.map((w) => w[0]).join('')
+  })
 
-  // build run-group command
-  // format: run-group -p -t @name <cmd1> --- @name2 <cmd2> --- ...
-  const runGroupArgs: string[] = ['-p', '-t']
+  const lengths = new Array(managedProcesses.length).fill(1) as number[]
 
-  for (let i = 0; i < commands.length; i++) {
-    const cmd = commands[i]!
-    const fullCwd = resolve(cmd.cwd)
+  for (let round = 0; round < 5; round++) {
+    const shortcuts = initials.map((init, i) => init.slice(0, lengths[i]) || init)
 
-    // 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
+    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)
+    }
 
-    // use @name prefix for display name in parallel mode
-    runGroupArgs.push(`@${cmd.name}`)
-    runGroupArgs.push('sh', '-c', `cd "${fullCwd}" && ${envSetup} ${fullCommand}`)
+    for (const [, indices] of groups) {
+      if (indices.length <= 1) continue
+      hasCollision = true
+      for (const idx of indices) {
+        lengths[idx]!++
+      }
+    }
 
-    if (i < commands.length - 1) {
-      runGroupArgs.push('---')
+    if (!hasCollision) {
+      for (let i = 0; i < managedProcesses.length; i++) {
+        managedProcesses[i]!.shortcut = shortcuts[i]!
+      }
+      return
     }
   }
 
-  // exec run-group (replaces this process)
-  const { execFileSync } = await import('node:child_process')
+  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 {
-    execFileSync(runGroupPath, runGroupArgs, {
-      stdio: 'inherit',
-      env: process.env,
-    })
-  } catch (error: any) {
-    process.exit(error.status || 1)
+    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}`)
-  process.exit(1)
+  exit(1)
 })

package/src/run-group/build.zig

@@ -1,24 +0,0 @@
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-
-    const exe = b.addExecutable(.{
-        .name = "run-group",
-        .root_source_file = b.path("main.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
-    b.installArtifact(exe);
-
-    const run_cmd = b.addRunArtifact(exe);
-    run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
-        run_cmd.addArgs(args);
-    }
-
-    const run_step = b.step("run", "Run the app");
-    run_step.dependOn(&run_cmd.step);
-}