@take-out/scripts 0.1.39-1772740363029 → 0.1.40

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.39-1772740363029",
+  "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-1772740363029",
+    "@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,237 +0,0 @@
-import { execSync } from 'node:child_process'
-import { appendFileSync, rmSync } from 'node:fs'
-
-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>
-}
-
-const pidFilePath = `/tmp/tko-run-${process.pid}.pids`
-
-function writePidFile(pid: number) {
-  try {
-    appendFileSync(pidFilePath, `${pid}\n`)
-  } catch {}
-}
-
-function removePidFile() {
-  try {
-    rmSync(pidFilePath, { force: true })
-  } catch {}
-}
-
-// find descendant pids that survived the group kill
-function findStragglers(trackedPids: number[]): number[] {
-  try {
-    const output = execSync('ps -eo pid,ppid', { encoding: 'utf-8', timeout: 2000 })
-    const lines = output.trim().split('\n').slice(1) // skip header
-
-    const parentToChildren = new Map<number, number[]>()
-    for (const line of lines) {
-      const parts = line.trim().split(/\s+/)
-      if (parts.length < 2) continue
-      const pid = parseInt(parts[0]!, 10)
-      const ppid = parseInt(parts[1]!, 10)
-      if (isNaN(pid) || isNaN(ppid)) continue
-      if (!parentToChildren.has(ppid)) parentToChildren.set(ppid, [])
-      parentToChildren.get(ppid)!.push(pid)
-    }
-
-    // walk from each tracked pid to find all descendants
-    const descendants = new Set<number>()
-    const queue = [...trackedPids]
-    while (queue.length > 0) {
-      const current = queue.pop()!
-      const children = parentToChildren.get(current)
-      if (!children) continue
-      for (const child of children) {
-        if (!descendants.has(child)) {
-          descendants.add(child)
-          queue.push(child)
-        }
-      }
-    }
-    return [...descendants]
-  } catch {
-    return []
-  }
-}
-
-// kill entire process group to prevent orphaned descendants
-function killProcess(
-  pid: number,
-  signal: NodeJS.Signals = 'SIGTERM',
-  forceful: boolean = false
-): void {
-  // kill process group first (negative pid), then direct process
-  try {
-    process.kill(-pid, signal)
-  } catch (_) {}
-  try {
-    process.kill(pid, signal)
-  } catch (_) {}
-
-  if (forceful && signal !== 'SIGKILL') {
-    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
-    }
-
-    const isInterrupt = signal === 'SIGINT'
-    const killSignal = isInterrupt ? 'SIGTERM' : (signal as NodeJS.Signals)
-
-    for (const proc of processes) {
-      if (proc.pid) {
-        killProcess(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) {
-        killProcess(proc.pid, 'SIGKILL')
-      }
-    }
-
-    // straggler walk: find any descendants that survived the group kill
-    const trackedPids = processes.map((p) => p.pid).filter(Boolean) as number[]
-    if (trackedPids.length > 0) {
-      const stragglers = findStragglers(trackedPids)
-      for (const pid of stragglers) {
-        try {
-          process.kill(pid, 'SIGKILL')
-        } catch {}
-      }
-    }
-
-    removePidFile()
-  }
-
-  const addChildProcess = (proc: ProcessType) => {
-    processes.push(proc)
-    if (proc.pid) writePidFile(proc.pid)
-  }
-
-  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('SIGHUP', sighupHandler)
-    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)
-    })
-  }
-
-  const sighupHandler = () => {
-    cleanup('SIGHUP').then(() => {
-      finalizeWithSignal('SIGHUP', 129)
-    })
-  }
-
-  // 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)
-  process.on('SIGHUP', sighupHandler)
-
-  const exit = async (code: number = 0) => {
-    await cleanup('SIGTERM')
-    process.exit(code)
-  }
-
-  return {
-    addChildProcess,
-    cleanup,
-    exit,
-  }
-}

package/src/helpers/process-cleanup.test.ts

@@ -1,141 +0,0 @@
-import { spawn } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { afterAll, afterEach, describe, expect, it } from 'vitest'
-
-function isAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function waitForDead(pid: number, timeoutMs = 3000): Promise<boolean> {
-  const start = Date.now()
-  while (Date.now() - start < timeoutMs) {
-    if (!isAlive(pid)) return true
-    await new Promise((r) => setTimeout(r, 50))
-  }
-  return false
-}
-
-async function waitForFile(path: string, timeoutMs = 3000): Promise<boolean> {
-  const start = Date.now()
-  while (Date.now() - start < timeoutMs) {
-    if (existsSync(path)) return true
-    await new Promise((r) => setTimeout(r, 50))
-  }
-  return false
-}
-
-describe('process cleanup', () => {
-  const tmpDir = mkdtempSync(join(tmpdir(), 'tko-test-'))
-  const pids: number[] = []
-
-  afterEach(() => {
-    for (const pid of pids) {
-      try {
-        process.kill(-pid, 'SIGKILL')
-      } catch {}
-      try {
-        process.kill(pid, 'SIGKILL')
-      } catch {}
-    }
-    pids.length = 0
-  })
-
-  afterAll(() => {
-    try {
-      rmSync(tmpDir, { recursive: true, force: true })
-    } catch {}
-  })
-
-  it('detached child gets its own process group', async () => {
-    const pidFile = join(tmpDir, 'child1.pid')
-    const child = spawn('bash', ['-c', `echo $$ > ${pidFile}; sleep 999`], {
-      detached: true,
-      stdio: 'ignore',
-    })
-    pids.push(child.pid!)
-    child.unref()
-
-    expect(await waitForFile(pidFile)).toBe(true)
-    const childPid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10)
-
-    expect(isAlive(childPid)).toBe(true)
-
-    // killing the process group should kill it
-    try {
-      process.kill(-child.pid!, 'SIGKILL')
-    } catch {}
-    expect(await waitForDead(childPid)).toBe(true)
-  })
-
-  it('process group kill reaches grandchildren', async () => {
-    const grandchildPidFile = join(tmpDir, 'grandchild.pid')
-    // write a helper script so escaping is clean
-    const helperScript = join(tmpDir, 'grandchild-helper.sh')
-    writeFileSync(
-      helperScript,
-      `#!/bin/bash\necho $$ > ${grandchildPidFile}\nsleep 999\n`,
-      { mode: 0o755 }
-    )
-
-    const parent = spawn('bash', ['-c', `bash ${helperScript} & wait`], {
-      detached: true,
-      stdio: 'ignore',
-    })
-    pids.push(parent.pid!)
-
-    expect(await waitForFile(grandchildPidFile)).toBe(true)
-    const grandchildPid = parseInt(readFileSync(grandchildPidFile, 'utf-8').trim(), 10)
-    pids.push(grandchildPid)
-
-    expect(isAlive(grandchildPid)).toBe(true)
-
-    // kill the process group — grandchild should die too
-    try {
-      process.kill(-parent.pid!, 'SIGKILL')
-    } catch {}
-    expect(await waitForDead(grandchildPid)).toBe(true)
-  })
-
-  it('SIGTERM on parent with trap kills children', async () => {
-    const childPidFile = join(tmpDir, 'term-child.pid')
-    const wrapperScript = join(tmpDir, 'wrapper.sh')
-    writeFileSync(
-      wrapperScript,
-      [
-        '#!/bin/bash',
-        'cleanup() { kill 0; exit 0; }',
-        'trap cleanup SIGTERM',
-        `bash -c 'echo $$ > ${childPidFile}; sleep 999' &`,
-        'wait',
-        '',
-      ].join('\n'),
-      { mode: 0o755 }
-    )
-
-    const parent = spawn('bash', [wrapperScript], {
-      detached: true,
-      stdio: 'ignore',
-    })
-    pids.push(parent.pid!)
-
-    expect(await waitForFile(childPidFile)).toBe(true)
-    const childPid = parseInt(readFileSync(childPidFile, 'utf-8').trim(), 10)
-    pids.push(childPid)
-
-    expect(isAlive(childPid)).toBe(true)
-
-    // send SIGTERM to the process group
-    try {
-      process.kill(-parent.pid!, 'SIGTERM')
-    } catch {}
-    expect(await waitForDead(childPid, 5000)).toBe(true)
-  })
-})