numux 1.4.0 → 1.5.1

package/src/process/manager.ts

@@ -1,379 +0,0 @@
-import { resolve } from 'node:path'
-import { resolveDependencyTiers } from '../config/resolver'
-import type { ProcessEvent, ProcessState, ProcessStatus, ResolvedNumuxConfig } from '../types'
-import { log } from '../utils/logger'
-import { FileWatcher } from '../utils/watcher'
-import { ProcessRunner } from './runner'
-
-type EventListener = (event: ProcessEvent) => void
-
-const BACKOFF_BASE_MS = 1000
-const BACKOFF_MAX_MS = 30_000
-const BACKOFF_RESET_MS = 10_000
-
-export class ProcessManager {
-	private config: ResolvedNumuxConfig
-	private runners = new Map<string, ProcessRunner>()
-	private states = new Map<string, ProcessState>()
-	private tiers: string[][]
-	private listeners: EventListener[] = []
-	private stopping = false
-	private lastCols = 80
-	private lastRows = 24
-	private restartAttempts = new Map<string, number>()
-	private restartTimers = new Map<string, ReturnType<typeof setTimeout>>()
-	private startTimes = new Map<string, number>()
-	private pendingReadyResolvers = new Map<string, () => void>()
-	private fileWatcher?: FileWatcher
-
-	constructor(config: ResolvedNumuxConfig) {
-		this.config = config
-		this.tiers = resolveDependencyTiers(config)
-		log(`Resolved ${this.tiers.length} dependency tiers:`, this.tiers)
-
-		for (const [name, proc] of Object.entries(config.processes)) {
-			this.states.set(name, {
-				name,
-				config: proc,
-				status: 'pending',
-				exitCode: null,
-				restartCount: 0
-			})
-		}
-	}
-
-	on(listener: EventListener): void {
-		this.listeners.push(listener)
-	}
-
-	private emit(event: ProcessEvent): void {
-		for (const listener of this.listeners) {
-			listener(event)
-		}
-	}
-
-	getState(name: string): ProcessState | undefined {
-		return this.states.get(name)
-	}
-
-	getAllStates(): ProcessState[] {
-		return [...this.states.values()]
-	}
-
-	/** Names in display order (topological) */
-	getProcessNames(): string[] {
-		return this.tiers.flat()
-	}
-
-	async startAll(cols: number, rows: number): Promise<void> {
-		log('Starting all processes')
-		this.lastCols = cols
-		this.lastRows = rows
-
-		for (const tier of this.tiers) {
-			const readyPromises: Promise<void>[] = []
-
-			for (const name of tier) {
-				const proc = this.config.processes[name]
-
-				// Evaluate condition
-				if (proc.condition && !evaluateCondition(proc.condition)) {
-					log(`Skipping ${name}: condition "${proc.condition}" not met`)
-					this.updateStatus(name, 'skipped')
-					continue
-				}
-
-				// Check if any dependency failed or was skipped
-				const deps = proc.dependsOn ?? []
-				const failedDep = deps.find(d => {
-					const s = this.states.get(d)!.status
-					return s === 'failed' || s === 'skipped'
-				})
-
-				if (failedDep) {
-					log(`Skipping ${name}: dependency ${failedDep} failed`)
-					this.updateStatus(name, 'skipped')
-					continue
-				}
-
-				const { promise, resolve } = Promise.withResolvers<void>()
-				readyPromises.push(promise)
-
-				this.pendingReadyResolvers.set(name, resolve)
-				this.createRunner(name, () => {
-					this.pendingReadyResolvers.delete(name)
-					resolve()
-				})
-				this.startProcess(name, cols, rows)
-			}
-
-			// Wait for all processes in this tier to become ready
-			if (readyPromises.length > 0) {
-				await Promise.all(readyPromises)
-			}
-		}
-
-		this.setupWatchers()
-	}
-
-	private startProcess(name: string, cols: number, rows: number): void {
-		const delay = this.config.processes[name].delay
-		if (delay) {
-			log(`[${name}] Delaying start by ${delay}ms`)
-			const timer = setTimeout(() => {
-				this.restartTimers.delete(name)
-				if (this.stopping) return
-				this.startTimes.set(name, Date.now())
-				this.runners.get(name)!.start(cols, rows)
-			}, delay)
-			this.restartTimers.set(name, timer)
-		} else {
-			this.startTimes.set(name, Date.now())
-			this.runners.get(name)!.start(cols, rows)
-		}
-	}
-
-	private createRunner(name: string, onInitialReady?: () => void): void {
-		let readyResolved = !onInitialReady
-		const runner = new ProcessRunner(name, this.config.processes[name], {
-			onStatus: status => this.updateStatus(name, status),
-			onOutput: data => this.emit({ type: 'output', name, data }),
-			onExit: code => {
-				const state = this.states.get(name)!
-				state.exitCode = code
-				this.emit({ type: 'exit', name, code })
-				if (!readyResolved) {
-					readyResolved = true
-					onInitialReady!()
-				}
-				this.scheduleAutoRestart(name, code)
-			},
-			onReady: () => {
-				if (!readyResolved) {
-					readyResolved = true
-					onInitialReady!()
-				}
-			}
-		})
-		this.runners.set(name, runner)
-	}
-
-	private scheduleAutoRestart(name: string, exitCode: number | null): void {
-		if (this.stopping) return
-		const proc = this.config.processes[name]
-		if (proc.persistent === false) return
-		if (exitCode === 0) return
-		// null exitCode means spawn failed — retrying won't help
-		if (exitCode === null) return
-		log(`Scheduling auto-restart for ${name} (exit code: ${exitCode})`)
-
-		// Reset backoff if the process ran long enough
-		const startTime = this.startTimes.get(name) ?? 0
-		if (Date.now() - startTime > BACKOFF_RESET_MS) {
-			this.restartAttempts.set(name, 0)
-		}
-
-		const attempt = this.restartAttempts.get(name) ?? 0
-
-		// Enforce maxRestarts limit
-		const maxRestarts = proc.maxRestarts
-		if (maxRestarts !== undefined && attempt >= maxRestarts) {
-			log(`[${name}] Reached maxRestarts limit (${maxRestarts}), not restarting`)
-			const encoder = new TextEncoder()
-			const msg = `\r\n\x1b[31m[numux] reached restart limit (${maxRestarts}), giving up\x1b[0m\r\n`
-			this.emit({ type: 'output', name, data: encoder.encode(msg) })
-			return
-		}
-
-		const delay = Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_MAX_MS)
-		this.restartAttempts.set(name, attempt + 1)
-
-		const encoder = new TextEncoder()
-		const msg = `\r\n\x1b[33m[numux] restarting in ${(delay / 1000).toFixed(0)}s (attempt ${attempt + 1}${maxRestarts !== undefined ? `/${maxRestarts}` : ''})...\x1b[0m\r\n`
-		this.emit({ type: 'output', name, data: encoder.encode(msg) })
-
-		const timer = setTimeout(() => {
-			this.restartTimers.delete(name)
-			if (this.stopping) return
-			const runner = this.runners.get(name)
-			if (!runner) return
-			const state = this.states.get(name)
-			if (state) state.restartCount++
-			this.startTimes.set(name, Date.now())
-			runner.restart(this.lastCols, this.lastRows)
-		}, delay)
-		this.restartTimers.set(name, timer)
-	}
-
-	private setupWatchers(): void {
-		const encoder = new TextEncoder()
-		for (const [name, proc] of Object.entries(this.config.processes)) {
-			if (!proc.watch) continue
-			if (!this.fileWatcher) this.fileWatcher = new FileWatcher()
-
-			const patterns = Array.isArray(proc.watch) ? proc.watch : [proc.watch]
-			const cwd = proc.cwd ? resolve(proc.cwd) : process.cwd()
-
-			this.fileWatcher.watch(name, patterns, cwd, changedFile => {
-				const state = this.states.get(name)
-				if (!state) return
-				// 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'
-				)
-					return
-
-				log(`[${name}] File changed: ${changedFile}, restarting`)
-				const msg = `\r\n\x1b[36m[numux] file changed: ${changedFile}, restarting...\x1b[0m\r\n`
-				this.emit({ type: 'output', name, data: encoder.encode(msg) })
-				this.restart(name, this.lastCols, this.lastRows)
-			})
-		}
-	}
-
-	private updateStatus(name: string, status: ProcessStatus): void {
-		const state = this.states.get(name)!
-		state.status = status
-		this.emit({ type: 'status', name, status })
-	}
-
-	restart(name: string, cols: number, rows: number): void {
-		const state = this.states.get(name)
-		if (!state) return
-		if (state.status === 'pending' || state.status === 'stopping' || state.status === 'skipped') return
-
-		const runner = this.runners.get(name)
-		if (!runner) return
-
-		// Cancel pending auto-restart and reset backoff
-		const timer = this.restartTimers.get(name)
-		if (timer) {
-			clearTimeout(timer)
-			this.restartTimers.delete(name)
-		}
-		this.restartAttempts.set(name, 0)
-
-		state.exitCode = null
-		state.restartCount++
-		this.startTimes.set(name, Date.now())
-		runner.restart(cols, rows)
-	}
-
-	/** Stop a single process. No-op if already stopped or not running. */
-	async stop(name: string): Promise<void> {
-		const state = this.states.get(name)
-		if (!state) return
-		if (
-			state.status === 'pending' ||
-			state.status === 'stopped' ||
-			state.status === 'finished' ||
-			state.status === 'stopping' ||
-			state.status === 'skipped'
-		)
-			return
-
-		// Cancel pending auto-restart
-		const timer = this.restartTimers.get(name)
-		if (timer) {
-			clearTimeout(timer)
-			this.restartTimers.delete(name)
-		}
-
-		const runner = this.runners.get(name)
-		if (!runner) return
-
-		// Always try to stop via runner — the process may still be alive even if
-		// status is 'failed' (e.g. readyTimeout fired but process didn't exit).
-		// runner.stop() is a no-op if proc is null (already exited).
-		if (state.status === 'failed') {
-			await runner.stop()
-			this.updateStatus(name, 'stopped')
-			return
-		}
-
-		await runner.stop()
-	}
-
-	/** Start a single process that is stopped or failed. */
-	start(name: string, cols: number, rows: number): void {
-		const state = this.states.get(name)
-		if (!state) 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)
-		if (timer) {
-			clearTimeout(timer)
-			this.restartTimers.delete(name)
-		}
-		this.restartAttempts.set(name, 0)
-
-		state.exitCode = null
-		state.restartCount++
-		this.startTimes.set(name, Date.now())
-		this.runners.get(name)?.restart(cols, rows)
-	}
-
-	/** Restart all processes. Restarts each runner in-place without dependency re-resolution. */
-	restartAll(cols: number, rows: number): void {
-		log('Restarting all processes')
-		for (const name of this.tiers.flat()) {
-			this.restart(name, cols, rows)
-		}
-	}
-
-	resize(name: string, cols: number, rows: number): void {
-		this.runners.get(name)?.resize(cols, rows)
-	}
-
-	resizeAll(cols: number, rows: number): void {
-		this.lastCols = cols
-		this.lastRows = rows
-		for (const runner of this.runners.values()) {
-			runner.resize(cols, rows)
-		}
-	}
-
-	write(name: string, data: string): void {
-		this.runners.get(name)?.write(data)
-	}
-
-	async stopAll(): Promise<void> {
-		log('Stopping all processes')
-		this.stopping = true
-		// Close file watchers
-		this.fileWatcher?.close()
-		// Cancel all pending auto-restart and delay timers
-		for (const timer of this.restartTimers.values()) {
-			clearTimeout(timer)
-		}
-		this.restartTimers.clear()
-		// Resolve any pending ready promises (e.g. processes waiting on delay)
-		for (const resolve of this.pendingReadyResolvers.values()) {
-			resolve()
-		}
-		this.pendingReadyResolvers.clear()
-		// Stop in reverse tier order — use allSettled so one failure doesn't skip remaining tiers
-		const reversed = [...this.tiers].reverse()
-		for (const tier of reversed) {
-			await Promise.allSettled(tier.map(name => this.runners.get(name)?.stop()).filter(Boolean))
-		}
-	}
-}
-
-const FALSY_VALUES = new Set(['', '0', 'false', 'no', 'off'])
-
-/** Evaluate a condition string against environment variables.
- *  `"VAR"` → truthy if VAR is set and not a falsy value.
- *  `"!VAR"` → truthy if VAR is unset or a falsy value. */
-function evaluateCondition(condition: string): boolean {
-	const negated = condition.startsWith('!')
-	const varName = negated ? condition.slice(1) : condition
-	const value = process.env[varName]
-	const isTruthy = value !== undefined && !FALSY_VALUES.has(value.toLowerCase())
-	return negated ? !isTruthy : isTruthy
-}

package/src/process/ready.ts

@@ -1,45 +0,0 @@
-import type { NumuxProcessConfig } from '../types'
-
-/** Keep the last 64 KB of output for pattern matching */
-const BUFFER_CAP = 65_536
-
-/**
- * Determines when a process should be considered "ready"
- * based on its configuration.
- */
-export function createReadinessChecker(config: NumuxProcessConfig) {
-	const pattern = config.readyPattern ? new RegExp(config.readyPattern) : null
-	const persistent = config.persistent !== false
-	let outputBuffer = ''
-
-	return {
-		/**
-		 * Feed process output data. Returns true if the process
-		 * should now be considered ready.
-		 */
-		feedOutput(data: string): boolean {
-			if (!(persistent && pattern)) return false
-			outputBuffer += data
-			if (outputBuffer.length > BUFFER_CAP) {
-				outputBuffer = outputBuffer.slice(-BUFFER_CAP)
-			}
-			return pattern.test(outputBuffer)
-		},
-
-		/**
-		 * Returns true if the process is immediately ready on spawn
-		 * (persistent with no readyPattern).
-		 */
-		get isImmediatelyReady(): boolean {
-			return persistent && !pattern
-		},
-
-		/**
-		 * Returns true if readiness depends on exit code
-		 * (non-persistent processes).
-		 */
-		get dependsOnExit(): boolean {
-			return !persistent
-		}
-	}
-}

package/src/process/runner.ts

@@ -1,243 +0,0 @@
-import { resolve } from 'node:path'
-import type { NumuxProcessConfig, ProcessStatus } from '../types'
-import { loadEnvFiles } from '../utils/env-file'
-import { log } from '../utils/logger'
-import { createReadinessChecker } from './ready'
-
-export type RunnerEventHandler = {
-	onStatus: (status: ProcessStatus) => void
-	onOutput: (data: Uint8Array) => void
-	onExit: (code: number | null) => void
-	onReady: () => void
-}
-
-export class ProcessRunner {
-	readonly name: string
-	private config: NumuxProcessConfig
-	private handler: RunnerEventHandler
-	private proc: ReturnType<typeof Bun.spawn> | null = null
-	private readiness: ReturnType<typeof createReadinessChecker>
-	private _ready = false
-	private stopping = false
-	private decoder = new TextDecoder()
-	private generation = 0
-	private readyTimer: ReturnType<typeof setTimeout> | null = null
-	private restarting = false
-	private readyTimedOut = false
-
-	constructor(name: string, config: NumuxProcessConfig, handler: RunnerEventHandler) {
-		this.name = name
-		this.config = config
-		this.handler = handler
-		this.readiness = createReadinessChecker(config)
-	}
-
-	get isReady(): boolean {
-		return this._ready
-	}
-
-	private get signal(): NodeJS.Signals {
-		return this.config.stopSignal ?? 'SIGTERM'
-	}
-
-	start(cols: number, rows: number): void {
-		const gen = ++this.generation
-		this.stopping = false
-		log(`[${this.name}] Starting (gen ${gen}): ${this.config.command}`)
-		this.handler.onStatus('starting')
-
-		const cwd = this.config.cwd ? resolve(this.config.cwd) : process.cwd()
-
-		try {
-			const envFromFile = this.config.envFile ? loadEnvFiles(this.config.envFile, cwd) : {}
-			const noColor = 'NO_COLOR' in process.env
-			const env: Record<string, string> = {
-				...(process.env as Record<string, string>),
-				...(noColor ? {} : { FORCE_COLOR: '1' }),
-				TERM: 'xterm-256color',
-				...envFromFile,
-				...this.config.env
-			}
-
-			this.proc = Bun.spawn(['sh', '-c', this.config.command], {
-				cwd,
-				env,
-				terminal: {
-					cols,
-					rows,
-					data: (_terminal, data) => {
-						if (this.generation !== gen) return
-						this.handler.onOutput(data)
-						this.checkReadiness(data)
-					}
-				}
-			})
-		} catch (err) {
-			log(`[${this.name}] Spawn failed: ${err}`)
-			const encoder = new TextEncoder()
-			const msg = `\r\n\x1b[31m[numux] failed to start: ${err instanceof Error ? err.message : err}\x1b[0m\r\n`
-			this.handler.onOutput(encoder.encode(msg))
-			this.handler.onStatus('failed')
-			this.handler.onExit(null)
-			return
-		}
-
-		this.handler.onStatus(this.config.persistent !== false ? 'running' : 'starting')
-
-		if (this.readiness.isImmediatelyReady) {
-			this.markReady()
-		}
-
-		this.startReadyTimeout(gen)
-
-		this.proc.exited
-			.then(code => {
-				if (this.generation !== gen) return
-				log(`[${this.name}] Exited with code ${code}`)
-
-				if (this.readiness.dependsOnExit && code === 0) {
-					this.markReady()
-				}
-
-				if (code === 127 || code === 126) {
-					const encoder = new TextEncoder()
-					const hint = code === 127 ? 'command not found' : 'permission denied'
-					const msg = `\r\n\x1b[31m[numux] exit ${code}: ${hint}\x1b[0m\r\n`
-					this.handler.onOutput(encoder.encode(msg))
-				}
-
-				// When readyTimeout already marked the process as failed, suppress
-				// duplicate status/exit events to avoid double onStatus('failed')
-				// and unintended auto-restart scheduling.
-				if (!this.readyTimedOut) {
-					const status: ProcessStatus = this.stopping ? 'stopped' : code === 0 ? 'finished' : 'failed'
-					this.handler.onStatus(status)
-					this.handler.onExit(code)
-				}
-			})
-			.catch(err => {
-				if (this.generation !== gen) return
-				log(`[${this.name}] proc.exited rejected: ${err}`)
-				this.handler.onStatus('failed')
-				this.handler.onExit(null)
-			})
-	}
-
-	private checkReadiness(data: Uint8Array): void {
-		if (this._ready) return
-		const text = this.decoder.decode(data, { stream: true })
-		if (this.readiness.feedOutput(text)) {
-			this.markReady()
-		}
-	}
-
-	private startReadyTimeout(gen: number): void {
-		const timeout = this.config.readyTimeout
-		if (!(timeout && this.config.readyPattern) || this.config.persistent === false) return
-
-		this.readyTimer = setTimeout(() => {
-			this.readyTimer = null
-			if (this.generation !== gen || this._ready) return
-			this.readyTimedOut = true
-			log(`[${this.name}] Ready timeout after ${timeout}ms`)
-			const encoder = new TextEncoder()
-			const msg = `\r\n\x1b[31m[numux] readyPattern not matched within ${(timeout / 1000).toFixed(0)}s — marking as failed\x1b[0m\r\n`
-			this.handler.onOutput(encoder.encode(msg))
-			this.handler.onStatus('failed')
-			this.handler.onReady() // unblock the dependency tier
-		}, timeout)
-	}
-
-	private clearReadyTimeout(): void {
-		if (this.readyTimer) {
-			clearTimeout(this.readyTimer)
-			this.readyTimer = null
-		}
-	}
-
-	private markReady(): void {
-		if (this._ready) return
-		this._ready = true
-		this.clearReadyTimeout()
-		log(`[${this.name}] Ready`)
-		this.handler.onStatus('ready')
-		this.handler.onReady()
-	}
-
-	async restart(cols: number, rows: number): Promise<void> {
-		if (this.restarting) return
-		this.restarting = true
-		log(`[${this.name}] Restarting`)
-		this.clearReadyTimeout()
-		if (this.proc) {
-			this.stopping = true
-			this.handler.onStatus('stopping')
-			this.killProcessGroup(this.signal)
-			const result = await Promise.race([
-				this.proc.exited.then(() => 'exited' as const),
-				new Promise<'timeout'>(r => setTimeout(() => r('timeout'), 2000))
-			])
-			if (result === 'timeout' && this.proc) {
-				this.killProcessGroup('SIGKILL')
-				await this.proc.exited
-			}
-		}
-		this.proc = null
-		this._ready = false
-		this.restarting = false
-		this.readyTimedOut = false
-		this.readiness = createReadinessChecker(this.config)
-		this.start(cols, rows)
-	}
-
-	async stop(timeoutMs = 5000): Promise<void> {
-		if (!this.proc) return
-
-		this.clearReadyTimeout()
-		this.stopping = true
-		log(`[${this.name}] Stopping (timeout: ${timeoutMs}ms)`)
-		this.handler.onStatus('stopping')
-		this.killProcessGroup(this.signal)
-
-		const exited = Promise.race([
-			this.proc.exited,
-			new Promise<'timeout'>(r => setTimeout(() => r('timeout'), timeoutMs))
-		])
-
-		const result = await exited
-		if (result === 'timeout') {
-			this.killProcessGroup('SIGKILL')
-			await this.proc.exited
-		}
-
-		this.proc = null
-	}
-
-	/** Signal the entire process group (child + its descendants), falling back to direct PID */
-	private killProcessGroup(sig: NodeJS.Signals): void {
-		if (!this.proc) return
-		try {
-			// Negative PID signals the entire process group
-			process.kill(-this.proc.pid, sig)
-		} catch {
-			// Process group may not exist; fall back to direct kill
-			try {
-				this.proc.kill(sig)
-			} catch {
-				// Process already exited
-			}
-		}
-	}
-
-	resize(cols: number, rows: number): void {
-		if (this.proc?.terminal) {
-			this.proc.terminal.resize(cols, rows)
-		}
-	}
-
-	write(data: string): void {
-		if (this.config.interactive && this.proc?.terminal) {
-			this.proc.terminal.write(data)
-		}
-	}
-}