@take-out/scripts 0.0.28

package/src/helpers/handleProcessExit.ts

@@ -0,0 +1,254 @@
+import type { ChildProcess } from 'node:child_process'
+import { spawn } from 'node:child_process'
+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>
+}
+
+async function getChildPids(parentPid: number): Promise<number[]> {
+  try {
+    const proc = spawn('pgrep', ['-P', parentPid.toString()], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    return new Promise((resolve) => {
+      let output = ''
+      proc.stdout?.on('data', (data) => {
+        output += data.toString()
+      })
+
+      proc.on('close', () => {
+        const childPids = output.trim().split('\n').filter(Boolean).map(Number)
+        resolve(childPids)
+      })
+    })
+  } catch (error) {
+    console.error(`Error getting child PIDs for ${parentPid}: ${error}`)
+    return []
+  }
+}
+
+async function getAllDescendantPids(parentPid: number): Promise<number[]> {
+  const childPids = await getChildPids(parentPid)
+  const descendantPids = [...childPids]
+
+  for (const childPid of childPids) {
+    const grandchildren = await getAllDescendantPids(childPid)
+    descendantPids.push(...grandchildren)
+  }
+
+  return descendantPids
+}
+
+async function killProcessTree(
+  pid: number,
+  signal: NodeJS.Signals = 'SIGTERM',
+  forceful: boolean = false
+): Promise<void> {
+  try {
+    const descendants = await getAllDescendantPids(pid)
+
+    // first send the requested signal
+    for (const descendantPid of descendants.reverse()) {
+      try {
+        process.kill(descendantPid, signal)
+      } catch (_) {
+        // process may already be gone
+      }
+    }
+
+    if (pid && !Number.isNaN(pid)) {
+      try {
+        process.kill(pid, signal)
+      } catch (_) {
+        // process may already be gone
+      }
+    }
+
+    // if forceful, wait briefly then send SIGKILL
+    if (forceful && signal !== 'SIGKILL') {
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      // send SIGKILL to any still-alive processes
+      for (const descendantPid of descendants.reverse()) {
+        try {
+          process.kill(descendantPid, 'SIGKILL')
+        } catch (_) {
+          // process may already be gone
+        }
+      }
+
+      if (pid && !Number.isNaN(pid)) {
+        try {
+          process.kill(pid, 'SIGKILL')
+        } catch (_) {
+          // process may already be gone
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error killing process tree for ${pid}: ${error}`)
+  }
+}
+
+function isChildProcess(proc: ProcessType): proc is ChildProcess {
+  return 'killed' in proc && typeof (proc as any).on === 'function'
+}
+
+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[] = []
+  const allChildPids = new Set<number>()
+  let cleaning = false
+
+  const cleanup = async (signal: NodeJS.Signals | string = 'SIGTERM') => {
+    if (cleaning) return
+    cleaning = true
+
+    // notify run.ts that we're in cleanup state
+    setExitCleanupState(true)
+
+    // suppress console output during cleanup for cleaner exit
+    if (signal === 'SIGINT') {
+      const noop = () => {}
+      console.log = noop
+      console.info = noop
+      console.warn = noop
+      // keep console.error for critical errors only
+    }
+
+    // wrap entire cleanup in a timeout to prevent hanging
+    if (onExit) {
+      try {
+        await onExit({ signal })
+      } catch (error) {
+        console.error('Error in exit callback:', error)
+      }
+    }
+
+    // skip cleanup if no processes to clean up
+    if (processes.length === 0) {
+      return
+    }
+
+    // for SIGINT (Ctrl+C), be more aggressive with cleanup
+    const isInterrupt = signal === 'SIGINT'
+    const killSignal = isInterrupt ? 'SIGTERM' : (signal as NodeJS.Signals)
+
+    await Promise.all(
+      processes.map(async (proc) => {
+        if (proc.pid) {
+          try {
+            await killProcessTree(proc.pid, killSignal, isInterrupt)
+          } catch (error) {
+            console.error(
+              `Error during graceful shutdown of process ${proc.pid}: ${error}`
+            )
+          }
+        }
+      })
+    )
+
+    // shorter wait for SIGINT
+    await new Promise((res) => setTimeout(res, isInterrupt ? 50 : 200))
+
+    // force kill any remaining processes
+    for (const proc of processes) {
+      try {
+        if (!proc.exitCode && proc.pid) {
+          await killProcessTree(proc.pid, 'SIGKILL', true)
+        }
+      } catch (err) {
+        // process already gone
+      }
+    }
+  }
+
+  const addChildProcess = (proc: ProcessType) => {
+    processes.push(proc)
+
+    // track pid if available
+    const pid = (proc as any).pid
+    if (pid) {
+      allChildPids.add(pid)
+
+      // for child processes, capture descendants once after a brief delay
+      if (isChildProcess(proc)) {
+        setTimeout(async () => {
+          if (proc.pid) {
+            try {
+              const childPids = await getChildPids(proc.pid)
+              for (const childPid of childPids) {
+                allChildPids.add(childPid)
+              }
+            } catch {
+              // ignore errors in background polling
+            }
+          }
+        }, 300)
+      }
+    }
+  }
+
+  addProcessHandler(addChildProcess)
+
+  const sigtermHandler = () => {
+    cleanup('SIGTERM').then(() => {
+      process.exit(0)
+    })
+  }
+
+  const sigintHandler = () => {
+    // immediately print newline and reset cursor for clean terminal
+    process.stdout.write('\n')
+    // reset terminal attributes
+    process.stdout.write('\x1b[0m')
+
+    cleanup('SIGINT').then(() => {
+      process.exit(0)
+    })
+  }
+
+  // intercept process.exit to ensure cleanup
+  const originalExit = process.exit
+  process.exit = ((code?: number) => {
+    cleanup('SIGTERM').then(() => {
+      originalExit(code)
+    })
+  }) as typeof process.exit
+
+  process.on('beforeExit', () => cleanup('SIGTERM'))
+  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/helpers/run.ts

@@ -0,0 +1,310 @@
+import type { ChildProcess } from 'node:child_process'
+import type { Timer } from '@take-out/helpers'
+
+export type ProcessType = ChildProcess | Bun.Subprocess
+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
+}
+
+export function getIsExiting() {
+  return isInExitCleanup
+}
+
+const processHandlers = new Set<ProcessHandler>()
+
+const colors = [
+  '\x1b[36m', // cyan
+  '\x1b[35m', // magenta
+  '\x1b[32m', // green
+  '\x1b[33m', // yellow
+  '\x1b[34m', // blue
+  '\x1b[31m', // red
+]
+const reset = '\x1b[0m'
+let colorIndex = 0
+
+function getNextColor(): string {
+  const color = colors[colorIndex % colors.length]!
+  colorIndex++
+  return color
+}
+
+const running: Record<string, Promise<unknown> | undefined | null> = {}
+
+export async function runInline(name: string, cb: () => Promise<void>) {
+  const promise = cb()
+  running[name] = promise
+  return await promise
+}
+
+export async function run(
+  command: string,
+  options?: {
+    env?: Record<string, string>
+    cwd?: string
+    silent?: boolean
+    captureOutput?: boolean
+    prefix?: string
+    detached?: boolean
+    timeout?: number
+    timing?: boolean | string
+  }
+) {
+  const { env, cwd, silent, captureOutput, prefix, detached, timeout, timing } =
+    options || {}
+
+  if (timing) {
+    const name = typeof timing === 'string' ? timing : command
+    const startTime = Date.now()
+    try {
+      const promise = runInternal()
+      running[name] = promise
+      const result = await promise
+      const duration = Date.now() - startTime
+      console.info(
+        `\x1b[32m✓\x1b[0m \x1b[35m${name}\x1b[0m completed in \x1b[33m${formatDuration(duration)}\x1b[0m`
+      )
+      return result
+    } catch (error) {
+      const duration = Date.now() - startTime
+      console.error(`✗ ${name} failed after ${formatDuration(duration)}`)
+      throw error
+    } finally {
+      running[name] = null
+    }
+  }
+
+  return runInternal()
+
+  async function runInternal() {
+    if (!silent) {
+      console.info(`$ ${command}${cwd ? ` (in ${cwd})` : ``}`)
+    }
+
+    let timeoutId: Timer | undefined
+    let didTimeOut = false
+
+    try {
+      const shell = Bun.spawn(['bash', '-c', command], {
+        env: { ...process.env, ...(env || {}) },
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe', // always pipe stderr so we can capture it for error messages
+      })
+
+      if (detached) {
+        shell.unref()
+      }
+
+      processHandlers.forEach((cb) => cb(shell))
+
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          didTimeOut = true
+          console.error(`Command timed out after ${timeout}ms: ${command}`)
+          shell.kill()
+        }, timeout)
+      }
+
+      const color = prefix ? getNextColor() : ''
+      const coloredPrefix = prefix ? `${color}[${prefix}]${reset}` : ''
+
+      const writeOutput = (text: string, isStderr: boolean) => {
+        if (!silent) {
+          const output = prefix ? `${coloredPrefix} ${text}` : text
+          if (!prefix || !captureOutput) {
+            const stream = isStderr ? process.stderr : process.stdout
+            stream.write(output)
+          }
+        }
+      }
+
+      const processStream = async (
+        stream: ReadableStream<Uint8Array> | undefined,
+        isStderr: boolean
+      ): Promise<string> => {
+        if (silent && !captureOutput) {
+          return ''
+        }
+
+        if (!stream) return ''
+
+        let buffer = ''
+        let captured = ''
+        const decoder = new TextDecoder()
+        const reader = stream.getReader()
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+
+            const text = buffer + decoder.decode(value, { stream: true })
+            const lines = text.split('\n')
+
+            // keep last partial line in buffer
+            buffer = lines.pop() || ''
+
+            // process complete lines
+            for (const line of lines) {
+              // always capture for potential error messages or captureOutput
+              captured += line + '\n'
+
+              // output if not silent and appropriate
+              if (!captureOutput || prefix) {
+                writeOutput(line + '\n', isStderr)
+              }
+            }
+          }
+
+          // output any remaining buffer
+          if (buffer) {
+            captured += buffer
+            if (!captureOutput || prefix) {
+              writeOutput(buffer + '\n', isStderr)
+            }
+          }
+        } catch (err) {
+          console.error(`Error reading stream!`, err)
+        } finally {
+          reader.releaseLock()
+        }
+
+        return captured
+      }
+
+      // always process both streams
+      const [stdout, stderr] = await Promise.all([
+        processStream(shell.stdout, false),
+        processStream(shell.stderr, true),
+      ])
+
+      const exitCode = await shell.exited
+
+      if (timeoutId) {
+        clearTimeout(timeoutId)
+      }
+
+      if (detached) {
+        return { stdout: '', stderr: '' }
+      }
+
+      if (exitCode !== 0) {
+        const errorMsg =
+          exitCode === 143 && didTimeOut
+            ? `Command timed out after ${timeout}ms: ${command}`
+            : `Command failed with exit code ${exitCode}: ${command}`
+
+        if (!silent && !isInExitCleanup) {
+          console.error(`run() error: ${errorMsg}: ${stderr || ''}`)
+        }
+
+        const error = new Error(errorMsg, { cause: { exitCode } })
+        Error.captureStackTrace(error, runInternal)
+        throw error
+      }
+
+      return { stdout, stderr, exitCode }
+    } catch (error) {
+      clearTimeout(timeoutId)
+      if (!silent && !isInExitCleanup) {
+        // 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) {
+        // simple message when being killed due to another error
+        const shortCmd = command.split(' ')[0]
+        console.error(`${shortCmd} exiting due to earlier error`)
+      }
+      throw error
+    }
+  }
+}
+
+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}`)
+  }
+  await running[name]
+}
+
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const remainingSeconds = seconds % 60
+
+  if (minutes > 0) {
+    return `${minutes}m ${remainingSeconds}s`
+  }
+  return `${seconds}s`
+}
+
+export async function printTiming<T>(name: string, fn: () => Promise<T>): Promise<T> {
+  const startTime = Date.now()
+  try {
+    const result = await fn()
+    const duration = Date.now() - startTime
+    console.info(
+      `\x1b[32m✓\x1b[0m \x1b[35m${name}\x1b[0m completed in \x1b[33m${formatDuration(duration)}\x1b[0m`
+    )
+    return result
+  } catch (error) {
+    const duration = Date.now() - startTime
+    console.error(`✗ ${name} failed after ${formatDuration(duration)}`)
+    throw error
+  }
+}
+
+export async function runParallel(
+  tasks: Array<{ name: string; fn: () => Promise<void>; condition?: () => boolean }>
+) {
+  const activeTasks = tasks.filter((task) => !task.condition || task.condition())
+
+  if (activeTasks.length === 0) {
+    return
+  }
+
+  console.info(`\nStarting parallel tasks: ${activeTasks.map((t) => t.name).join(', ')}`)
+
+  const taskStartTime = Date.now()
+
+  try {
+    await Promise.all(
+      activeTasks.map(async (task) => {
+        const startTime = Date.now()
+        try {
+          await task.fn()
+          const duration = Date.now() - startTime
+          console.info(
+            `\x1b[32m✓\x1b[0m task: \x1b[35m${task.name}\x1b[0m completed in \x1b[33m${formatDuration(duration)}\x1b[0m`
+          )
+        } catch (error) {
+          const duration = Date.now() - startTime
+          console.error(`✗ task: ${task.name} failed after ${formatDuration(duration)}`)
+          throw error
+        }
+      })
+    )
+
+    const totalDuration = Date.now() - taskStartTime
+    console.info(
+      `\nAll parallel tasks completed successfully in ${formatDuration(totalDuration)}`
+    )
+  } catch (error) {
+    const totalDuration = Date.now() - taskStartTime
+    console.error(`\nCI fail after ${formatDuration(totalDuration)} failed`)
+    throw error
+  }
+}

package/src/helpers/wait-for-port.ts

@@ -0,0 +1,33 @@
+import { checkPort } from './check-port'
+
+interface WaitForPortOptions {
+  host?: string
+  intervalMs?: number
+  timeoutMs?: number
+  retries?: number
+}
+
+export async function waitForPort(
+  port: number,
+  options: WaitForPortOptions = {}
+): Promise<void> {
+  const {
+    host = '127.0.0.1',
+    intervalMs = 1000,
+    timeoutMs = 30000,
+    retries = Math.floor(timeoutMs / intervalMs),
+  } = options
+
+  for (let i = 0; i < retries; i++) {
+    const isOpen = await checkPort(port, host)
+    if (isOpen) {
+      return
+    }
+
+    if (i < retries - 1) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs))
+    }
+  }
+
+  throw new Error(`Port ${port} on ${host} did not become available after ${timeoutMs}ms`)
+}

package/src/helpers/zero-get-version.ts

@@ -0,0 +1,8 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export function getZeroVersion() {
+  const packageJsonPath = join(process.cwd(), 'package.json')
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+  return packageJson.dependencies?.['@rocicorp/zero']?.replace(/^[\^~]/, '')
+}

package/src/node-version-check.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+function getCurrentNodeVersion() {
+  return process.version
+}
+
+async function getRequiredNodeVersion() {
+  // try .node-version file first
+  try {
+    const nodeVersionContent = await fs.readFile(
+      path.join(process.cwd(), '.node-version'),
+      'utf-8'
+    )
+    return `v${nodeVersionContent.trim()}`
+  } catch {}
+
+  // fallback to package.json engines.node
+  try {
+    const packageJson = JSON.parse(
+      await fs.readFile(path.join(process.cwd(), 'package.json'), 'utf-8')
+    )
+    return packageJson?.engines?.node ? `v${packageJson.engines.node}` : null
+  } catch {
+    return null
+  }
+}
+
+export async function checkNodeVersion() {
+  const currentNodeVersion = getCurrentNodeVersion()
+  const requiredNodeVersion = await getRequiredNodeVersion()
+
+  if (requiredNodeVersion) {
+    if (currentNodeVersion !== requiredNodeVersion) {
+      throw new Error(
+        `\u001b[33mWarning: Incorrect Node.js version. Expected ${requiredNodeVersion} but got ${currentNodeVersion}\u001b[0m`
+      )
+    }
+  }
+}
+
+if (import.meta.main) {
+  checkNodeVersion().catch((e: any) => {
+    console.error(e.message)
+    process.exit(1)
+  })
+}