@take-out/scripts 0.1.19 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.8.2",
-    "@take-out/helpers": "0.1.19",
+    "@lydell/node-pty": "^1.2.0-beta.3",
+    "@take-out/helpers": "0.1.21",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/helpers/deploy-health.ts

@@ -24,12 +24,19 @@ export interface ContainerInfo {
 /**
  * check for containers stuck in restart loop
  * fails fast if any container is crash-looping
+ * excludes init containers (minio-init, migrate) that are expected to exit
  */
-export async function checkRestartLoops(ctx: SSHContext): Promise<{
+export async function checkRestartLoops(
+  ctx: SSHContext,
+  options?: { excludePatterns?: string[] }
+): Promise<{
   hasLoop: boolean
   services: string[]
 }> {
   const { sshOpts, deployUser, deployHost, $ } = ctx
+  // default exclude patterns for init/oneshot containers
+  const excludePatterns = options?.excludePatterns ?? ['init', 'migrate']
+
   try {
     const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
     const result =
@@ -40,7 +47,11 @@ export async function checkRestartLoops(ctx: SSHContext): Promise<{
     for (const line of lines) {
       if (line.includes('Restarting')) {
         const name = line.split(' ')[0] || ''
-        loopingServices.push(name)
+        // skip init/oneshot containers
+        const isExcluded = excludePatterns.some((pattern) => name.includes(pattern))
+        if (!isExcluded) {
+          loopingServices.push(name)
+        }
       }
     }
 

package/src/run-pty.mjs

@@ -0,0 +1,361 @@
+#!/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 bold = '\x1b[1m'
+const inverse = '\x1b[7m'
+
+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
+      match.terminal.kill()
+      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
+        match.terminal.kill()
+        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')
+  }
+}
+
+function cleanup() {
+  console.log()
+  for (const p of processes) {
+    if (!p.killed) {
+      p.killed = true
+      p.terminal.kill()
+    }
+  }
+  process.exit(0)
+}
+
+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)
+        p.terminal.resize(process.stdout.columns || 80, process.stdout.rows || 24)
+    }
+  })
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

package/src/run.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 /**
- * @description Run multiple scripts in parallel or sequence
+ * @description Run multiple scripts in parallel
  */
 
 import { spawn } from 'node:child_process'
@@ -13,15 +13,14 @@ import { handleProcessExit } from '@take-out/scripts/helpers/handleProcessExit'
 import { getIsExiting } from './helpers/run'
 import { checkNodeVersion } from './node-version-check'
 
-// 256-color grays for subtle differentiation (232=darkest, 255=lightest)
 const colors = [
-  '\x1b[38;5;245m', // medium gray
-  '\x1b[38;5;240m', // darker gray
-  '\x1b[38;5;250m', // lighter gray
-  '\x1b[38;5;243m', // medium-dark gray
-  '\x1b[38;5;248m', // medium-light gray
-  '\x1b[38;5;238m', // dark gray
-  '\x1b[38;5;252m', // light gray
+  '\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'
@@ -29,22 +28,6 @@ const reset = '\x1b[0m'
 // eslint-disable-next-line no-control-regex
 const ansiPattern = /\x1b\[[0-9;]*m/g
 
-// Verbose logging flag - set to false to reduce logs
-const verbose = false
-
-// Helper function to conditionally log based on verbosity
-const log = {
-  info: (message: string) => {
-    if (verbose) console.info(message)
-  },
-  error: (message: string) => console.error(message),
-  output: (message: string) => console.info(message),
-}
-
-const MAX_RESTARTS = 3
-
-// Separate command names from flags/arguments
-// Handles --flag=value and --flag value styles, excluding flag values from commands
 const args = process.argv.slice(2)
 const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
 const runCommands: string[] = []
@@ -54,37 +37,25 @@ for (let i = 0; i < args.length; i++) {
   const arg = args[i]!
 
   if (arg.startsWith('--')) {
-    // handle flags
-    if (ownFlags.includes(arg) || arg.startsWith('--stdin=')) {
-      continue
-    }
+    if (ownFlags.includes(arg)) continue
     forwardArgs.push(arg)
-    // if next arg exists and doesn't start with --, treat it as this flag's value
     const nextArg = args[i + 1]
     if (nextArg && !nextArg.startsWith('--')) {
       forwardArgs.push(nextArg)
-      i++ // skip the value in next iteration
+      i++
     }
   } else {
-    // non-flag arg is a command name
     runCommands.push(arg)
   }
 }
 
 const noRoot = args.includes('--no-root')
 const runBun = args.includes('--bun')
-const watch = args.includes('--watch') // just attempts to restart a failed process up to MAX_RESTARTS times
-// --flags=last forwards args only to last script, default forwards to all
+const watch = args.includes('--watch')
 const flagsLast = args.includes('--flags=last')
 
-// parse --stdin=<script-name> to specify which script receives keyboard input
-// if not specified, defaults to the last script in the list
-const stdinArg = args.find((arg) => arg.startsWith('--stdin='))
-const stdinScript = stdinArg
-  ? stdinArg.replace('--stdin=', '')
-  : (runCommands[runCommands.length - 1] ?? null)
+const MAX_RESTARTS = 3
 
-// Get the list of scripts already being run by a parent process
 const parentRunningScripts = process.env.BUN_RUN_SCRIPTS
   ? process.env.BUN_RUN_SCRIPTS.split(',')
   : []
@@ -97,14 +68,11 @@ interface ManagedProcess {
   extraArgs: string[]
   index: number
   shortcut: string
-  restarting: boolean
-  killing: boolean
 }
 
 const managedProcesses: ManagedProcess[] = []
 const { addChildProcess, exit } = handleProcessExit()
 
-// dynamic prefix using shortcut letter(s) — falls back to index before shortcuts are computed
 function getPrefix(index: number): string {
   const managed = managedProcesses[index]
   if (!managed) return ''
@@ -114,8 +82,7 @@ function getPrefix(index: number): string {
 }
 
 if (runCommands.length === 0) {
-  log.error('Please provide at least one script name to run')
-  log.error('Example: bun run.ts watch lint test')
+  console.error('Please provide at least one script name to run')
   exit(1)
 }
 
@@ -124,7 +91,7 @@ async function readPackageJson(directoryPath: string) {
     const packageJsonPath = join(directoryPath, 'package.json')
     const content = await fs.promises.readFile(packageJsonPath, 'utf8')
     return JSON.parse(content)
-  } catch (_) {
+  } catch {
     return null
   }
 }
@@ -137,8 +104,7 @@ async function getWorkspacePatterns(): Promise<string[]> {
     return Array.isArray(packageJson.workspaces)
       ? packageJson.workspaces
       : packageJson.workspaces.packages || []
-  } catch (_) {
-    log.error('Error reading workspace patterns')
+  } catch {
     return []
   }
 }
@@ -172,14 +138,12 @@ async function findPackageJsonDirs(basePath: string, maxDepth = 3): Promise<stri
       )
       .map(async (dir) => {
         const path = join(basePath, dir.name)
-        const subdirResults = await findPackageJsonDirs(path, maxDepth - 1)
-        return subdirResults
+        return findPackageJsonDirs(path, maxDepth - 1)
       })
 
     const subdirResults = await Promise.all(subDirPromises)
     return [...results, ...subdirResults.flat()]
-  } catch (error) {
-    log.error(`Error scanning directory ${basePath}: ${error}`)
+  } catch {
     return []
   }
 }
@@ -190,13 +154,12 @@ async function findWorkspaceDirectories(): Promise<string[]> {
 
   const allPackageDirs = await findPackageJsonDirs('.')
 
-  // normalize path separators to forward slashes for cross-platform support
   const normalizePath = (path: string): string => {
-    let normalized = path.replace(/\\/g, '/')
+    const normalized = path.replace(/\\/g, '/')
     return normalized.startsWith('./') ? normalized.substring(2) : normalized
   }
 
-  const workspaceDirs = allPackageDirs.filter((dir) => {
+  return allPackageDirs.filter((dir) => {
     if (dir === '.') return false
 
     const relativePath = relative('.', dir)
@@ -214,8 +177,6 @@ async function findWorkspaceDirectories(): Promise<string[]> {
       )
     })
   })
-
-  return workspaceDirs
 }
 
 async function findAvailableScripts(
@@ -265,22 +226,14 @@ const runScript = async (
 ) => {
   const index = managedIndex ?? managedProcesses.length
 
-  // capture stderr for error reporting
-  let stderrBuffer = ''
-
-  // --silent suppresses bun's "$ command" output
   const runArgs = ['run', '--silent', runBun ? '--bun' : '', name, ...extraArgs].filter(
     Boolean
   )
 
-  const commandDisplay = `bun ${runArgs.join(' ')}`
-  log.info(`${getPrefix(index)} Running: ${commandDisplay} (in ${resolve(cwd)})`)
-
   const allRunningScripts = [...parentRunningScripts, ...runCommands].join(',')
 
-  // always pipe stdin - parent handles keyboard shortcuts and forwarding
   const proc = spawn('bun', runArgs, {
-    stdio: ['pipe', 'pipe', 'pipe'],
+    stdio: ['ignore', 'pipe', 'pipe'],
     shell: false,
     env: {
       ...process.env,
@@ -290,11 +243,8 @@ const runScript = async (
       TKO_SILENT: '1',
     } as any,
     cwd: resolve(cwd),
-    detached: true,
   })
 
-  log.info(`${getPrefix(index)} Process started with PID: ${proc.pid}`)
-
   const managed: ManagedProcess = {
     proc,
     name,
@@ -303,8 +253,6 @@ const runScript = async (
     extraArgs,
     index,
     shortcut: '',
-    restarting: false,
-    killing: false,
   }
 
   if (managedIndex !== undefined) {
@@ -321,52 +269,36 @@ const runScript = async (
     for (const line of lines) {
       const stripped = line.replace(ansiPattern, '')
       if (stripped.startsWith('$ ')) continue
-      if (line) log.output(`${getPrefix(index)} ${line}`)
+      if (line) console.info(`${getPrefix(index)} ${line}`)
     }
   })
 
   proc.stderr!.on('data', (data) => {
-    const dataStr = data.toString()
-    stderrBuffer += dataStr
-
     if (getIsExiting()) return
-    const lines = dataStr.split('\n')
+    const lines = data.toString().split('\n')
     for (const line of lines) {
       const stripped = line.replace(ansiPattern, '')
       if (stripped.startsWith('$ ')) continue
-      if (line) log.error(`${getPrefix(index)} ${line}`)
+      if (line) console.error(`${getPrefix(index)} ${line}`)
     }
   })
 
   proc.on('error', (error) => {
-    log.error(`${getPrefix(index)} Failed to start: ${error.message}`)
+    console.error(`${getPrefix(index)} Failed to start: ${error.message}`)
   })
 
   proc.on('close', (code) => {
     if (getIsExiting()) return
 
-    // intentionally killed or restarting - skip error handling
-    const currentManaged = managedProcesses[index]
-    if (currentManaged?.restarting || currentManaged?.killing) return
-
     if (code && code !== 0) {
-      log.error(`${getPrefix(index)} Process exited with code ${code}`)
+      console.error(`${getPrefix(index)} Process exited with code ${code}`)
 
-      if (code === 1) {
-        console.error('\x1b[31m❌ Run Failed\x1b[0m')
-        console.error(
-          `\x1b[31mProcess "${prefixLabel}" failed with exit code ${code}\x1b[0m`
-        )
-
-        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)
-        }
+      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)
       }
     }
   })
@@ -374,8 +306,6 @@ const runScript = async (
   return proc
 }
 
-// compute unique letter-based shortcuts from process labels
-// splits on non-letters, takes first char of each word, extends until unique
 function computeShortcuts() {
   const initials = managedProcesses.map((p) => {
     const words = p.prefixLabel
@@ -385,7 +315,6 @@ function computeShortcuts() {
     return words.map((w) => w[0]).join('')
   })
 
-  // start each shortcut at 1 letter, extend collisions
   const lengths = new Array(managedProcesses.length).fill(1) as number[]
 
   for (let round = 0; round < 5; round++) {
@@ -415,217 +344,15 @@ function computeShortcuts() {
     }
   }
 
-  // fallback: use whatever we have, append index if still colliding
   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 killProcessGroup(managed: ManagedProcess) {
-  if (managed.proc.pid) {
-    try {
-      process.kill(-managed.proc.pid, 'SIGTERM')
-    } catch {}
-    await new Promise((r) => setTimeout(r, 200))
-    try {
-      process.kill(-managed.proc.pid, 'SIGKILL')
-    } catch {}
-  }
-  await new Promise((r) => setTimeout(r, 100))
-}
-
-async function restartProcess(index: number) {
-  const managed = managedProcesses[index]
-  if (!managed) return
-
-  const { name, cwd, prefixLabel, extraArgs } = managed
-
-  managed.restarting = true
-  managed.killing = false
-  console.info(`\x1b[2m  restarting ${managed.shortcut} ${prefixLabel}...\x1b[0m`)
-
-  await killProcessGroup(managed)
-  await runScript(name, cwd, prefixLabel, 0, extraArgs, index)
-  console.info(`${getPrefix(index)} \x1b[32m↻ restarted\x1b[0m`)
-}
-
-async function killProcess(index: number) {
-  const managed = managedProcesses[index]
-  if (!managed) return
-
-  if (managed.killing) {
-    console.info(
-      `\x1b[2m  ${managed.shortcut} ${managed.prefixLabel} already stopped\x1b[0m`
-    )
-    return
-  }
-
-  managed.killing = true
-  managed.restarting = false
-  console.info(`\x1b[2m  killing ${managed.shortcut} ${managed.prefixLabel}...\x1b[0m`)
-
-  await killProcessGroup(managed)
-  console.info(`${getPrefix(index)} \x1b[31m■ stopped\x1b[0m`)
-}
-
-type InputMode = 'restart' | 'kill' | null
-
-function setupKeyboardShortcuts() {
-  if (!process.stdin.isTTY) return
-  if (managedProcesses.length === 0) return
-
-  process.stdin.setRawMode(true)
-  process.stdin.resume()
-  process.stdin.setEncoding('utf8')
-
-  let mode: InputMode = null
-  let buffer = ''
-  let timer: ReturnType<typeof setTimeout> | null = null
-
-  function clearTimer() {
-    if (timer) {
-      clearTimeout(timer)
-      timer = null
-    }
-  }
-
-  function dispatchMatch(m: InputMode, index: number) {
-    if (m === 'restart') restartProcess(index)
-    else if (m === 'kill') killProcess(index)
-  }
-
-  function finishMatch() {
-    clearTimer()
-    if (!buffer) return
-
-    const currentMode = mode
-    const match = managedProcesses.find((p) => p.shortcut === buffer)
-    if (match) {
-      dispatchMatch(currentMode, match.index)
-    } else {
-      console.info(`\x1b[2m  no match for "${buffer}"\x1b[0m`)
-    }
-
-    buffer = ''
-    mode = null
-  }
-
-  function showProcessList(label: string) {
-    const dim = '\x1b[2m'
-    console.info()
-    console.info(`${dim}  ${label} which process?${reset}`)
-    for (const managed of managedProcesses) {
-      const color = colors[managed.index % colors.length]
-      const stopped = managed.killing ? `${dim} (stopped)` : ''
-      console.info(
-        `${dim}  ${reset}${color}${managed.shortcut}${reset}${dim} ${managed.prefixLabel}${stopped}${reset}`
-      )
-    }
-    console.info()
-  }
-
-  function enterMode(newMode: InputMode, label: string) {
-    clearTimer()
-    mode = newMode
-    buffer = ''
-    showProcessList(label)
-  }
-
-  process.stdin.on('data', (key: string) => {
-    // ctrl+c
-    if (key === '\x03') {
-      process.stdin.setRawMode(false)
-      exit(0)
-      return
-    }
-
-    // escape cancels
-    if (key === '\x1b' && mode) {
-      clearTimer()
-      buffer = ''
-      mode = null
-      console.info('\x1b[2m  cancelled\x1b[0m')
-      return
-    }
-
-    // ctrl+r - restart mode
-    if (key === '\x12') {
-      enterMode('restart', 'restart')
-      return
-    }
-
-    // ctrl+k - kill mode
-    if (key === '\x0b') {
-      enterMode('kill', 'kill')
-      return
-    }
-
-    // ctrl+l - clear screen
-    if (key === '\x0c') {
-      process.stdout.write('\x1b[2J\x1b[H')
-      return
-    }
-
-    if (mode) {
-      const lower = key.toLowerCase()
-      if (/^[a-z]$/.test(lower)) {
-        buffer += lower
-        clearTimer()
-
-        // exact match → dispatch immediately
-        const exact = managedProcesses.find((p) => p.shortcut === buffer)
-        if (exact) {
-          const m = mode
-          mode = null
-          buffer = ''
-          dispatchMatch(m, exact.index)
-          return
-        }
-
-        // no shortcuts start with buffer → no match
-        const hasPrefix = managedProcesses.some((p) => p.shortcut.startsWith(buffer))
-        if (!hasPrefix) {
-          console.info(`\x1b[2m  no match for "${buffer}"\x1b[0m`)
-          buffer = ''
-          mode = null
-          return
-        }
-
-        // ambiguous — wait 500ms for more input
-        timer = setTimeout(finishMatch, 500)
-      } else {
-        // non-letter cancels
-        clearTimer()
-        buffer = ''
-        mode = null
-        console.info('\x1b[2m  cancelled\x1b[0m')
-      }
-      return
-    }
-
-    // forward other input to the designated stdin process
-    const stdinProc = managedProcesses.find((p) => p.name === stdinScript)
-    if (stdinProc?.proc.stdin && !stdinProc.proc.stdin.destroyed) {
-      stdinProc.proc.stdin.write(key)
-    }
-  })
-}
-
-function printShortcutHint() {
-  if (!process.stdin.isTTY) return
-  if (managedProcesses.length === 0) return
-
-  const dim = '\x1b[2m'
-  console.info(
-    `${dim}  ctrl+r restart · ctrl+k kill · ctrl+l clear · ctrl+c exit${reset}`
-  )
-  console.info()
-}
-
 async function main() {
   checkNodeVersion().catch((err) => {
-    log.error(err.message)
+    console.error(err.message)
     exit(1)
   })
 
@@ -633,15 +360,13 @@ async function main() {
     if (runCommands.length > 0) {
       const lastScript = runCommands[runCommands.length - 1]
 
-      // Root package.json scripts first, if not disabled
       if (!noRoot) {
         const filteredCommands = runCommands.filter(
           (name) => !parentRunningScripts.includes(name)
         )
         const scriptPromises = filteredCommands.map((name) => {
-          // --flags=last: only forward args to last script
-          const args = !flagsLast || name === lastScript ? forwardArgs : []
-          return runScript(name, '.', name, 0, args)
+          const scriptArgs = !flagsLast || name === lastScript ? forwardArgs : []
+          return runScript(name, '.', name, 0, scriptArgs)
         })
 
         await Promise.all(scriptPromises)
@@ -654,9 +379,14 @@ async function main() {
           (scriptName) => !parentRunningScripts.includes(scriptName)
         )
         const workspaceScriptPromises = filteredScripts.map((scriptName) => {
-          // --flags=last: only forward args to last script
-          const args = !flagsLast || scriptName === lastScript ? forwardArgs : []
-          return runScript(scriptName, workspace, `${packageName} ${scriptName}`, 0, args)
+          const scriptArgs = !flagsLast || scriptName === lastScript ? forwardArgs : []
+          return runScript(
+            scriptName,
+            workspace,
+            `${packageName} ${scriptName}`,
+            0,
+            scriptArgs
+          )
         })
 
         await Promise.all(workspaceScriptPromises)
@@ -667,16 +397,14 @@ async function main() {
       exit(0)
     } else {
       computeShortcuts()
-      printShortcutHint()
-      setupKeyboardShortcuts()
     }
   } catch (error) {
-    log.error(`Error running scripts: ${error}`)
+    console.error(`Error running scripts: ${error}`)
     exit(1)
   }
 }
 
 main().catch((error) => {
-  log.error(`Error running scripts: ${error}`)
+  console.error(`Error running scripts: ${error}`)
   exit(1)
 })