numux 1.3.0 → 1.5.0

package/README.md

@@ -264,7 +264,7 @@ Persistent processes that crash are auto-restarted with exponential backoff (1s
 | `Alt+L` | Clear active pane output |
 | `Alt+1`–`Alt+9` | Jump to tab |
 | `Alt+Left/Right` | Cycle tabs |
-| `Up/Down` | Scroll output 1 line (non-interactive panes) |
+| `Up/Down` | Navigate between tabs |
 | `PageUp/PageDown` | Scroll output by page (non-interactive panes) |
 | `Home/End` | Scroll to top/bottom (non-interactive panes) |
 | `Alt+PageUp/PageDown` | Scroll output up/down |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numux",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Terminal multiplexer with dependency orchestration",
   "type": "module",
   "license": "MIT",
@@ -27,7 +27,7 @@
     ".": "./src/config.ts"
   },
   "scripts": {
-    "dev": "bun run src/index.ts",
+    "dev": "cd example && bun run dev --debug",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
     "lint": "biome check .",

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/app.ts

@@ -2,6 +2,7 @@ import { BoxRenderable, type CliRenderer, createCliRenderer } from '@opentui/cor
 import type { ProcessManager } from '../process/manager'
 import type { ResolvedNumuxConfig } from '../types'
 import { buildProcessHexColorMap } from '../utils/color'
+import { log } from '../utils/logger'
 import { Pane, type SearchMatch } from './pane'
 import { StatusBar } from './status-bar'
 import { TabBar } from './tabs'
@@ -149,6 +150,8 @@ export class App {
 		this.renderer.keyInput.on(
 			'keypress',
 			(key: { ctrl: boolean; shift: boolean; meta: boolean; name: string; sequence: string }) => {
+				log(key)
+
 				// Ctrl+C: quit (always works)
 				if (key.ctrl && key.name === 'c') {
 					if (this.searchMode) {
@@ -167,30 +170,34 @@ export class App {
 					return
 				}
 
-				// Alt+Shift combos
-				if (key.meta && key.shift && !key.ctrl) {
-					// Alt+Shift+R: restart all processes
-					if (key.name === 'r') {
+				if (!this.activePane) return
+
+				const isInteractive = this.config.processes[this.activePane]?.interactive === true
+
+				// Non-interactive panes: plain keys act as shortcuts
+				if (!isInteractive) {
+					const name = key.name.toLowerCase()
+
+					// Shift+R: restart all processes
+					if (key.shift && name === 'r') {
 						this.manager.restartAll(this.termCols, this.termRows)
 						return
 					}
-				}
 
-				if (key.meta && !key.ctrl && !key.shift) {
-					// Alt+F: enter search mode
-					if (key.name === 'f' && this.activePane) {
+					// F: enter search mode
+					if (name === 'f') {
 						this.enterSearch()
 						return
 					}
 
-					// Alt+R: restart active process
-					if (key.name === 'r' && this.activePane) {
+					// R: restart active process
+					if (name === 'r') {
 						this.manager.restart(this.activePane, this.termCols, this.termRows)
 						return
 					}
 
-					// Alt+S: stop/start active process
-					if (key.name === 's' && this.activePane) {
+					// S: stop/start active process
+					if (name === 's') {
 						const state = this.manager.getState(this.activePane)
 						if (state?.status === 'stopped' || state?.status === 'finished' || state?.status === 'failed') {
 							this.manager.start(this.activePane, this.termCols, this.termRows)
@@ -200,80 +207,61 @@ export class App {
 						return
 					}
 
-					// Alt+L: clear active pane
-					if (key.name === 'l' && this.activePane) {
+					// L: clear active pane
+					if (name === 'l') {
 						this.panes.get(this.activePane)?.clear()
 						return
 					}
 
-					// Alt+1-9: jump to tab (uses display order from tab bar)
-					const num = Number.parseInt(key.name, 10)
+					// 1-9: jump to tab (uses display order from tab bar)
+					const num = Number.parseInt(name, 10)
 					if (num >= 1 && num <= 9 && num <= this.tabBar.count) {
 						this.tabBar.setSelectedIndex(num - 1)
 						this.switchPane(this.tabBar.getNameAtIndex(num - 1))
 						return
 					}
 
-					// Alt+Left/Right: cycle tabs
-					if (key.name === 'left' || key.name === 'right') {
+					// Left/Right: cycle tabs
+					if (name === 'left' || name === 'right') {
 						const current = this.tabBar.getSelectedIndex()
 						const count = this.tabBar.count
-						const next = key.name === 'right' ? (current + 1) % count : (current - 1 + count) % count
+						const next = name === 'right' ? (current + 1) % count : (current - 1 + count) % count
 						this.tabBar.setSelectedIndex(next)
 						this.switchPane(this.tabBar.getNameAtIndex(next))
 						return
 					}
 
-					// Alt+PageUp/PageDown: scroll output
-					if (this.activePane && (key.name === 'pageup' || key.name === 'pagedown')) {
+					// PageUp/PageDown: scroll by page
+					if (name === 'pageup' || name === 'pagedown') {
 						const pane = this.panes.get(this.activePane)
 						const delta = this.termRows - 2
-						pane?.scrollBy(key.name === 'pageup' ? -delta : delta)
+						pane?.scrollBy(name === 'pageup' ? -delta : delta)
 						return
 					}
 
-					// Alt+Home/End: scroll to top/bottom
-					if (this.activePane && key.name === 'home') {
+					// Home/End: scroll to top/bottom
+					if (name === 'home') {
 						this.panes.get(this.activePane)?.scrollToTop()
 						return
 					}
-					if (this.activePane && key.name === 'end') {
+					if (name === 'end') {
 						this.panes.get(this.activePane)?.scrollToBottom()
 						return
 					}
-				}
-
-				if (!this.activePane) return
-
-				const isInteractive = this.config.processes[this.activePane]?.interactive === true
-
-				// Non-interactive panes: arrow keys scroll, all other input is dropped
-				if (!isInteractive) {
-					if (key.name === 'up' || key.name === 'down') {
-						const pane = this.panes.get(this.activePane)
-						pane?.scrollBy(key.name === 'up' ? -1 : 1)
-					} 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)
-					} else if (key.name === 'home') {
-						this.panes.get(this.activePane)?.scrollToTop()
-					} else if (key.name === 'end') {
-						this.panes.get(this.activePane)?.scrollToBottom()
-					}
 					return
 				}
 
-				// Forward all other input to the active process
+				// Forward all other input to the active process (interactive mode)
 				if (key.sequence) {
 					this.manager.write(this.activePane, key.sequence)
 				}
 			}
 		)
 
-		// Show first pane
+		// Show first pane and focus sidebar for keyboard navigation
 		if (this.names.length > 0) {
 			this.switchPane(this.names[0])
+			this.tabBar.focus()
 		}
 
 		// Start all processes

package/src/ui/status-bar.ts

@@ -34,7 +34,9 @@ export class StatusBar {
 		if (this._searchMode) {
 			return this.buildSearchContent()
 		}
-		return new StyledText([plain('')])
+		return new StyledText([
+			plain('\u2190\u2192/1-9: tabs  R: restart  S: stop/start  F: search  L: clear  Ctrl+C: quit')
+		])
 	}
 
 	private buildSearchContent(): StyledText {

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 {

package/src/utils/logger.ts

@@ -3,6 +3,7 @@ import { resolve } from 'node:path'
 
 let enabled = false
 let logFile = ''
+let debugCallback: ((line: string) => void) | null = null
 
 export function enableDebugLog(dir?: string): void {
 	const logDir = dir ?? resolve(process.cwd(), '.numux')
@@ -13,12 +14,18 @@ export function enableDebugLog(dir?: string): void {
 	enabled = true
 }
 
-export function log(message: string, ...args: unknown[]): void {
+export function setDebugCallback(cb: ((line: string) => void) | null): void {
+	debugCallback = cb
+}
+export function log(...args: unknown[]): void {
 	if (!enabled) return
 	try {
 		const timestamp = new Date().toISOString()
-		const formatted = args.length > 0 ? `${message} ${args.map(a => JSON.stringify(a)).join(' ')}` : message
-		appendFileSync(logFile, `[${timestamp}] ${formatted}\n`)
+		const formatted =
+			args.length > 0 ? `${args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}` : ''
+		const line = `[${timestamp}] ${formatted}`
+		appendFileSync(logFile, `${line}\n`)
+		debugCallback?.(line)
 	} catch {
 		// Disk errors in debug logging should not crash the app
 		enabled = false
@@ -29,4 +36,5 @@ export function log(message: string, ...args: unknown[]): void {
 export function _resetLogger(): void {
 	enabled = false
 	logFile = ''
+	debugCallback = null
 }