numux 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numux",
-  "version": "1.2.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

@@ -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

@@ -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'