numux 1.1.0 → 1.3.0

package/package.json

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

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

@@ -29,7 +29,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

@@ -20,7 +20,6 @@ export class App {
 	private sidebarWidth = 20
 
 	private config: ResolvedNumuxConfig
-	private processHexColors: Map<string, string>
 
 	private resizeTimer: ReturnType<typeof setTimeout> | null = null
 
@@ -30,11 +29,14 @@ 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
 		this.names = manager.getProcessNames()
-		this.processHexColors = buildProcessHexColorMap(this.names, config)
 	}
 
 	async start(): Promise<void> {
@@ -60,7 +62,8 @@ export class App {
 		})
 
 		// Tab bar (vertical sidebar)
-		this.tabBar = new TabBar(this.renderer, this.names, this.processHexColors)
+		const processHexColors = buildProcessHexColorMap(this.names, this.config)
+		this.tabBar = new TabBar(this.renderer, this.names, processHexColors)
 
 		// Content row: sidebar | pane
 		const contentRow = new BoxRenderable(this.renderer, {
@@ -91,15 +94,12 @@ export class App {
 		for (const name of this.names) {
 			const interactive = this.config.processes[name].interactive === true
 			const pane = new Pane(this.renderer, name, termCols, termRows, interactive)
-			pane.onScroll(() => {
-				if (name === this.activePane) this.updateScrollIndicator()
-			})
 			this.panes.set(name, pane)
 			paneContainer.add(pane.scrollBox)
 		}
 
-		// Status bar
-		this.statusBar = new StatusBar(this.renderer, this.names, this.processHexColors)
+		// Status bar (only visible during search)
+		this.statusBar = new StatusBar(this.renderer)
 
 		// Assemble layout
 		contentRow.add(sidebar)
@@ -117,13 +117,17 @@ export class App {
 			if (this.destroyed) return
 			if (event.type === 'output') {
 				this.panes.get(event.name)?.feed(event.data)
-				if (event.name === this.activePane) {
-					this.updateScrollIndicator()
+				// 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)
-				this.statusBar.updateStatus(event.name, event.status)
+				// Clear input-waiting on non-active statuses
+				if (event.status !== 'running' && event.status !== 'ready') {
+					this.clearInputWaiting(event.name)
+				}
 			}
 		})
 
@@ -188,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)
@@ -202,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
 					}
 
@@ -227,19 +229,16 @@ export class App {
 						const pane = this.panes.get(this.activePane)
 						const delta = this.termRows - 2
 						pane?.scrollBy(key.name === 'pageup' ? -delta : delta)
-						this.updateScrollIndicator()
 						return
 					}
 
 					// Alt+Home/End: scroll to top/bottom
 					if (this.activePane && key.name === 'home') {
 						this.panes.get(this.activePane)?.scrollToTop()
-						this.updateScrollIndicator()
 						return
 					}
 					if (this.activePane && key.name === 'end') {
 						this.panes.get(this.activePane)?.scrollToBottom()
-						this.updateScrollIndicator()
 						return
 					}
 				}
@@ -253,18 +252,14 @@ export class App {
 					if (key.name === 'up' || key.name === 'down') {
 						const pane = this.panes.get(this.activePane)
 						pane?.scrollBy(key.name === 'up' ? -1 : 1)
-						this.updateScrollIndicator()
 					} else if (key.name === 'pageup' || key.name === 'pagedown') {
 						const pane = this.panes.get(this.activePane)
 						const delta = this.termRows - 2
 						pane?.scrollBy(key.name === 'pageup' ? -delta : delta)
-						this.updateScrollIndicator()
 					} else if (key.name === 'home') {
 						this.panes.get(this.activePane)?.scrollToTop()
-						this.updateScrollIndicator()
 					} else if (key.name === 'end') {
 						this.panes.get(this.activePane)?.scrollToBottom()
-						this.updateScrollIndicator()
 					}
 					return
 				}
@@ -296,14 +291,45 @@ export class App {
 		}
 		this.activePane = name
 		this.panes.get(name)?.show()
-		this.updateScrollIndicator()
 	}
 
-	private updateScrollIndicator(): void {
-		if (!this.activePane) return
-		const pane = this.panes.get(this.activePane)
-		if (!pane) return
-		this.statusBar.setScrollIndicator(!pane.isAtBottom)
+	/** 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 {
@@ -398,7 +424,6 @@ export class App {
 		if (!pane) return
 		const match = this.searchMatches[this.searchIndex]
 		pane.scrollToLine(match.line)
-		this.updateScrollIndicator()
 	}
 
 	async shutdown(): Promise<void> {
@@ -408,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/status-bar.ts

@@ -1,24 +1,4 @@
-import {
-	type CliRenderer,
-	cyan,
-	fg,
-	green,
-	red,
-	reverse,
-	StyledText,
-	type TextChunk,
-	TextRenderable,
-	yellow
-} from '@opentui/core'
-import type { ProcessStatus } from '../types'
-
-const STATUS_STYLE: Partial<Record<ProcessStatus, (input: string) => TextChunk>> = {
-	ready: green,
-	running: cyan,
-	failed: red,
-	stopped: fg('#888'),
-	skipped: fg('#888')
-}
+import { type CliRenderer, cyan, red, reverse, StyledText, type TextChunk, TextRenderable, yellow } from '@opentui/core'
 
 function plain(text: string): TextChunk {
 	return { __isChunk: true, text } as TextChunk
@@ -26,20 +6,12 @@ function plain(text: string): TextChunk {
 
 export class StatusBar {
 	readonly renderable: TextRenderable
-	private statuses = new Map<string, ProcessStatus>()
-	private colors: Map<string, string>
-	private scrolledUp = false
 	private _searchMode = false
 	private _searchQuery = ''
 	private _searchMatchCount = 0
 	private _searchCurrentIndex = -1
 
-	constructor(renderer: CliRenderer, names: string[], colors?: Map<string, string>) {
-		this.colors = colors ?? new Map()
-		for (const name of names) {
-			this.statuses.set(name, 'pending')
-		}
-
+	constructor(renderer: CliRenderer) {
 		this.renderable = new TextRenderable(renderer, {
 			id: 'status-bar',
 			width: '100%',
@@ -50,17 +22,6 @@ export class StatusBar {
 		})
 	}
 
-	updateStatus(name: string, status: ProcessStatus): void {
-		this.statuses.set(name, status)
-		this.renderable.content = this.buildContent()
-	}
-
-	setScrollIndicator(scrolledUp: boolean): void {
-		if (this.scrolledUp === scrolledUp) return
-		this.scrolledUp = scrolledUp
-		this.renderable.content = this.buildContent()
-	}
-
 	setSearchMode(active: boolean, query = '', matchCount = 0, currentIndex = -1): void {
 		this._searchMode = active
 		this._searchQuery = query
@@ -73,29 +34,7 @@ export class StatusBar {
 		if (this._searchMode) {
 			return this.buildSearchContent()
 		}
-		const chunks: TextChunk[] = []
-		let first = true
-		for (const [name, status] of this.statuses) {
-			if (!first) chunks.push(plain('  '))
-			first = false
-			const styleFn = STATUS_STYLE[status]
-			const hexColor = this.colors.get(name)
-			if (styleFn) {
-				chunks.push(styleFn(`${name}:${status}`))
-			} else if (hexColor) {
-				chunks.push(fg(hexColor)(`${name}:${status}`))
-			} else {
-				chunks.push(plain(`${name}:${status}`))
-			}
-		}
-		if (this.scrolledUp) {
-			chunks.push(plain('  '))
-			chunks.push(yellow('[scrolled]'))
-		}
-		chunks.push(
-			plain('  Alt+\u2190\u2192/1-9: tabs  Alt+PgUp/Dn: scroll  Alt+R: restart  Alt+S: stop/start  Ctrl+C: quit')
-		)
-		return new StyledText(chunks)
+		return new StyledText([plain('')])
 	}
 
 	private buildSearchContent(): StyledText {

package/src/ui/tabs.ts

@@ -15,6 +15,7 @@ const STATUS_ICONS: Record<ProcessStatus, string> = {
 	ready: '●',
 	stopping: '◑',
 	stopped: '■',
+	finished: '✓',
 	failed: '✖',
 	skipped: '⊘'
 }
@@ -22,11 +23,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
@@ -83,15 +88,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 +133,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'