numux 1.19.0 → 1.21.0

package/README.md

@@ -193,6 +193,11 @@ Top-level options apply to all processes (process-level settings override):
 | `env` | `Record<string, string>` | Environment variables merged into all processes (process `env` overrides per key) |
 | `envFile` | `string \| string[] \| false` | `.env` file(s) for all processes (process `envFile` replaces if set; `false` disables) |
 | `showCommand` | `boolean` | Print the command being run as the first line of output (default: `true`) |
+| `maxRestarts` | `number` | Restart limit for all processes (default: `Infinity`) |
+| `readyTimeout` | `number` | Ready timeout in ms for all processes |
+| `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) |
 
 ```ts
 export default defineConfig({
@@ -223,6 +228,7 @@ Each process accepts:
 | `maxRestarts` | `number` | `Infinity` | Max auto-restart attempts before giving up |
 | `delay` | `number` | — | Milliseconds to wait before starting the process |
 | `condition` | `string` | — | Env var name; process skipped if falsy. Prefix with `!` to negate |
+| `platform` | `string \| string[]` | — | OS(es) this process runs on (e.g. `'darwin'`, `'linux'`). Non-matching processes are removed; dependents still start |
 | `stopSignal` | `string` | `SIGTERM` | Signal for graceful stop (`SIGTERM`, `SIGINT`, or `SIGHUP`) |
 | `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 |

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.19.0",
+    version: "1.21.0",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -826,6 +826,34 @@ async function autoDetectConfig(cwd) {
   throw new Error(`No numux config found. Create one of: ${CONFIG_FILES.join(", ")}, or add a "numux" key to package.json`);
 }
 
+// src/config/platform.ts
+function filterByPlatform(config, currentPlatform = process.platform) {
+  const excluded = new Set;
+  for (const [name, proc] of Object.entries(config.processes)) {
+    if (!proc.platform)
+      continue;
+    const platforms = Array.isArray(proc.platform) ? proc.platform : [proc.platform];
+    if (!platforms.includes(currentPlatform)) {
+      excluded.add(name);
+    }
+  }
+  if (excluded.size === 0)
+    return config;
+  const processes = {};
+  for (const [name, proc] of Object.entries(config.processes)) {
+    if (excluded.has(name))
+      continue;
+    const copy = { ...proc };
+    if (copy.dependsOn) {
+      copy.dependsOn = copy.dependsOn.filter((d) => !excluded.has(d));
+      if (copy.dependsOn.length === 0)
+        copy.dependsOn = undefined;
+    }
+    processes[name] = copy;
+  }
+  return { processes };
+}
+
 // src/config/resolver.ts
 function resolveDependencyTiers(config) {
   const names = Object.keys(config.processes);
@@ -1007,6 +1035,11 @@ function validateConfig(raw, warnings) {
   const globalCwd = typeof config.cwd === "string" ? config.cwd : undefined;
   const globalShowCommand = typeof config.showCommand === "boolean" ? config.showCommand : undefined;
   const globalEnvFile = validateEnvFile(config.envFile);
+  const globalMaxRestarts = typeof config.maxRestarts === "number" && config.maxRestarts >= 0 ? config.maxRestarts : undefined;
+  const globalReadyTimeout = typeof config.readyTimeout === "number" && config.readyTimeout > 0 ? config.readyTimeout : undefined;
+  const globalStopSignal = validateStopSignal(config.stopSignal);
+  const globalErrorMatcher = validateErrorMatcher("(global)", config.errorMatcher);
+  const globalWatch = validateStringOrStringArray(config.watch);
   let globalEnv;
   if (config.env && typeof config.env === "object") {
     for (const [k, v] of Object.entries(config.env)) {
@@ -1086,6 +1119,12 @@ function validateConfig(raw, warnings) {
     const processEnv = p.env && typeof p.env === "object" ? p.env : undefined;
     const processEnvFile = validateEnvFile(p.envFile);
     const showCommand = typeof p.showCommand === "boolean" ? p.showCommand : globalShowCommand ?? true;
+    const platform = validatePlatform(name, p.platform);
+    const processMaxRestarts = typeof p.maxRestarts === "number" && p.maxRestarts >= 0 ? p.maxRestarts : undefined;
+    const processReadyTimeout = typeof p.readyTimeout === "number" && p.readyTimeout > 0 ? p.readyTimeout : undefined;
+    const processStopSignal = validateStopSignal(p.stopSignal);
+    const processErrorMatcher = validateErrorMatcher(name, p.errorMatcher);
+    const processWatch = validateStringOrStringArray(p.watch);
     validated[name] = {
       command: p.command,
       cwd: processCwd ?? globalCwd,
@@ -1094,15 +1133,16 @@ function validateConfig(raw, warnings) {
       dependsOn: Array.isArray(p.dependsOn) ? p.dependsOn : undefined,
       readyPattern,
       persistent,
-      maxRestarts: typeof p.maxRestarts === "number" && p.maxRestarts >= 0 ? p.maxRestarts : undefined,
-      readyTimeout: typeof p.readyTimeout === "number" && p.readyTimeout > 0 ? p.readyTimeout : undefined,
+      maxRestarts: processMaxRestarts ?? globalMaxRestarts,
+      readyTimeout: processReadyTimeout ?? globalReadyTimeout,
       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),
+      platform,
+      stopSignal: processStopSignal ?? globalStopSignal,
       color: typeof p.color === "string" ? p.color : Array.isArray(p.color) ? p.color : undefined,
-      watch: validateStringOrStringArray(p.watch),
+      watch: processWatch ?? globalWatch,
       interactive: typeof p.interactive === "boolean" ? p.interactive : false,
-      errorMatcher: validateErrorMatcher(name, p.errorMatcher),
+      errorMatcher: processErrorMatcher ?? globalErrorMatcher,
       showCommand
     };
   }
@@ -1136,6 +1176,19 @@ function validateErrorMatcher(name, value) {
   }
   return;
 }
+var VALID_PLATFORMS = new Set(["aix", "darwin", "freebsd", "linux", "openbsd", "sunos", "win32"]);
+function validatePlatform(name, value) {
+  const arr = validateStringOrStringArray(value);
+  if (arr === undefined)
+    return;
+  const values = typeof arr === "string" ? [arr] : arr;
+  for (const v of values) {
+    if (!VALID_PLATFORMS.has(v)) {
+      throw new Error(`Process "${name}".platform "${v}" is not valid. Must be one of: ${[...VALID_PLATFORMS].join(", ")}`);
+    }
+  }
+  return arr;
+}
 var VALID_STOP_SIGNALS = new Set(["SIGTERM", "SIGINT", "SIGHUP"]);
 function validateStopSignal(value) {
   if (typeof value === "string" && VALID_STOP_SIGNALS.has(value)) {
@@ -3302,6 +3355,7 @@ async function main() {
     const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
     const warnings2 = [];
     let config2 = validateConfig(raw, warnings2);
+    config2 = filterByPlatform(config2);
     if (parsed.only || parsed.exclude) {
       config2 = filterConfig(config2, parsed.only, parsed.exclude);
     }
@@ -3325,6 +3379,10 @@ async function main() {
           flags.push(`delay: ${proc.delay}ms`);
         if (proc.condition)
           flags.push(`if: ${proc.condition}`);
+        if (proc.platform) {
+          const p = Array.isArray(proc.platform) ? proc.platform : [proc.platform];
+          flags.push(`platform: ${p.join(", ")}`);
+        }
         if (proc.watch) {
           const patterns = Array.isArray(proc.watch) ? proc.watch : [proc.watch];
           flags.push(`watch: ${patterns.join(", ")}`);
@@ -3414,6 +3472,7 @@ async function main() {
   } else {
     const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
     config = validateConfig(raw, warnings);
+    config = filterByPlatform(config);
     if (parsed.noRestart) {
       for (const proc of Object.values(config.processes)) {
         proc.maxRestarts = 0;

package/dist/types.d.ts

@@ -31,6 +31,8 @@ export interface NumuxProcessConfig<K extends string = string> {
     delay?: number;
     /** Env var name (prefix with `!` to negate); process skipped if condition is falsy */
     condition?: string;
+    /** OS(es) this process runs on (e.g. `'darwin'`, `'linux'`). Non-matching processes are removed, their dependents still start */
+    platform?: string | string[];
     /**
      * Signal for graceful stop
      * @default 'SIGTERM'
@@ -70,6 +72,22 @@ export interface NumuxConfig<K extends string = string> {
      * @default true
      */
     showCommand?: boolean;
+    /**
+     * Global restart limit, inherited by all processes
+     * @default Infinity
+     */
+    maxRestarts?: number;
+    /** Global ready timeout (ms), inherited by all processes */
+    readyTimeout?: number;
+    /**
+     * Global stop signal, inherited by all processes
+     * @default 'SIGTERM'
+     */
+    stopSignal?: 'SIGTERM' | 'SIGINT' | 'SIGHUP';
+    /** Global error matcher, inherited by all processes. `true` = detect ANSI red output, string = regex */
+    errorMatcher?: boolean | string;
+    /** Global watch patterns, inherited by processes without their own watch */
+    watch?: string | string[];
     processes: Record<K, NumuxProcessConfig<K> | NumuxScriptPattern<K> | string>;
 }
 /** Process config after validation — dependsOn is always normalized to an array */

package/package.json

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