@take-out/scripts 0.1.20 → 0.1.21

package/package.json

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

package/src/run-pty.mjs

@@ -6,12 +6,12 @@ import { join, relative, resolve } from 'node:path'
 import pty from '@lydell/node-pty'
 
 const colors = [
-  '\x1b[38;5;245m',
-  '\x1b[38;5;240m',
-  '\x1b[38;5;243m',
-  '\x1b[38;5;248m',
-  '\x1b[38;5;238m',
-  '\x1b[38;5;252m',
+  '\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'
@@ -43,14 +43,13 @@ const runBun = args.includes('--bun')
 const flagsLast = args.includes('--flags=last')
 
 const processes = []
-let dashboardMode = false
-let selectedIndex = 0
+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} ${p.label}${reset}`
+  return `${color}${p.shortcut}${reset}`
 }
 
 if (runCommands.length === 0) {
@@ -97,10 +96,8 @@ async function findPackageJsonDirs(base, depth = 3) {
 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, '/')
@@ -111,7 +108,6 @@ async function findWorkspaceScripts(scripts) {
         : 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')
@@ -124,7 +120,6 @@ 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,
@@ -144,26 +139,34 @@ function spawnScript(name, cwd, label, extraArgs, index) {
     killed: false,
   }
 
-  if (index !== undefined) {
-    processes[index] = managed
-  } else {
-    processes.push(managed)
-  }
+  if (index !== undefined) processes[index] = managed
+  else processes.push(managed)
 
   terminal.onData((data) => {
-    if (dashboardMode) return
-    const lines = data.split('\n')
-    for (const line of lines) {
-      if (line && line !== '\r') {
+    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) {
-      process.stdout.write(`${getPrefix(idx)} exited with code ${exitCode}\n`)
+      console.error(`${getPrefix(idx)} exited ${exitCode}`)
     }
   })
 
@@ -171,115 +174,122 @@ function spawnScript(name, cwd, label, extraArgs, index) {
 }
 
 function computeShortcuts() {
-  const initials = processes.map((p) =>
-    p.label
+  // 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)
-      .map((w) => w[0])
-      .join('')
-  )
-  const lengths = new Array(processes.length).fill(1)
-
-  for (let round = 0; round < 5; round++) {
-    const shortcuts = initials.map((init, i) => init.slice(0, lengths[i]) || init)
-    const groups = new Map()
-    shortcuts.forEach((s, i) => groups.set(s, [...(groups.get(s) || []), i]))
-
-    let collision = false
-    for (const indices of groups.values()) {
-      if (indices.length > 1) {
-        collision = true
-        indices.forEach((i) => lengths[i]++)
-      }
-    }
-    if (!collision) {
-      processes.forEach((p, i) => (p.shortcut = shortcuts[i]))
-      return
+    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
   }
-  processes.forEach(
-    (p, i) => (p.shortcut = initials[i]?.slice(0, lengths[i]) || String(i + 1))
-  )
 }
 
-function renderDashboard() {
-  process.stdout.write('\x1b[2J\x1b[H')
-  process.stdout.write(
-    `${bold}Dashboard${reset} ${dim}(↑↓ navigate, r restart, k kill, esc back)${reset}\n\n`
+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`
   )
-
-  for (let i = 0; i < processes.length; i++) {
-    const p = processes[i]
-    const prefix = i === selectedIndex ? `${inverse} > ${reset}` : '   '
-    const status = p.killed
-      ? `${dim}(killed)${reset}`
-      : p.terminal.pid
-        ? `${dim}(pid ${p.terminal.pid})${reset}`
-        : ''
-    process.stdout.write(`${prefix} ${getPrefix(i)} ${status}\n`)
-  }
-  process.stdout.write(`\n${dim}ctrl+c to exit${reset}\n`)
 }
 
-function exitDashboard() {
-  dashboardMode = false
-  process.stdout.write('\x1b[2J\x1b[H')
-  process.stdout.write(
-    `${dim}  running ${processes.length} processes (ctrl+z dashboard, ctrl+c exit)${reset}\n\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 (dashboardMode) {
-      exitDashboard()
+    if (focusedIndex >= 0) {
+      focusedIndex = -1
+      showDashboard()
     } else {
-      dashboardMode = true
-      renderDashboard()
+      showDashboard()
     }
     return
   }
 
-  if (dashboardMode) {
-    if (str === '\x1b[A') {
-      selectedIndex = Math.max(0, selectedIndex - 1)
-      renderDashboard()
-    } else if (str === '\x1b[B') {
-      selectedIndex = Math.min(processes.length - 1, selectedIndex + 1)
-      renderDashboard()
-    } else if (str === 'r' || str === 'R') {
-      const p = processes[selectedIndex]
-      if (p) {
-        p.killed = true
-        p.terminal.kill()
-        setTimeout(() => {
-          spawnScript(p.name, p.cwd, p.label, p.extraArgs, p.index)
-          exitDashboard()
-        }, 100)
-      }
-    } else if (str === 'k' || str === 'K') {
-      const p = processes[selectedIndex]
-      if (p && !p.killed) {
-        p.killed = true
-        p.terminal.kill()
-        renderDashboard()
+  // 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 if (str === '\x1b' || str === '\x1b\x1b') {
-      exitDashboard()
+    } 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() {
-  process.stdout.write('\n')
+  console.log()
   for (const p of processes) {
     if (!p.killed) {
       p.killed = true
@@ -297,8 +307,12 @@ async function main() {
     if (pkg?.scripts) {
       for (const name of runCommands) {
         if (typeof pkg.scripts[name] === 'string') {
-          const scriptArgs = !flagsLast || name === lastScript ? forwardArgs : []
-          spawnScript(name, '.', name, scriptArgs)
+          spawnScript(
+            name,
+            '.',
+            name,
+            !flagsLast || name === lastScript ? forwardArgs : []
+          )
         }
       }
     }
@@ -307,8 +321,12 @@ async function main() {
   const wsScripts = await findWorkspaceScripts(runCommands)
   for (const [dir, { scripts, name }] of wsScripts) {
     for (const script of scripts) {
-      const scriptArgs = !flagsLast || script === lastScript ? forwardArgs : []
-      spawnScript(script, dir, `${name} ${script}`, scriptArgs)
+      spawnScript(
+        script,
+        dir,
+        `${name} ${script}`,
+        !flagsLast || script === lastScript ? forwardArgs : []
+      )
     }
   }
 
@@ -318,9 +336,7 @@ async function main() {
   }
 
   computeShortcuts()
-  process.stdout.write(
-    `${dim}  running ${processes.length} processes (ctrl+z dashboard, ctrl+c exit)${reset}\n\n`
-  )
+  showDashboard()
 
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true)
@@ -329,12 +345,9 @@ async function main() {
   }
 
   process.stdout.on('resize', () => {
-    const cols = process.stdout.columns || 80
-    const rows = process.stdout.rows || 24
     for (const p of processes) {
-      if (!p.killed) {
-        p.terminal.resize(cols, rows)
-      }
+      if (!p.killed)
+        p.terminal.resize(process.stdout.columns || 80, process.stdout.rows || 24)
     }
   })
 

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)
 })