@o/run 0.16.19-canary.1790165522484

package/src/run-pty.mjs

@@ -0,0 +1,455 @@
+#!/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 watch = args.includes('--watch')
+const MAX_RESTARTS = 3
+
+const processes = []
+let focusedIndex = -1 // -1 = interleaved/dashboard
+let exiting = false
+
+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, restarts = 0) {
+  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 startedAt = Date.now()
+  const previous = index === undefined ? undefined : processes[index]
+  const managed = {
+    terminal,
+    name,
+    cwd,
+    label,
+    extraArgs,
+    index: idx,
+    // Keep the same keyboard shortcut when a process is restarted in-place.
+    shortcut: previous?.shortcut || '',
+    killed: false,
+    restartTimer: null,
+  }
+
+  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, signal }) => {
+    if (managed.killed) return
+    if (focusedIndex === idx) {
+      focusedIndex = -1
+      showDashboard()
+    }
+    const terminatedBySignal = signal != null && signal !== 0
+    if (exitCode !== 0 || terminatedBySignal) {
+      const result = terminatedBySignal ? `signal ${signal}` : `code ${exitCode}`
+      console.error(`${getPrefix(idx)} exited with ${result}`)
+      if (watch && !exiting) {
+        const effectiveRestarts = Date.now() - startedAt >= 20_000 ? 0 : restarts
+        if (effectiveRestarts < MAX_RESTARTS) {
+          const nextRestart = effectiveRestarts + 1
+          const delayMs = Math.min(1_000 * 2 ** effectiveRestarts, 30_000)
+          managed.killed = true
+          console.info(
+            `${getPrefix(idx)} restarting (${nextRestart}/${MAX_RESTARTS}) in ${Math.round(delayMs / 1_000)}s`
+          )
+          managed.restartTimer = setTimeout(() => {
+            if (exiting || processes[idx] !== managed) return
+            managed.restartTimer = null
+            spawnScript(name, cwd, label, extraArgs, idx, nextRestart)
+          }, delayMs)
+        } else {
+          console.error(`${getPrefix(idx)} gave up after ${MAX_RESTARTS} rapid restarts`)
+          cleanup(1)
+        }
+      }
+    }
+  })
+
+  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)
+      if (match.restartTimer) {
+        clearTimeout(match.restartTimer)
+        match.restartTimer = null
+      }
+      if (!match.killed) {
+        match.killed = true
+        killProcessTree(match.terminal.pid)
+      }
+      match.restartTimer = setTimeout(() => {
+        if (exiting || processes[match.index] !== match) return
+        match.restartTimer = null
+        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.restartTimer) {
+        clearTimeout(match.restartTimer)
+        match.restartTimer = null
+      }
+      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(exitCode = 0) {
+  if (exiting) return
+  exiting = true
+  // 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(exitCode), 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-supervision.test.ts

@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { spawn, type ChildProcess } from 'node:child_process'
+import {
+  appendFileSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+const RUNNER = resolve(import.meta.dir, 'run.ts')
+const running: ChildProcess[] = []
+const directories: string[] = []
+
+afterEach(async () => {
+  for (const child of running.splice(0)) {
+    if (child.exitCode !== null || child.signalCode !== null) continue
+    child.kill('SIGTERM')
+    await new Promise<void>((done) => child.once('exit', () => done()))
+  }
+  for (const directory of directories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true })
+  }
+})
+
+async function waitFor(read: () => boolean, timeoutMs = 5_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (read()) return
+    await Bun.sleep(25)
+  }
+  throw new Error('timed out waiting for supervised process state')
+}
+
+function startRunner(watch: boolean) {
+  const directory = mkdtempSync(join(tmpdir(), 'tko-run-supervision-'))
+  directories.push(directory)
+  const startsPath = join(directory, 'starts.txt')
+  writeFileSync(
+    join(directory, 'child.ts'),
+    `import { appendFileSync } from 'node:fs'\nappendFileSync(process.env.STARTS_PATH!, String(process.pid) + '\\n')\nawait new Promise(() => {})\n`
+  )
+  writeFileSync(
+    join(directory, 'package.json'),
+    JSON.stringify({ scripts: { child: 'bun child.ts' } })
+  )
+
+  const child = spawn('bun', [RUNNER, ...(watch ? ['--watch'] : []), 'child'], {
+    cwd: directory,
+    env: { ...process.env, STARTS_PATH: startsPath },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+  running.push(child)
+  let output = ''
+  child.stdout?.on('data', (chunk) => {
+    output += String(chunk)
+  })
+  child.stderr?.on('data', (chunk) => {
+    output += String(chunk)
+  })
+  const managedPidsPath = `/tmp/tko-run-${child.pid}.pids`
+
+  return {
+    child,
+    managedPidsPath,
+    startsPath,
+    output() {
+      return output
+    },
+    starts() {
+      if (!existsSync(startsPath)) return []
+      return readFileSync(startsPath, 'utf8').trim().split('\n').filter(Boolean)
+    },
+    managedPids() {
+      if (!existsSync(managedPidsPath)) return []
+      return readFileSync(managedPidsPath, 'utf8').trim().split('\n').filter(Boolean)
+    },
+  }
+}
+
+describe('run process supervision', () => {
+  test('watch restarts a child terminated by a signal', async () => {
+    const runner = startRunner(true)
+    await waitFor(() => runner.starts().length === 1 && runner.managedPids().length === 1)
+
+    process.kill(Number(runner.managedPids()[0]), 'SIGTERM')
+
+    await waitFor(() => runner.starts().length === 2)
+    expect(runner.starts()[1]).not.toBe(runner.starts()[0])
+  }, 15_000)
+})