numux 1.3.0 → 1.4.0

package/package.json

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

package/src/ui/tabs.ts

@@ -1,5 +1,6 @@
 import {
 	type CliRenderer,
+	type MouseEvent,
 	type OptimizedBuffer,
 	parseColor,
 	type RGBA,
@@ -59,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)

package/src/utils/color.ts

@@ -51,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 {
@@ -74,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 {