numux 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numux",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Terminal multiplexer with dependency orchestration",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -19,6 +19,7 @@ export interface ParsedArgs {
 	logDir?: string
 	only?: string[]
 	exclude?: string[]
+	colors?: string[]
 	commands: string[]
 	named: Array<{ name: string; command: string }>
 }
@@ -72,8 +73,13 @@ export function parseArgs(argv: string[]): ParsedArgs {
 			result.noRestart = true
 		} else if (arg === '--no-watch') {
 			result.noWatch = true
-		} else if (arg === '-c' || arg === '--config') {
+		} else if (arg === '--config') {
 			result.configPath = consumeValue(arg)
+		} else if (arg === '-c' || arg === '--color') {
+			result.colors = consumeValue(arg)
+				.split(',')
+				.map(s => s.trim())
+				.filter(Boolean)
 		} else if (arg === '--log-dir') {
 			result.logDir = consumeValue(arg)
 		} else if (arg === '--only') {
@@ -128,13 +134,16 @@ export function parseArgs(argv: string[]): ParsedArgs {
 export function buildConfigFromArgs(
 	commands: string[],
 	named: Array<{ name: string; command: string }>,
-	options?: { noRestart?: boolean }
+	options?: { noRestart?: boolean; colors?: string[] }
 ): ResolvedNumuxConfig {
 	const processes: ResolvedNumuxConfig['processes'] = {}
 	const maxRestarts = options?.noRestart ? 0 : undefined
+	const colors = options?.colors
+	let colorIndex = 0
 
 	for (const { name, command } of named) {
-		processes[name] = { command, persistent: true, maxRestarts }
+		const color = colors?.[colorIndex++ % colors.length]
+		processes[name] = { command, persistent: true, maxRestarts, ...(color ? { color } : {}) }
 	}
 
 	for (let i = 0; i < commands.length; i++) {
@@ -144,7 +153,8 @@ export function buildConfigFromArgs(
 		if (processes[name]) {
 			name = `${name}-${i}`
 		}
-		processes[name] = { command: cmd, persistent: true, maxRestarts }
+		const color = colors?.[colorIndex++ % colors.length]
+		processes[name] = { command: cmd, persistent: true, maxRestarts, ...(color ? { color } : {}) }
 	}
 
 	return { processes }

package/src/completions.ts

@@ -22,7 +22,7 @@ _numux() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
   case "$prev" in
-    -c|--config)
+    --config)
       COMPREPLY=( $(compgen -f -- "$cur") )
       return ;;
     --log-dir)
@@ -38,7 +38,7 @@ _numux() {
   esac
 
   if [[ "$cur" == -* ]]; then
-    COMPREPLY=( $(compgen -W "-h --help -v --version -c --config -n --name -p --prefix --only --exclude --kill-others --no-restart --no-watch -t --timestamps --log-dir --debug" -- "$cur") )
+    COMPREPLY=( $(compgen -W "-h --help -v --version -c --color --config -n --name -p --prefix --only --exclude --kill-others --no-restart --no-watch -t --timestamps --log-dir --debug" -- "$cur") )
   else
     local subcmds="init validate exec completions"
     COMPREPLY=( $(compgen -W "$subcmds" -- "$cur") )
@@ -63,7 +63,8 @@ _numux() {
   _arguments -s \\
     '(-h --help)'{-h,--help}'[Show help]' \\
     '(-v --version)'{-v,--version}'[Show version]' \\
-    '(-c --config)'{-c,--config}'[Config file path]:file:_files' \\
+    '(-c --color)'{-c,--color}'[Comma-separated colors for processes]' \\
+    '--config[Config file path]:file:_files' \\
     '(-n --name)'{-n,--name}'[Named process (name=command)]:named process' \\
     '(-p --prefix)'{-p,--prefix}'[Prefixed output mode]' \\
     '--only[Only run these processes]:processes' \\
@@ -105,7 +106,8 @@ complete -c numux -n '__fish_seen_subcommand_from completions' -a 'bash zsh fish
 # Options
 complete -c numux -s h -l help -d 'Show help'
 complete -c numux -s v -l version -d 'Show version'
-complete -c numux -s c -l config -rF -d 'Config file path'
+complete -c numux -s c -l color -r -d 'Comma-separated colors for processes'
+complete -c numux -l config -rF -d 'Config file path'
 complete -c numux -s n -l name -r -d 'Named process (name=command)'
 complete -c numux -s p -l prefix -d 'Prefixed output mode'
 complete -c numux -l only -r -d 'Only run these processes'

package/src/config/expand-scripts.ts

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { NumuxConfig, NumuxProcessConfig } from '../types'
+
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun'
+
+const LOCKFILE_PM: [string, PackageManager][] = [
+	['bun.lockb', 'bun'],
+	['bun.lock', 'bun'],
+	['yarn.lock', 'yarn'],
+	['pnpm-lock.yaml', 'pnpm'],
+	['package-lock.json', 'npm']
+]
+
+export function detectPackageManager(pkgJson: Record<string, unknown>, cwd: string): PackageManager {
+	const field = pkgJson.packageManager
+	if (typeof field === 'string') {
+		const name = field.split('@')[0] as PackageManager
+		if (['npm', 'yarn', 'pnpm', 'bun'].includes(name)) return name
+	}
+	for (const [file, pm] of LOCKFILE_PM) {
+		if (existsSync(resolve(cwd, file))) return pm
+	}
+	return 'npm'
+}
+
+export function expandScriptPatterns(config: NumuxConfig, cwd?: string): NumuxConfig {
+	const entries = Object.entries(config.processes)
+	const hasWildcard = entries.some(([name]) => name.startsWith('npm:'))
+	if (!hasWildcard) return config
+
+	const dir = config.cwd ?? cwd ?? process.cwd()
+	const pkgPath = resolve(dir, 'package.json')
+
+	if (!existsSync(pkgPath)) {
+		throw new Error(`npm: patterns require a package.json (looked in ${dir})`)
+	}
+
+	const pkgJson = JSON.parse(readFileSync(pkgPath, 'utf-8')) as Record<string, unknown>
+	const scripts = pkgJson.scripts as Record<string, string> | undefined
+	if (!scripts || typeof scripts !== 'object') {
+		throw new Error('package.json has no "scripts" field')
+	}
+
+	const scriptNames = Object.keys(scripts)
+	const pm = detectPackageManager(pkgJson, dir)
+
+	const expanded: Record<string, NumuxProcessConfig | string> = {}
+
+	for (const [name, value] of entries) {
+		if (!name.startsWith('npm:')) {
+			expanded[name] = value as NumuxProcessConfig | string
+			continue
+		}
+
+		const pattern = name.slice(4) // strip "npm:"
+		const template = (value ?? {}) as Partial<NumuxProcessConfig>
+
+		if (template.command) {
+			throw new Error(
+				`"${name}": wildcard processes cannot have a "command" field (commands come from package.json scripts)`
+			)
+		}
+
+		const glob = new Bun.Glob(pattern)
+		const matches = scriptNames.filter(s => glob.match(s))
+
+		if (matches.length === 0) {
+			throw new Error(
+				`"${name}": no scripts matched pattern "${pattern}". Available scripts: ${scriptNames.join(', ')}`
+			)
+		}
+
+		const colors = Array.isArray(template.color) ? template.color : undefined
+		const singleColor = typeof template.color === 'string' ? template.color : undefined
+
+		for (let i = 0; i < matches.length; i++) {
+			const scriptName = matches[i]
+
+			if (expanded[scriptName]) {
+				throw new Error(`"${name}": expanded script "${scriptName}" collides with an existing process name`)
+			}
+
+			const color = colors ? colors[i % colors.length] : singleColor
+
+			const { color: _color, ...rest } = template
+			expanded[scriptName] = {
+				...rest,
+				command: `${pm} run ${scriptName}`,
+				...(color ? { color } : {})
+			} as NumuxProcessConfig
+		}
+	}
+
+	return { ...config, processes: expanded }
+}

package/src/config/validator.ts

@@ -72,8 +72,18 @@ export function validateConfig(raw: unknown, warnings?: ValidationWarning[]): Re
 		}
 
 		// Validate color hex format
-		if (typeof p.color === 'string' && !HEX_COLOR_RE.test(p.color)) {
-			throw new Error(`Process "${name}".color must be a valid hex color (e.g. "#ff8800"), got "${p.color}"`)
+		if (typeof p.color === 'string') {
+			if (!HEX_COLOR_RE.test(p.color)) {
+				throw new Error(`Process "${name}".color must be a valid hex color (e.g. "#ff8800"), got "${p.color}"`)
+			}
+		} else if (Array.isArray(p.color)) {
+			for (const c of p.color) {
+				if (typeof c !== 'string' || !HEX_COLOR_RE.test(c)) {
+					throw new Error(
+						`Process "${name}".color entries must be valid hex colors (e.g. "#ff8800"), got "${c}"`
+					)
+				}
+			}
 		}
 
 		const persistent = typeof p.persistent === 'boolean' ? p.persistent : true
@@ -113,7 +123,7 @@ export function validateConfig(raw: unknown, warnings?: ValidationWarning[]): Re
 			delay: typeof p.delay === 'number' && p.delay > 0 ? p.delay : undefined,
 			condition: typeof p.condition === 'string' && p.condition.trim() ? p.condition.trim() : undefined,
 			stopSignal: validateStopSignal(p.stopSignal),
-			color: typeof p.color === 'string' ? p.color : undefined,
+			color: typeof p.color === 'string' ? p.color : Array.isArray(p.color) ? (p.color as string[]) : undefined,
 			watch: validateStringOrStringArray(p.watch),
 			interactive: typeof p.interactive === 'boolean' ? p.interactive : false
 		}

package/src/index.ts

@@ -3,11 +3,12 @@ import { existsSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { buildConfigFromArgs, filterConfig, parseArgs } from './cli'
 import { generateCompletions } from './completions'
+import { expandScriptPatterns } from './config/expand-scripts'
 import { loadConfig } from './config/loader'
 import { resolveDependencyTiers } from './config/resolver'
 import { type ValidationWarning, validateConfig } from './config/validator'
 import { ProcessManager } from './process/manager'
-import type { ResolvedNumuxConfig } from './types'
+import type { NumuxProcessConfig, ResolvedNumuxConfig } from './types'
 import { App } from './ui/app'
 import { PrefixDisplay } from './ui/prefix'
 import { loadEnvFiles } from './utils/env-file'
@@ -28,7 +29,8 @@ Usage:
 
 Options:
   -n, --name <name=command>  Add a named process
-  -c, --config <path>        Config file path (default: auto-detect)
+  -c, --color <colors>       Comma-separated colors for processes (hex, e.g. #ff0,#0f0)
+  --config <path>            Config file path (default: auto-detect)
   -p, --prefix               Prefixed output mode (no TUI, for CI/scripts)
   --only <a,b,...>           Only run these processes (+ their dependencies)
   --exclude <a,b,...>        Exclude these processes
@@ -100,7 +102,7 @@ async function main() {
 	}
 
 	if (parsed.validate) {
-		const raw = await loadConfig(parsed.configPath)
+		const raw = expandScriptPatterns(await loadConfig(parsed.configPath))
 		const warnings: ValidationWarning[] = []
 		let config = validateConfig(raw, warnings)
 
@@ -135,7 +137,7 @@ async function main() {
 	}
 
 	if (parsed.exec) {
-		const raw = await loadConfig(parsed.configPath)
+		const raw = expandScriptPatterns(await loadConfig(parsed.configPath))
 		const config = validateConfig(raw)
 		const proc = config.processes[parsed.execName!]
 		if (!proc) {
@@ -169,9 +171,36 @@ async function main() {
 	const warnings: ValidationWarning[] = []
 
 	if (parsed.commands.length > 0 || parsed.named.length > 0) {
-		config = buildConfigFromArgs(parsed.commands, parsed.named, { noRestart: parsed.noRestart })
+		const hasNpmPatterns = parsed.commands.some(c => c.startsWith('npm:'))
+		if (hasNpmPatterns) {
+			// Expand npm: patterns into named processes, pass remaining commands as-is
+			const npmPatterns = parsed.commands.filter(c => c.startsWith('npm:'))
+			const otherCommands = parsed.commands.filter(c => !c.startsWith('npm:'))
+			const processes: Record<string, NumuxProcessConfig | string> = {}
+			for (const pattern of npmPatterns) {
+				const entry: Partial<NumuxProcessConfig> = {}
+				if (parsed.colors?.length) entry.color = parsed.colors
+				processes[pattern] = entry as NumuxProcessConfig
+			}
+			for (let i = 0; i < otherCommands.length; i++) {
+				const cmd = otherCommands[i]
+				let name = cmd.split(/\s+/)[0].split('/').pop()!
+				if (processes[name]) name = `${name}-${i}`
+				processes[name] = cmd
+			}
+			for (const { name, command } of parsed.named) {
+				processes[name] = command
+			}
+			const expanded = expandScriptPatterns({ processes })
+			config = validateConfig(expanded, warnings)
+		} else {
+			config = buildConfigFromArgs(parsed.commands, parsed.named, {
+				noRestart: parsed.noRestart,
+				colors: parsed.colors
+			})
+		}
 	} else {
-		const raw = await loadConfig(parsed.configPath)
+		const raw = expandScriptPatterns(await loadConfig(parsed.configPath))
 		config = validateConfig(raw, warnings)
 
 		if (parsed.noRestart) {

package/src/process/manager.ts

@@ -217,10 +217,11 @@ export class ProcessManager {
 			this.fileWatcher.watch(name, patterns, cwd, changedFile => {
 				const state = this.states.get(name)
 				if (!state) return
-				// Don't restart processes that are stopped (user intentionally stopped), pending, stopping, or skipped
+				// Don't restart processes that are stopped/finished, pending, stopping, or skipped
 				if (
 					state.status === 'pending' ||
 					state.status === 'stopped' ||
+					state.status === 'finished' ||
 					state.status === 'stopping' ||
 					state.status === 'skipped'
 				)
@@ -269,6 +270,7 @@ export class ProcessManager {
 		if (
 			state.status === 'pending' ||
 			state.status === 'stopped' ||
+			state.status === 'finished' ||
 			state.status === 'stopping' ||
 			state.status === 'skipped'
 		)
@@ -300,7 +302,7 @@ export class ProcessManager {
 	start(name: string, cols: number, rows: number): void {
 		const state = this.states.get(name)
 		if (!state) return
-		if (state.status !== 'stopped' && state.status !== 'failed') return
+		if (state.status !== 'stopped' && state.status !== 'finished' && state.status !== 'failed') return
 
 		// Cancel pending auto-restart and reset backoff
 		const timer = this.restartTimers.get(name)

package/src/process/runner.ts

@@ -110,7 +110,7 @@ export class ProcessRunner {
 				// duplicate status/exit events to avoid double onStatus('failed')
 				// and unintended auto-restart scheduling.
 				if (!this.readyTimedOut) {
-					const status: ProcessStatus = this.stopping || code === 0 ? 'stopped' : 'failed'
+					const status: ProcessStatus = this.stopping ? 'stopped' : code === 0 ? 'finished' : 'failed'
 					this.handler.onStatus(status)
 					this.handler.onExit(code)
 				}

package/src/types.ts

@@ -11,17 +11,20 @@ export interface NumuxProcessConfig {
 	delay?: number // ms to wait before starting the process (default: none)
 	condition?: string // env var name (prefix with ! to negate); process skipped if condition is falsy
 	stopSignal?: 'SIGTERM' | 'SIGINT' | 'SIGHUP' // signal for graceful stop (default: SIGTERM)
-	color?: string
+	color?: string | string[]
 	watch?: string | string[] // Glob patterns — restart process when matching files change
 	interactive?: boolean // default false — when true, keyboard input is forwarded to the process
 }
 
-/** Raw config as authored — processes can be string shorthand or full objects */
+/** Config for npm: wildcard entries — command is derived from package.json scripts */
+export type NumuxScriptPattern = Omit<NumuxProcessConfig, 'command'> & { command?: never }
+
+/** Raw config as authored — processes can be string shorthand, full objects, or wildcard patterns */
 export interface NumuxConfig {
 	cwd?: string // Global working directory, inherited by all processes
 	env?: Record<string, string> // Global env vars, merged into each process (process-level overrides)
 	envFile?: string | string[] // Global .env file(s), inherited by processes without their own envFile
-	processes: Record<string, NumuxProcessConfig | string>
+	processes: Record<string, NumuxProcessConfig | NumuxScriptPattern | string>
 }
 
 /** Validated config with all shorthand expanded to full objects */
@@ -29,7 +32,16 @@ export interface ResolvedNumuxConfig {
 	processes: Record<string, NumuxProcessConfig>
 }
 
-export type ProcessStatus = 'pending' | 'starting' | 'ready' | 'running' | 'stopping' | 'stopped' | 'failed' | 'skipped'
+export type ProcessStatus =
+	| 'pending'
+	| 'starting'
+	| 'ready'
+	| 'running'
+	| 'stopping'
+	| 'stopped'
+	| 'finished'
+	| 'failed'
+	| 'skipped'
 
 export interface ProcessState {
 	name: string

package/src/ui/app.ts

@@ -29,6 +29,10 @@ export class App {
 	private searchMatches: SearchMatch[] = []
 	private searchIndex = -1
 
+	// Input-waiting detection for interactive processes
+	private inputWaitTimers = new Map<string, ReturnType<typeof setTimeout>>()
+	private awaitingInput = new Set<string>()
+
 	constructor(manager: ProcessManager, config: ResolvedNumuxConfig) {
 		this.manager = manager
 		this.config = config
@@ -113,9 +117,17 @@ export class App {
 			if (this.destroyed) return
 			if (event.type === 'output') {
 				this.panes.get(event.name)?.feed(event.data)
+				// Detect input-waiting for interactive processes
+				if (this.config.processes[event.name]?.interactive) {
+					this.checkInputWaiting(event.name, event.data)
+				}
 			} else if (event.type === 'status') {
 				const state = this.manager.getState(event.name)
 				this.tabBar.updateStatus(event.name, event.status, state?.exitCode, state?.restartCount)
+				// Clear input-waiting on non-active statuses
+				if (event.status !== 'running' && event.status !== 'ready') {
+					this.clearInputWaiting(event.name)
+				}
 			}
 		})
 
@@ -180,7 +192,7 @@ export class App {
 					// Alt+S: stop/start active process
 					if (key.name === 's' && this.activePane) {
 						const state = this.manager.getState(this.activePane)
-						if (state?.status === 'stopped' || state?.status === 'failed') {
+						if (state?.status === 'stopped' || state?.status === 'finished' || state?.status === 'failed') {
 							this.manager.start(this.activePane, this.termCols, this.termRows)
 						} else {
 							this.manager.stop(this.activePane)
@@ -194,23 +206,21 @@ export class App {
 						return
 					}
 
-					// Alt+1-9: jump to tab
+					// Alt+1-9: jump to tab (uses display order from tab bar)
 					const num = Number.parseInt(key.name, 10)
-					if (num >= 1 && num <= 9 && num <= this.names.length) {
+					if (num >= 1 && num <= 9 && num <= this.tabBar.count) {
 						this.tabBar.setSelectedIndex(num - 1)
-						this.switchPane(this.names[num - 1])
+						this.switchPane(this.tabBar.getNameAtIndex(num - 1))
 						return
 					}
 
 					// Alt+Left/Right: cycle tabs
 					if (key.name === 'left' || key.name === 'right') {
 						const current = this.tabBar.getSelectedIndex()
-						const next =
-							key.name === 'right'
-								? (current + 1) % this.names.length
-								: (current - 1 + this.names.length) % this.names.length
+						const count = this.tabBar.count
+						const next = key.name === 'right' ? (current + 1) % count : (current - 1 + count) % count
 						this.tabBar.setSelectedIndex(next)
-						this.switchPane(this.names[next])
+						this.switchPane(this.tabBar.getNameAtIndex(next))
 						return
 					}
 
@@ -283,6 +293,45 @@ export class App {
 		this.panes.get(name)?.show()
 	}
 
+	/** Detect when an interactive process is likely waiting for user input */
+	private checkInputWaiting(name: string, data: Uint8Array): void {
+		// Clear existing timer
+		const existing = this.inputWaitTimers.get(name)
+		if (existing) clearTimeout(existing)
+
+		// If we were showing awaiting input, clear it since new output arrived
+		if (this.awaitingInput.has(name)) {
+			this.awaitingInput.delete(name)
+			this.tabBar.setInputWaiting(name, false)
+		}
+
+		// If the last byte is not a newline, the process may be showing a prompt
+		const lastByte = data[data.length - 1]
+		if (lastByte !== 0x0a && lastByte !== 0x0d) {
+			const timer = setTimeout(() => {
+				this.inputWaitTimers.delete(name)
+				const state = this.manager.getState(name)
+				if (state && (state.status === 'running' || state.status === 'ready')) {
+					this.awaitingInput.add(name)
+					this.tabBar.setInputWaiting(name, true)
+				}
+			}, 200)
+			this.inputWaitTimers.set(name, timer)
+		}
+	}
+
+	private clearInputWaiting(name: string): void {
+		const timer = this.inputWaitTimers.get(name)
+		if (timer) {
+			clearTimeout(timer)
+			this.inputWaitTimers.delete(name)
+		}
+		if (this.awaitingInput.has(name)) {
+			this.awaitingInput.delete(name)
+			this.tabBar.setInputWaiting(name, false)
+		}
+	}
+
 	private enterSearch(): void {
 		this.searchMode = true
 		this.searchQuery = ''
@@ -384,6 +433,11 @@ export class App {
 			clearTimeout(this.resizeTimer)
 			this.resizeTimer = null
 		}
+		// Clear all input-waiting timers
+		for (const timer of this.inputWaitTimers.values()) {
+			clearTimeout(timer)
+		}
+		this.inputWaitTimers.clear()
 		await this.manager.stopAll()
 		for (const pane of this.panes.values()) {
 			pane.destroy()

package/src/ui/prefix.ts

@@ -102,7 +102,13 @@ export class PrefixDisplay {
 	}
 
 	private handleStatus(name: string, status: ProcessStatus): void {
-		if (status === 'ready' || status === 'failed' || status === 'stopped' || status === 'skipped') {
+		if (
+			status === 'ready' ||
+			status === 'failed' ||
+			status === 'finished' ||
+			status === 'stopped' ||
+			status === 'skipped'
+		) {
 			if (this.noColor) {
 				this.printLine(name, `→ ${status}`)
 			} else {
@@ -144,7 +150,9 @@ export class PrefixDisplay {
 	private checkAllDone(): void {
 		if (this.stopping) return
 		const states = this.manager.getAllStates()
-		const allDone = states.every(s => s.status === 'stopped' || s.status === 'failed' || s.status === 'skipped')
+		const allDone = states.every(
+			s => s.status === 'stopped' || s.status === 'finished' || s.status === 'failed' || s.status === 'skipped'
+		)
 		if (allDone) {
 			this.printSummary()
 			this.logWriter?.close()

package/src/ui/tabs.ts

@@ -1,5 +1,6 @@
 import {
 	type CliRenderer,
+	type MouseEvent,
 	type OptimizedBuffer,
 	parseColor,
 	type RGBA,
@@ -15,6 +16,7 @@ const STATUS_ICONS: Record<ProcessStatus, string> = {
 	ready: '●',
 	stopping: '◑',
 	stopped: '■',
+	finished: '✓',
 	failed: '✖',
 	skipped: '⊘'
 }
@@ -22,11 +24,15 @@ const STATUS_ICONS: Record<ProcessStatus, string> = {
 /** Status-specific icon colors (override process colors) */
 const STATUS_ICON_HEX: Partial<Record<ProcessStatus, string>> = {
 	ready: '#00cc00',
+	finished: '#66aa66',
 	failed: '#ff5555',
 	stopped: '#888888',
 	skipped: '#888888'
 }
 
+/** Statuses that represent a terminal (done) state — tabs move to bottom */
+const TERMINAL_STATUSES = new Set<ProcessStatus>(['finished', 'stopped', 'failed', 'skipped'])
+
 interface OptionColors {
 	icon: RGBA | null
 	name: RGBA | null
@@ -54,6 +60,18 @@ class ColoredSelectRenderable extends SelectRenderable {
 		}
 	}
 
+	protected onMouseEvent(event: MouseEvent): void {
+		if (event.type === 'down') {
+			const linesPerItem = (this as any).linesPerItem as number
+			const scrollOffset = (this as any).scrollOffset as number
+			const clickedIndex = scrollOffset + Math.floor(event.y / linesPerItem)
+			if (clickedIndex >= 0 && clickedIndex < this.options.length) {
+				this.setSelectedIndex(clickedIndex)
+				this.selectCurrent()
+			}
+		}
+	}
+
 	private colorizeOptions(): void {
 		const fb = this.frameBuffer!
 		// Access internal layout state (private in TS, accessible at runtime)
@@ -83,15 +101,18 @@ class ColoredSelectRenderable extends SelectRenderable {
 
 export class TabBar {
 	readonly renderable: ColoredSelectRenderable
+	private originalNames: string[]
 	private names: string[]
 	private statuses: Map<string, ProcessStatus>
-	private descriptions: Map<string, string>
+	private baseDescriptions: Map<string, string>
 	private processColors: Map<string, string>
+	private inputWaiting = new Set<string>()
 
 	constructor(renderer: CliRenderer, names: string[], colors?: Map<string, string>) {
-		this.names = names
+		this.originalNames = names
+		this.names = [...names]
 		this.statuses = new Map(names.map(n => [n, 'pending' as ProcessStatus]))
-		this.descriptions = new Map(names.map(n => [n, 'pending']))
+		this.baseDescriptions = new Map(names.map(n => [n, 'pending']))
 		this.processColors = colors ?? new Map()
 
 		this.renderable = new ColoredSelectRenderable(renderer, {
@@ -125,18 +146,67 @@ export class TabBar {
 
 	updateStatus(name: string, status: ProcessStatus, exitCode?: number | null, restartCount?: number): void {
 		this.statuses.set(name, status)
-		this.descriptions.set(name, this.formatDescription(status, exitCode, restartCount))
+		this.baseDescriptions.set(name, this.formatDescription(status, exitCode, restartCount))
+		// Clear input waiting on terminal status changes
+		if (TERMINAL_STATUSES.has(status) || status === 'stopping') {
+			this.inputWaiting.delete(name)
+		}
+		this.refreshOptions()
+	}
+
+	setInputWaiting(name: string, waiting: boolean): void {
+		if (waiting) this.inputWaiting.add(name)
+		else this.inputWaiting.delete(name)
+		this.refreshOptions()
+	}
+
+	/** Get the process name at the given display index */
+	getNameAtIndex(index: number): string {
+		return this.names[index]
+	}
+
+	get count(): number {
+		return this.names.length
+	}
+
+	private refreshOptions(): void {
+		// Preserve currently selected name
+		const currentIdx = this.renderable.getSelectedIndex()
+		const currentName = this.names[currentIdx]
+
+		// Reorder: active first, terminal states at bottom
+		this.names = this.getDisplayOrder()
+
 		this.renderable.options = this.names.map(n => ({
 			name: this.formatTab(n, this.statuses.get(n)!),
-			description: this.descriptions.get(n)!
+			description: this.getDescription(n)
 		}))
+
+		// Restore selection by name
+		const newIdx = this.names.indexOf(currentName)
+		if (newIdx >= 0 && newIdx !== currentIdx) {
+			this.renderable.setSelectedIndex(newIdx)
+		}
+
 		this.updateOptionColors()
 	}
 
+	private getDisplayOrder(): string[] {
+		const active = this.originalNames.filter(n => !TERMINAL_STATUSES.has(this.statuses.get(n)!))
+		const terminal = this.originalNames.filter(n => TERMINAL_STATUSES.has(this.statuses.get(n)!))
+		return [...active, ...terminal]
+	}
+
+	private getDescription(name: string): string {
+		if (this.inputWaiting.has(name)) return 'awaiting input'
+		return this.baseDescriptions.get(name) ?? 'pending'
+	}
+
 	private updateOptionColors(): void {
 		const colors = this.names.map(name => {
 			const status = this.statuses.get(name)!
-			const statusHex = STATUS_ICON_HEX[status]
+			const waiting = this.inputWaiting.has(name)
+			const statusHex = waiting ? '#ffaa00' : STATUS_ICON_HEX[status]
 			const processHex = this.processColors.get(name)
 			return {
 				icon: parseColor(statusHex ?? processHex ?? '#888888'),

package/src/utils/color.ts

@@ -20,6 +20,7 @@ import type { ProcessStatus, ResolvedNumuxConfig } from '../types'
 export const STATUS_ANSI: Partial<Record<ProcessStatus, string>> = {
 	ready: '\x1b[32m',
 	running: '\x1b[36m',
+	finished: '\x1b[32m',
 	failed: '\x1b[31m',
 	stopped: '\x1b[90m',
 	skipped: '\x1b[90m'
@@ -50,13 +51,20 @@ const DEFAULT_ANSI_COLORS = [
 /** Default palette as hex colors (for styled text rendering) */
 const DEFAULT_HEX_COLORS = ['#00cccc', '#cccc00', '#cc00cc', '#0000cc', '#00cc00', '#ff5555', '#ffff55', '#ff55ff']
 
+/** Resolve a color value (string or array) to a single hex string, or undefined. */
+function resolveColor(color: string | string[] | undefined): string | undefined {
+	if (typeof color === 'string') return color
+	if (Array.isArray(color) && color.length > 0) return color[0]
+	return undefined
+}
+
 /** Build a map of process names to ANSI color codes, using explicit config colors or a default palette. */
 export function buildProcessColorMap(names: string[], config: ResolvedNumuxConfig): Map<string, string> {
 	const map = new Map<string, string>()
 	if ('NO_COLOR' in process.env) return map
 	let paletteIndex = 0
 	for (const name of names) {
-		const explicit = config.processes[name]?.color
+		const explicit = resolveColor(config.processes[name]?.color)
 		if (explicit) {
 			map.set(name, hexToAnsi(explicit))
 		} else {
@@ -73,7 +81,7 @@ export function buildProcessHexColorMap(names: string[], config: ResolvedNumuxCo
 	if ('NO_COLOR' in process.env) return map
 	let paletteIndex = 0
 	for (const name of names) {
-		const explicit = config.processes[name]?.color
+		const explicit = resolveColor(config.processes[name]?.color)
 		if (explicit) {
 			map.set(name, explicit.startsWith('#') ? explicit : `#${explicit}`)
 		} else {