numux 1.21.0 → 1.23.0

package/README.md

@@ -164,6 +164,7 @@ Template properties (color, env, dependsOn, etc.) are inherited by all matched p
 | `--exclude <a,b,...>` | Exclude these processes |
 | `--kill-others` | Kill all processes when any exits |
 | `--no-restart` | Disable auto-restart for crashed processes |
+| `-s, --sort <mode>` | Tab display order: `config` (default), `alphabetical`, `topological` |
 | `--no-watch` | Disable file watching even if config has `watch` patterns |
 | `-t, --timestamps` | Add `[HH:MM:SS]` timestamps to prefixed output |
 | `--log-dir <path>` | Write per-process output to `<path>/<name>.log` |
@@ -198,6 +199,7 @@ Top-level options apply to all processes (process-level settings override):
 | `stopSignal` | `'SIGTERM' \| 'SIGINT' \| 'SIGHUP'` | Stop signal for all processes (default: `'SIGTERM'`) |
 | `errorMatcher` | `boolean \| string` | Error detection for all processes (`true` = ANSI red, string = regex) |
 | `watch` | `string \| string[]` | Watch patterns for all processes (process `watch` replaces if set) |
+| `sort` | `'config' \| 'alphabetical' \| 'topological'` | Tab display order (default: `'config'` — definition order) |
 
 ```ts
 export default defineConfig({

package/dist/numux.js

@@ -36,7 +36,7 @@ var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports,
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "numux",
-    version: "1.21.0",
+    version: "1.23.0",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -95,6 +95,15 @@ import { resolve as resolve8 } from "path";
 // src/cli-flags.ts
 var commaSplit = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
 var FLAGS = [
+  {
+    type: "value",
+    long: "--sort",
+    short: "-s",
+    key: "sort",
+    description: "Tab display order",
+    valueName: "<config|alphabetical|topological>",
+    completionHint: "none"
+  },
   {
     type: "value",
     long: "--workspace",
@@ -906,12 +915,12 @@ 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",
+  red: "#ff5555",
+  green: "#00cc00",
+  yellow: "#cccc00",
+  blue: "#0000cc",
+  magenta: "#cc00cc",
+  cyan: "#00cccc",
   white: "#ffffff",
   gray: "#808080",
   grey: "#808080",
@@ -940,35 +949,35 @@ function hexToAnsi(hex) {
 }
 var HEX_COLOR_RE = /^#?[0-9a-fA-F]{6}$/;
 var STATUS_ANSI = {
-  ready: "\x1B[32m",
-  running: "\x1B[36m",
-  finished: "\x1B[32m",
-  failed: "\x1B[31m",
-  stopped: "\x1B[90m",
-  skipped: "\x1B[90m"
+  ready: hexToAnsi(BASIC_COLORS.green),
+  running: hexToAnsi(BASIC_COLORS.cyan),
+  finished: hexToAnsi(BASIC_COLORS.green),
+  failed: hexToAnsi(BASIC_COLORS.red),
+  stopped: hexToAnsi(BASIC_COLORS.gray),
+  skipped: hexToAnsi(BASIC_COLORS.gray)
 };
 var ANSI_RESET = "\x1B[0m";
 var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()#][0-9A-Za-z]|\x1b[A-Za-z><=]/g;
 function stripAnsi(str) {
   return str.replace(ANSI_RE, "");
 }
-var DEFAULT_ANSI_COLORS = [
-  "\x1B[36m",
-  "\x1B[33m",
-  "\x1B[35m",
-  "\x1B[34m",
-  "\x1B[32m",
-  "\x1B[91m",
-  "\x1B[93m",
-  "\x1B[95m"
+var DEFAULT_PALETTE = [
+  BASIC_COLORS.cyan,
+  BASIC_COLORS.yellow,
+  BASIC_COLORS.magenta,
+  BASIC_COLORS.blue,
+  BASIC_COLORS.green,
+  BASIC_COLORS.red,
+  BASIC_COLORS.orange,
+  BASIC_COLORS.purple
 ];
-var DEFAULT_HEX_COLORS = ["#00cccc", "#cccc00", "#cc00cc", "#0000cc", "#00cc00", "#ff5555", "#ffff55", "#ff55ff"];
+var DEFAULT_ANSI_COLORS = DEFAULT_PALETTE.map(hexToAnsi);
 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];
+  return DEFAULT_PALETTE[Math.abs(hash) % DEFAULT_PALETTE.length];
 }
 function resolveColor(color) {
   if (typeof color === "string")
@@ -1009,9 +1018,9 @@ function buildProcessHexColorMap(names, config) {
       if (hex)
         map.set(name, hex);
       else
-        map.set(name, DEFAULT_HEX_COLORS[paletteIndex++ % DEFAULT_HEX_COLORS.length]);
+        map.set(name, DEFAULT_PALETTE[paletteIndex++ % DEFAULT_PALETTE.length]);
     } else {
-      map.set(name, DEFAULT_HEX_COLORS[paletteIndex % DEFAULT_HEX_COLORS.length]);
+      map.set(name, DEFAULT_PALETTE[paletteIndex % DEFAULT_PALETTE.length]);
       paletteIndex++;
     }
   }
@@ -1049,6 +1058,7 @@ function validateConfig(raw, warnings) {
     }
     globalEnv = config.env;
   }
+  const sort = validateSort(config.sort);
   const validated = {};
   for (const name of names) {
     let proc = processes[name];
@@ -1146,7 +1156,7 @@ function validateConfig(raw, warnings) {
       showCommand
     };
   }
-  return { processes: validated };
+  return { ...sort ? { sort } : {}, processes: validated };
 }
 function validateStringOrStringArray(value) {
   if (typeof value === "string")
@@ -1176,6 +1186,16 @@ function validateErrorMatcher(name, value) {
   }
   return;
 }
+var VALID_SORT_VALUES = new Set(["config", "alphabetical", "topological"]);
+function validateSort(value) {
+  if (typeof value === "string") {
+    if (!VALID_SORT_VALUES.has(value)) {
+      throw new Error(`sort must be one of: ${[...VALID_SORT_VALUES].join(", ")}. Got "${value}"`);
+    }
+    return value;
+  }
+  return;
+}
 var VALID_PLATFORMS = new Set(["aix", "darwin", "freebsd", "linux", "openbsd", "sunos", "win32"]);
 function validatePlatform(name, value) {
   const arr = validateStringOrStringArray(value);
@@ -1743,7 +1763,14 @@ class ProcessManager {
     return [...this.states.values()];
   }
   getProcessNames() {
-    return this.tiers.flat();
+    switch (this.config.sort) {
+      case "alphabetical":
+        return Object.keys(this.config.processes).sort();
+      case "topological":
+        return this.tiers.flat();
+      default:
+        return Object.keys(this.config.processes);
+    }
   }
   async startAll(cols, rows) {
     log("Starting all processes");
@@ -2153,8 +2180,6 @@ class Pane {
   _onScroll = null;
   _onCopy = null;
   _onLinkClick = null;
-  _textLines = null;
-  _textLinesLower = null;
   constructor(renderer, name, cols, rows, interactive = false) {
     this.scrollBox = new ScrollBoxRenderable(renderer, {
       id: `pane-${name}`,
@@ -2201,14 +2226,10 @@ class Pane {
   feed(data) {
     const text = this.decoder.decode(data, { stream: true });
     this.terminal.feed(text);
-    this._textLines = null;
-    this._textLinesLower = null;
   }
   resize(cols, rows) {
     this.terminal.cols = cols;
     this.terminal.rows = rows;
-    this._textLines = null;
-    this._textLinesLower = null;
   }
   get isAtBottom() {
     const { scrollTop, scrollHeight, viewport } = this.scrollBox;
@@ -2238,16 +2259,13 @@ class Pane {
     this._onLinkClick = handler;
   }
   getLinkAtMouse(localX, localY) {
-    if (!this._textLines) {
-      const text = this.terminal.getText();
-      this._textLines = text.split(`
+    const text = this.terminal.getText();
+    const lines = text.split(`
 `);
-      this._textLinesLower = this._textLines.map((l) => l.toLowerCase());
-    }
     const lineIndex = Math.floor(this.scrollBox.scrollTop) + localY;
-    if (lineIndex < 0 || lineIndex >= this._textLines.length)
+    if (lineIndex < 0 || lineIndex >= lines.length)
       return null;
-    return findLinkAtPosition(this._textLines[lineIndex], localX);
+    return findLinkAtPosition(lines[lineIndex], localX);
   }
   show() {
     this.scrollBox.visible = true;
@@ -2255,30 +2273,6 @@ class Pane {
   hide() {
     this.scrollBox.visible = false;
   }
-  search(query) {
-    if (!query)
-      return [];
-    if (!this._textLines) {
-      const text = this.terminal.getText();
-      this._textLines = text.split(`
-`);
-      this._textLinesLower = this._textLines.map((l) => l.toLowerCase());
-    }
-    const lines = this._textLinesLower;
-    const matches = [];
-    const lowerQuery = query.toLowerCase();
-    for (let line = 0;line < lines.length; line++) {
-      let pos = 0;
-      while (true) {
-        const idx = lines[line].indexOf(lowerQuery, pos);
-        if (idx === -1)
-          break;
-        matches.push({ line, start: idx, end: idx + query.length });
-        pos = idx + 1;
-      }
-    }
-    return matches;
-  }
   setHighlights(matches, currentIndex) {
     const firstVisible = Math.max(0, Math.floor(this.scrollBox.scrollTop) - 2);
     const lastVisible = Math.ceil(this.scrollBox.scrollTop + this.scrollBox.viewport.height) + 2;
@@ -2307,8 +2301,6 @@ class Pane {
   }
   clear() {
     this.terminal.reset();
-    this._textLines = null;
-    this._textLinesLower = null;
   }
   destroy() {
     this.terminal.destroy();
@@ -2637,6 +2629,7 @@ class App {
   termRows = 24;
   sidebarWidth = 20;
   config;
+  logWriter;
   resizeTimer = null;
   searchTimer = null;
   searchMode = false;
@@ -2645,9 +2638,10 @@ class App {
   searchIndex = -1;
   inputWaitTimers = new Map;
   awaitingInput = new Set;
-  constructor(manager, config) {
+  constructor(manager, config, logWriter) {
     this.manager = manager;
     this.config = config;
+    this.logWriter = logWriter;
     this.names = manager.getProcessNames();
   }
   async start() {
@@ -2805,6 +2799,7 @@ class App {
         }
         if (name === SHORTCUTS.clear.key) {
           this.panes.get(this.activePane)?.clear();
+          this.logWriter.truncate(this.activePane);
           return;
         }
         const num = Number.parseInt(name, 10);
@@ -2977,14 +2972,16 @@ class App {
       this.runSearch();
     }, 100);
   }
-  runSearch() {
+  async runSearch() {
     if (!this.activePane)
       return;
-    const pane = this.panes.get(this.activePane);
-    if (!pane)
+    const query = this.searchQuery;
+    const activeName = this.activePane;
+    const matches = await this.logWriter.search(activeName, query);
+    if (!this.searchMode || this.searchQuery !== query || this.activePane !== activeName)
       return;
-    this.searchMatches = pane.search(this.searchQuery);
-    this.searchIndex = this.searchMatches.length > 0 ? 0 : -1;
+    this.searchMatches = matches;
+    this.searchIndex = matches.length > 0 ? 0 : -1;
     this.updateSearchHighlights();
     if (this.searchIndex >= 0) {
       this.scrollToCurrentMatch();
@@ -3152,7 +3149,7 @@ class PrefixDisplay {
     const allDone = states.every((s) => s.status === "stopped" || s.status === "finished" || s.status === "failed" || s.status === "skipped");
     if (allDone) {
       this.printSummary();
-      this.logWriter?.close();
+      this.logWriter?.cleanup();
       const anyFailed = states.some((s) => s.status === "failed");
       process.exit(anyFailed ? 1 : 0);
     }
@@ -3168,7 +3165,7 @@ class PrefixDisplay {
         this.flushBuffer(name);
       }
       this.printSummary();
-      this.logWriter?.close();
+      this.logWriter?.cleanup();
       process.exit(code === 0 ? 0 : 1);
     });
   }
@@ -3220,24 +3217,31 @@ ${DIM}Done in ${elapsed}${RESET}
     for (const name of this.manager.getProcessNames()) {
       this.flushBuffer(name);
     }
-    this.logWriter?.close();
+    this.logWriter?.cleanup();
     const anyFailed = this.manager.getAllStates().some((s) => s.status === "failed");
     process.exit(anyFailed ? 1 : 0);
   }
 }
 
 // src/utils/log-writer.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, writeSync } from "fs";
+import { closeSync, mkdirSync as mkdirSync2, openSync, rmSync, writeSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
 class LogWriter {
   dir;
+  isTemp;
   files = new Map;
   decoder = new TextDecoder;
   encoder = new TextEncoder;
-  constructor(dir) {
+  constructor(dir, isTemp = false) {
     this.dir = dir;
+    this.isTemp = isTemp;
     mkdirSync2(dir, { recursive: true });
   }
+  static createTemp() {
+    const dir = join(tmpdir(), `numux-${process.pid}`);
+    return new LogWriter(dir, true);
+  }
   errored = false;
   handleEvent = (event) => {
     if (event.type !== "output" || this.errored)
@@ -3258,12 +3262,81 @@ class LogWriter {
 `);
     }
   };
+  getLogPath(name) {
+    if (this.files.has(name)) {
+      return join(this.dir, `${name}.log`);
+    }
+    return;
+  }
+  async search(name, query) {
+    if (!query)
+      return [];
+    const path = this.getLogPath(name);
+    if (!path)
+      return [];
+    try {
+      const proc = Bun.spawn(["grep", "-inF", query, path], {
+        stdout: "pipe",
+        stderr: "ignore"
+      });
+      const output = await new Response(proc.stdout).text();
+      await proc.exited;
+      const matches = [];
+      const lowerQuery = query.toLowerCase();
+      for (const line of output.split(`
+`)) {
+        if (!line)
+          continue;
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+          continue;
+        const lineNumber = Number.parseInt(line.slice(0, colonIdx), 10);
+        if (Number.isNaN(lineNumber))
+          continue;
+        const lineText = line.slice(colonIdx + 1).toLowerCase();
+        let pos = 0;
+        while (true) {
+          const idx = lineText.indexOf(lowerQuery, pos);
+          if (idx === -1)
+            break;
+          matches.push({
+            line: lineNumber - 1,
+            start: idx,
+            end: idx + query.length
+          });
+          pos = idx + 1;
+        }
+      }
+      return matches;
+    } catch {
+      return [];
+    }
+  }
+  truncate(name) {
+    const fd = this.files.get(name);
+    if (fd === undefined)
+      return;
+    try {
+      closeSync(fd);
+      const path = join(this.dir, `${name}.log`);
+      const newFd = openSync(path, "w");
+      this.files.set(name, newFd);
+    } catch {}
+  }
   close() {
     for (const fd of this.files.values()) {
       closeSync(fd);
     }
     this.files.clear();
   }
+  cleanup() {
+    this.close();
+    if (this.isTemp) {
+      try {
+        rmSync(this.dir, { recursive: true });
+      } catch {}
+    }
+  }
 }
 
 // src/utils/shutdown.ts
@@ -3275,7 +3348,7 @@ function setupShutdownHandlers(app, logWriter) {
     }
     shuttingDown = true;
     app.shutdown().finally(() => {
-      logWriter?.close();
+      logWriter?.cleanup();
       process.exit(app.hasFailures() ? 1 : 0);
     });
   };
@@ -3286,7 +3359,7 @@ function setupShutdownHandlers(app, logWriter) {
     process.stderr.write(`numux: unexpected error: ${err?.stack ?? err}
 `);
     app.shutdown().finally(() => {
-      logWriter?.close();
+      logWriter?.cleanup();
       process.exit(1);
     });
   });
@@ -3296,7 +3369,7 @@ function setupShutdownHandlers(app, logWriter) {
     process.stderr.write(`numux: unhandled rejection: ${message}
 `);
     app.shutdown().finally(() => {
-      logWriter?.close();
+      logWriter?.cleanup();
       process.exit(1);
     });
   });
@@ -3479,6 +3552,9 @@ async function main() {
       }
     }
   }
+  if (parsed.sort) {
+    config.sort = parsed.sort;
+  }
   if (parsed.envFile !== undefined) {
     for (const proc of Object.values(config.processes)) {
       proc.envFile = parsed.envFile;
@@ -3500,10 +3576,7 @@ async function main() {
     }
   }
   const manager = new ProcessManager(config);
-  let logWriter;
-  if (parsed.logDir) {
-    logWriter = new LogWriter(parsed.logDir);
-  }
+  const logWriter = parsed.logDir ? new LogWriter(parsed.logDir) : LogWriter.createTemp();
   printWarnings(warnings);
   if (parsed.prefix) {
     if (!parsed.noRestart) {
@@ -3518,10 +3591,8 @@ async function main() {
     });
     await display.start();
   } else {
-    if (logWriter) {
-      manager.on(logWriter.handleEvent);
-    }
-    const app = new App(manager, config);
+    manager.on(logWriter.handleEvent);
+    const app = new App(manager, config, logWriter);
     setupShutdownHandlers(app, logWriter);
     await app.start();
   }

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { Color } from './utils/color';
 export interface NumuxProcessConfig<K extends string = string> {
     /** Shell command to run. Supports `$dep.group` references from dependency capture groups */
     command: string;
@@ -39,7 +40,7 @@ export interface NumuxProcessConfig<K extends string = string> {
      */
     stopSignal?: 'SIGTERM' | 'SIGINT' | 'SIGHUP';
     /** Hex color (e.g. `"#ff6600"`) or color name. Array for round-robin in script patterns */
-    color?: string | string[];
+    color?: Color | Color[];
     /** Glob patterns — restart process when matching files change */
     watch?: string | string[];
     /**
@@ -88,14 +89,22 @@ export interface NumuxConfig<K extends string = string> {
     errorMatcher?: boolean | string;
     /** Global watch patterns, inherited by processes without their own watch */
     watch?: string | string[];
+    /**
+     * Tab display order. `'config'` preserves definition order (package.json script order for wildcards),
+     * `'alphabetical'` sorts by process name, `'topological'` sorts by dependency tiers.
+     * @default 'config'
+     */
+    sort?: SortOrder;
     processes: Record<K, NumuxProcessConfig<K> | NumuxScriptPattern<K> | string>;
 }
+export type SortOrder = 'config' | 'alphabetical' | 'topological';
 /** Process config after validation — dependsOn is always normalized to an array */
 export interface ResolvedProcessConfig extends Omit<NumuxProcessConfig, 'dependsOn'> {
     dependsOn?: string[];
 }
 /** Validated config with all shorthand expanded to full objects */
 export interface ResolvedNumuxConfig {
+    sort?: SortOrder;
     processes: Record<string, ResolvedProcessConfig>;
 }
 export type ProcessStatus = 'pending' | 'starting' | 'ready' | 'running' | 'stopping' | 'stopped' | 'finished' | 'failed' | 'skipped';

package/dist/utils/color.d.ts

@@ -0,0 +1,40 @@
+/** Basic color names mapped to muted hex tones (lowercase keys) */
+export type BasicColor = keyof typeof BASIC_COLORS;
+export type Color = `#${string}` | BasicColor;
+export declare const BASIC_COLORS: {
+    readonly black: "#000000";
+    readonly red: "#ff5555";
+    readonly green: "#00cc00";
+    readonly yellow: "#cccc00";
+    readonly blue: "#0000cc";
+    readonly magenta: "#cc00cc";
+    readonly cyan: "#00cccc";
+    readonly white: "#ffffff";
+    readonly gray: "#808080";
+    readonly grey: "#808080";
+    readonly orange: "#ffa500";
+    readonly purple: "#800080";
+};
+/** Check if a string is a valid color (hex or basic name) */
+export declare function isValidColor(color: string): boolean;
+/** Resolve any color (hex or basic name) to normalized hex (#rrggbb) */
+export declare function resolveToHex(color: string): string;
+/**
+ * Convert a hex color string (e.g. "#ff8800") to an ANSI true-color escape sequence.
+ * Returns an empty string if the hex is malformed.
+ */
+export declare function hexToAnsi(hex: string): string;
+/** Regex matching a valid 6-digit hex color (with or without leading #) */
+export declare const HEX_COLOR_RE: RegExp;
+import type { ProcessStatus, ResolvedNumuxConfig } from '../types';
+/** ANSI color codes for process statuses */
+export declare const STATUS_ANSI: Partial<Record<ProcessStatus, string>>;
+export declare const ANSI_RESET = "\u001B[0m";
+/** Strip ANSI escape sequences from text */
+export declare function stripAnsi(str: string): string;
+/** Pick a deterministic color from the default palette based on the process name */
+export declare function colorFromName(name: string): Color;
+/** Build a map of process names to ANSI color codes, using explicit config colors or a default palette. */
+export declare function buildProcessColorMap(names: string[], config: ResolvedNumuxConfig): Map<string, string>;
+/** Build a map of process names to hex color strings (for StyledText rendering). */
+export declare function buildProcessHexColorMap(names: string[], config: ResolvedNumuxConfig): Map<string, string>;

package/package.json

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