numux 1.6.0 → 1.8.0

package/README.md

@@ -178,7 +178,7 @@ Each process accepts:
 | `delay` | `number` | — | Milliseconds to wait before starting the process |
 | `condition` | `string` | — | Env var name; process skipped if falsy. Prefix with `!` to negate |
 | `stopSignal` | `string` | `SIGTERM` | Signal for graceful stop (`SIGTERM`, `SIGINT`, or `SIGHUP`) |
-| `color` | `string` | auto | Hex color for tab icon and status bar (e.g. `"#ff6600"`) |
+| `color` | `string \| string[]` | auto | Hex (e.g. `"#ff6600"`) or basic name: black, red, green, yellow, blue, magenta, cyan, white, gray, orange, purple |
 | `watch` | `string \| string[]` | — | Glob patterns — restart process when matching files change |
 | `interactive` | `boolean` | `false` | When `true`, keyboard input is forwarded to the process |
 

package/dist/numux.js

@@ -22,7 +22,7 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "numux",
-    version: "1.6.0",
+    version: "1.8.0",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -92,6 +92,7 @@ function parseArgs(argv) {
     timestamps: false,
     noRestart: false,
     noWatch: false,
+    autoColors: false,
     configPath: undefined,
     commands: [],
     named: []
@@ -123,6 +124,8 @@ function parseArgs(argv) {
       result.noRestart = true;
     } else if (arg === "--no-watch") {
       result.noWatch = true;
+    } else if (arg === "--colors") {
+      result.autoColors = true;
     } else if (arg === "--config") {
       result.configPath = consumeValue(arg);
     } else if (arg === "-c" || arg === "--color") {
@@ -279,7 +282,7 @@ _numux() {
   esac
 
   if [[ "$cur" == -* ]]; then
-    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") )
+    COMPREPLY=( $(compgen -W "-h --help -v --version -c --color --colors --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") )
@@ -304,6 +307,7 @@ _numux() {
     '(-h --help)'{-h,--help}'[Show help]' \\
     '(-v --version)'{-v,--version}'[Show version]' \\
     '(-c --color)'{-c,--color}'[Comma-separated colors for processes]' \\
+    '--colors[Auto-assign colors based on process name]' \\
     '--config[Config file path]:file:_files' \\
     '(-n --name)'{-n,--name}'[Named process (name=command)]:named process' \\
     '(-p --prefix)'{-p,--prefix}'[Prefixed output mode]' \\
@@ -346,6 +350,7 @@ complete -c numux -n '__fish_seen_subcommand_from completions' -a 'bash zsh fish
 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 color -r -d 'Comma-separated colors for processes'
+complete -c numux -l colors -d 'Auto-assign colors based on process name'
 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'
@@ -592,6 +597,31 @@ function findCycle(remaining, config) {
 }
 
 // src/utils/color.ts
+var BASIC_COLORS = {
+  black: "#000000",
+  red: "#ff0000",
+  green: "#00ff00",
+  yellow: "#ffff00",
+  blue: "#0000ff",
+  magenta: "#ff00ff",
+  cyan: "#00ffff",
+  white: "#ffffff",
+  gray: "#808080",
+  grey: "#808080",
+  orange: "#ffa500",
+  purple: "#800080"
+};
+function isValidColor(color) {
+  if (HEX_COLOR_RE.test(color))
+    return true;
+  return color.toLowerCase() in BASIC_COLORS;
+}
+function resolveToHex(color) {
+  if (HEX_COLOR_RE.test(color))
+    return color.startsWith("#") ? color : `#${color}`;
+  const hex = BASIC_COLORS[color.toLowerCase()];
+  return hex ?? "";
+}
 function hexToAnsi(hex) {
   const h = hex.replace("#", "");
   const r = Number.parseInt(h.slice(0, 2), 16);
@@ -626,6 +656,13 @@ var DEFAULT_ANSI_COLORS = [
   "\x1B[95m"
 ];
 var DEFAULT_HEX_COLORS = ["#00cccc", "#cccc00", "#cc00cc", "#0000cc", "#00cc00", "#ff5555", "#ffff55", "#ff55ff"];
+function colorFromName(name) {
+  let hash = 0;
+  for (let i = 0;i < name.length; i++) {
+    hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+  }
+  return DEFAULT_HEX_COLORS[Math.abs(hash) % DEFAULT_HEX_COLORS.length];
+}
 function resolveColor(color) {
   if (typeof color === "string")
     return color;
@@ -641,7 +678,11 @@ function buildProcessColorMap(names, config) {
   for (const name of names) {
     const explicit = resolveColor(config.processes[name]?.color);
     if (explicit) {
-      map.set(name, hexToAnsi(explicit));
+      const hex = resolveToHex(explicit);
+      if (hex)
+        map.set(name, hexToAnsi(hex));
+      else
+        map.set(name, DEFAULT_ANSI_COLORS[paletteIndex++ % DEFAULT_ANSI_COLORS.length]);
     } else {
       map.set(name, DEFAULT_ANSI_COLORS[paletteIndex % DEFAULT_ANSI_COLORS.length]);
       paletteIndex++;
@@ -657,7 +698,11 @@ function buildProcessHexColorMap(names, config) {
   for (const name of names) {
     const explicit = resolveColor(config.processes[name]?.color);
     if (explicit) {
-      map.set(name, explicit.startsWith("#") ? explicit : `#${explicit}`);
+      const hex = resolveToHex(explicit);
+      if (hex)
+        map.set(name, hex);
+      else
+        map.set(name, DEFAULT_HEX_COLORS[paletteIndex++ % DEFAULT_HEX_COLORS.length]);
     } else {
       map.set(name, DEFAULT_HEX_COLORS[paletteIndex % DEFAULT_HEX_COLORS.length]);
       paletteIndex++;
@@ -721,13 +766,13 @@ function validateConfig(raw, warnings) {
       }
     }
     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}"`);
+      if (!isValidColor(p.color)) {
+        throw new Error(`Process "${name}".color must be a hex color (e.g. "#ff8800") or basic name (black, red, green, yellow, blue, magenta, cyan, white, gray, orange, purple), 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}"`);
+        if (typeof c !== "string" || !isValidColor(c)) {
+          throw new Error(`Process "${name}".color entries must be hex or basic names (black, red, green, yellow, blue, magenta, cyan, white, gray, orange), got "${c}"`);
         }
       }
     }
@@ -764,7 +809,8 @@ function validateConfig(raw, warnings) {
       stopSignal: validateStopSignal(p.stopSignal),
       color: typeof p.color === "string" ? p.color : Array.isArray(p.color) ? p.color : undefined,
       watch: validateStringOrStringArray(p.watch),
-      interactive: typeof p.interactive === "boolean" ? p.interactive : false
+      interactive: typeof p.interactive === "boolean" ? p.interactive : false,
+      errorMatcher: validateErrorMatcher(name, p.errorMatcher)
     };
   }
   return { processes: validated };
@@ -777,6 +823,22 @@ function validateStringOrStringArray(value) {
   return;
 }
 var validateEnvFile = validateStringOrStringArray;
+function validateErrorMatcher(name, value) {
+  if (value === true)
+    return true;
+  if (typeof value === "string" && value.trim()) {
+    try {
+      new RegExp(value);
+    } catch (err) {
+      throw new Error(`Process "${name}".errorMatcher is not a valid regex: "${value}"`, { cause: err });
+    }
+    return value;
+  }
+  if (value !== undefined && value !== false) {
+    throw new Error(`Process "${name}".errorMatcher must be true or a regex string`);
+  }
+  return;
+}
 var VALID_STOP_SIGNALS = new Set(["SIGTERM", "SIGINT", "SIGHUP"]);
 function validateStopSignal(value) {
   if (typeof value === "string" && VALID_STOP_SIGNALS.has(value)) {
@@ -884,8 +946,49 @@ function loadEnvFiles(envFile, cwd) {
   return merged;
 }
 
-// src/process/ready.ts
+// src/process/error.ts
 var BUFFER_CAP = 65536;
+var SGR_RE = /\x1b\[([0-9;]*)m/g;
+function hasAnsiRed(text) {
+  SGR_RE.lastIndex = 0;
+  for (let match = SGR_RE.exec(text);match !== null; match = SGR_RE.exec(text)) {
+    const params = match[1].split(";");
+    if (params.includes("31") || params.includes("91"))
+      return true;
+  }
+  return false;
+}
+function createErrorChecker(config) {
+  const matcher = config.errorMatcher;
+  if (!matcher)
+    return null;
+  const pattern = typeof matcher === "string" ? new RegExp(matcher) : null;
+  let buffer = "";
+  let triggered = false;
+  return {
+    feedOutput(data) {
+      if (triggered)
+        return false;
+      buffer += data;
+      if (buffer.length > BUFFER_CAP) {
+        buffer = buffer.slice(-BUFFER_CAP);
+      }
+      if (pattern) {
+        if (pattern.test(stripAnsi(buffer))) {
+          triggered = true;
+          return true;
+        }
+      } else if (hasAnsiRed(buffer)) {
+        triggered = true;
+        return true;
+      }
+      return false;
+    }
+  };
+}
+
+// src/process/ready.ts
+var BUFFER_CAP2 = 65536;
 function createReadinessChecker(config) {
   const pattern = config.readyPattern ? new RegExp(config.readyPattern) : null;
   const persistent = config.persistent !== false;
@@ -895,8 +998,8 @@ function createReadinessChecker(config) {
       if (!(persistent && pattern))
         return false;
       outputBuffer += data;
-      if (outputBuffer.length > BUFFER_CAP) {
-        outputBuffer = outputBuffer.slice(-BUFFER_CAP);
+      if (outputBuffer.length > BUFFER_CAP2) {
+        outputBuffer = outputBuffer.slice(-BUFFER_CAP2);
       }
       return pattern.test(outputBuffer);
     },
@@ -916,9 +1019,11 @@ class ProcessRunner {
   handler;
   proc = null;
   readiness;
+  errorChecker;
   _ready = false;
   stopping = false;
   decoder = new TextDecoder;
+  errorDecoder = new TextDecoder;
   generation = 0;
   readyTimer = null;
   restarting = false;
@@ -928,6 +1033,7 @@ class ProcessRunner {
     this.config = config;
     this.handler = handler;
     this.readiness = createReadinessChecker(config);
+    this.errorChecker = createErrorChecker(config);
   }
   get isReady() {
     return this._ready;
@@ -962,6 +1068,7 @@ class ProcessRunner {
               return;
             this.handler.onOutput(data);
             this.checkReadiness(data);
+            this.checkError(data);
           }
         }
       });
@@ -1017,6 +1124,14 @@ class ProcessRunner {
       this.markReady();
     }
   }
+  checkError(data) {
+    if (!this.errorChecker)
+      return;
+    const text = this.errorDecoder.decode(data, { stream: true });
+    if (this.errorChecker.feedOutput(text)) {
+      this.handler.onError();
+    }
+  }
   startReadyTimeout(gen) {
     const timeout = this.config.readyTimeout;
     if (!(timeout && this.config.readyPattern) || this.config.persistent === false)
@@ -1075,6 +1190,7 @@ class ProcessRunner {
     this.restarting = false;
     this.readyTimedOut = false;
     this.readiness = createReadinessChecker(this.config);
+    this.errorChecker = createErrorChecker(this.config);
     this.start(cols, rows);
   }
   async stop(timeoutMs = 5000) {
@@ -1244,7 +1360,8 @@ class ProcessManager {
           readyResolved = true;
           onInitialReady();
         }
-      }
+      },
+      onError: () => this.emit({ type: "error", name })
     });
     this.runners.set(name, runner);
   }
@@ -1651,20 +1768,24 @@ class ColoredSelectRenderable extends SelectRenderable {
     const scrollOffset = this.scrollOffset;
     const maxVisibleItems = this.maxVisibleItems;
     const linesPerItem = this.linesPerItem;
+    const selectedIndex = this.getSelectedIndex();
     const options = this.options;
     const visibleCount = Math.min(maxVisibleItems, options.length - scrollOffset);
+    const baseTextColor = this._focused ? this._focusedTextColor : this._textColor;
+    const selectedTextColor = this._selectedTextColor;
     for (let i = 0;i < visibleCount; i++) {
       const actualIndex = scrollOffset + i;
-      const colors = this._optionColors[actualIndex];
-      if (!colors)
-        continue;
       const itemY = i * linesPerItem;
       const optName = options[actualIndex].name;
-      if (colors.icon) {
-        fb.drawText(optName.charAt(0), 3, itemY, colors.icon);
+      const isSelected = actualIndex === selectedIndex;
+      const defaultColor = isSelected ? selectedTextColor : baseTextColor;
+      const colors = this._optionColors[actualIndex];
+      fb.drawText(`${optName}  `, 1, itemY, defaultColor);
+      if (colors?.icon) {
+        fb.drawText(optName.charAt(0), 1, itemY, colors.icon);
       }
-      if (colors.name) {
-        fb.drawText(optName.slice(2), 5, itemY, colors.name);
+      if (colors?.name) {
+        fb.drawText(optName.slice(2), 3, itemY, colors.name);
       }
     }
   }
@@ -1678,6 +1799,7 @@ class TabBar {
   baseDescriptions;
   processColors;
   inputWaiting = new Set;
+  erroredProcesses = new Set;
   constructor(renderer, names, colors) {
     this.originalNames = names;
     this.names = [...names];
@@ -1716,6 +1838,9 @@ class TabBar {
     if (TERMINAL_STATUSES.has(status) || status === "stopping") {
       this.inputWaiting.delete(name);
     }
+    if (status === "starting") {
+      this.erroredProcesses.delete(name);
+    }
     this.refreshOptions();
   }
   setInputWaiting(name, waiting) {
@@ -1725,6 +1850,13 @@ class TabBar {
       this.inputWaiting.delete(name);
     this.refreshOptions();
   }
+  setError(name, hasError) {
+    if (hasError)
+      this.erroredProcesses.add(name);
+    else
+      this.erroredProcesses.delete(name);
+    this.refreshOptions();
+  }
   getNameAtIndex(index) {
     return this.names[index];
   }
@@ -1753,13 +1885,16 @@ class TabBar {
   getDescription(name) {
     if (this.inputWaiting.has(name))
       return "awaiting input";
+    if (this.erroredProcesses.has(name))
+      return "error detected";
     return this.baseDescriptions.get(name) ?? "pending";
   }
   updateOptionColors() {
     const colors = this.names.map((name) => {
       const status = this.statuses.get(name);
       const waiting = this.inputWaiting.has(name);
-      const statusHex = waiting ? "#ffaa00" : STATUS_ICON_HEX[status];
+      const errored = this.erroredProcesses.has(name);
+      const statusHex = waiting ? "#ffaa00" : errored ? "#ff5555" : STATUS_ICON_HEX[status];
       const processHex = this.processColors.get(name);
       return {
         icon: parseColor(statusHex ?? processHex ?? "#888888"),
@@ -1881,6 +2016,8 @@ class App {
         if (this.config.processes[event.name]?.interactive) {
           this.checkInputWaiting(event.name, event.data);
         }
+      } else if (event.type === "error") {
+        this.tabBar.setError(event.name, true);
       } else if (event.type === "status") {
         const state = this.manager.getState(event.name);
         this.tabBar.updateStatus(event.name, event.status, state?.exitCode, state?.restartCount);
@@ -2403,7 +2540,8 @@ Usage:
 
 Options:
   -n, --name <name=command>  Add a named process
-  -c, --color <colors>       Comma-separated colors for processes (hex, e.g. #ff0,#0f0)
+  -c, --color <colors>       Comma-separated colors (hex or names: black, red, green, yellow, blue, magenta, cyan, white, gray, orange, purple)
+  --colors                   Auto-assign colors to processes based on their name
   --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)
@@ -2581,6 +2719,13 @@ async function main() {
   if (parsed.only || parsed.exclude) {
     config = filterConfig(config, parsed.only, parsed.exclude);
   }
+  if (parsed.autoColors) {
+    for (const [name, proc] of Object.entries(config.processes)) {
+      if (!proc.color) {
+        proc.color = colorFromName(name);
+      }
+    }
+  }
   const manager = new ProcessManager(config);
   let logWriter;
   if (parsed.logDir) {

package/dist/types.d.ts

@@ -14,6 +14,7 @@ export interface NumuxProcessConfig {
     color?: string | string[];
     watch?: string | string[];
     interactive?: boolean;
+    errorMatcher?: boolean | string;
 }
 /** Config for npm: wildcard entries — command is derived from package.json scripts */
 export type NumuxScriptPattern = Omit<NumuxProcessConfig, 'command'> & {
@@ -50,4 +51,7 @@ export type ProcessEvent = {
     type: 'exit';
     name: string;
     code: number | null;
+} | {
+    type: 'error';
+    name: string;
 };

package/package.json

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