numux 1.9.0 → 1.10.0

package/README.md

@@ -98,6 +98,22 @@ numux completions fish | source
 numux completions fish > ~/.config/fish/completions/numux.fish
 ```
 
+### Workspaces
+
+Run a `package.json` script across all workspaces in a monorepo:
+
+```sh
+numux -w dev
+```
+
+Reads the `workspaces` field from your root `package.json`, finds which workspaces have the given script, and spawns `<pm> run <script>` in each. The package manager is auto-detected from `packageManager` field or lockfiles.
+
+Composes with other flags:
+
+```sh
+numux -w dev -n redis="redis-server" --colors
+```
+
 ### Ad-hoc commands
 
 ```sh
@@ -108,10 +124,39 @@ numux "bun dev:api" "bun dev:web"
 numux -n api="bun dev:api" -n web="bun dev:web"
 ```
 
+### Script patterns
+
+Run multiple package.json scripts matching a glob pattern:
+
+```sh
+numux 'dev:*'             # all scripts matching dev:*
+numux 'npm:*:dev'         # explicit npm: prefix (same behavior)
+```
+
+Extra arguments after the pattern are forwarded to each matched command:
+
+```sh
+numux 'lint:* --fix'      # → bun run lint:js --fix, bun run lint:ts --fix
+```
+
+In a config file, use the pattern as the process name:
+
+```ts
+export default defineConfig({
+  processes: {
+    'dev:*': { color: ['green', 'cyan'] },
+    'lint:* --fix': {},
+  },
+})
+```
+
+Template properties (color, env, dependsOn, etc.) are inherited by all matched processes. Colors given as an array are distributed round-robin.
+
 ### Options
 
 | Flag | Description |
 |------|-------------|
+| `-w, --workspace <script>` | Run a script across all workspaces |
 | `-c, --config <path>` | Explicit config file path |
 | `-n, --name <name=cmd>` | Add a named process (repeatable) |
 | `-p, --prefix` | Prefixed output mode (no TUI, for CI/scripts) |

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.9.0",
+    version: "1.10.0",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -75,8 +75,8 @@ var require_package = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import { existsSync as existsSync4, writeFileSync } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync5, writeFileSync } from "fs";
+import { resolve as resolve8 } from "path";
 
 // src/cli.ts
 function parseArgs(argv) {
@@ -122,6 +122,8 @@ function parseArgs(argv) {
       result.timestamps = true;
     } else if (arg === "--no-restart") {
       result.noRestart = true;
+    } else if (arg === "-w" || arg === "--workspace") {
+      result.workspace = consumeValue(arg);
     } else if (arg === "--no-watch") {
       result.noWatch = true;
     } else if (arg === "--colors") {
@@ -274,7 +276,7 @@ _numux() {
       return ;;
     --only|--exclude)
       return ;;
-    -n|--name)
+    -n|--name|-w|--workspace)
       return ;;
     completions)
       COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
@@ -282,7 +284,7 @@ _numux() {
   esac
 
   if [[ "$cur" == -* ]]; then
-    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") )
+    COMPREPLY=( $(compgen -W "-h --help -v --version -w --workspace -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") )
@@ -306,6 +308,7 @@ _numux() {
   _arguments -s \\
     '(-h --help)'{-h,--help}'[Show help]' \\
     '(-v --version)'{-v,--version}'[Show version]' \\
+    '(-w --workspace)'{-w,--workspace}'[Run script across all workspaces]:script' \\
     '(-c --color)'{-c,--color}'[Comma-separated colors for processes]' \\
     '--colors[Auto-assign colors based on process name]' \\
     '--config[Config file path]:file:_files' \\
@@ -352,6 +355,7 @@ 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 w -l workspace -r -d 'Run script across all workspaces'
 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'
@@ -390,6 +394,12 @@ function detectPackageManager(pkgJson, cwd) {
 function isGlobPattern(name) {
   return /[*?[]/.test(name);
 }
+function splitPatternArgs(raw) {
+  const i = raw.indexOf(" ");
+  if (i === -1)
+    return { glob: raw, extraArgs: "" };
+  return { glob: raw.slice(0, i), extraArgs: raw.slice(i) };
+}
 function expandScriptPatterns(config, cwd) {
   const entries = Object.entries(config.processes);
   const hasWildcard = entries.some(([name]) => name.startsWith("npm:") || isGlobPattern(name));
@@ -413,15 +423,16 @@ function expandScriptPatterns(config, cwd) {
       expanded[name] = value;
       continue;
     }
-    const pattern = name.startsWith("npm:") ? name.slice(4) : name;
+    const rawPattern = name.startsWith("npm:") ? name.slice(4) : name;
+    const { glob: globPattern, extraArgs } = splitPatternArgs(rawPattern);
     const template = value ?? {};
     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 glob = new Bun.Glob(globPattern);
     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(", ")}`);
+      throw new Error(`"${name}": no scripts matched pattern "${globPattern}". Available scripts: ${scriptNames.join(", ")}`);
     }
     const colors = Array.isArray(template.color) ? template.color : undefined;
     const singleColor = typeof template.color === "string" ? template.color : undefined;
@@ -434,7 +445,7 @@ function expandScriptPatterns(config, cwd) {
       const { color: _color, ...rest } = template;
       expanded[scriptName] = {
         ...rest,
-        command: `${pm} run ${scriptName}`,
+        command: `${pm} run ${scriptName}${extraArgs}`,
         ...color ? { color } : {}
       };
     }
@@ -847,8 +858,71 @@ function validateStopSignal(value) {
   return;
 }
 
+// src/config/workspaces.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { basename, resolve as resolve4 } from "path";
+function resolveWorkspaceProcesses(script, cwd) {
+  const pkgPath = resolve4(cwd, "package.json");
+  if (!existsSync4(pkgPath)) {
+    throw new Error(`No package.json found in ${cwd}`);
+  }
+  const pkgJson = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  const pm = detectPackageManager(pkgJson, cwd);
+  const raw = pkgJson.workspaces;
+  let patterns;
+  if (Array.isArray(raw)) {
+    patterns = raw;
+  } else if (raw && typeof raw === "object" && Array.isArray(raw.packages)) {
+    patterns = raw.packages;
+  } else {
+    throw new Error('No "workspaces" field found in package.json');
+  }
+  const dirs = [];
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    for (const match of glob.scanSync({ cwd, onlyFiles: false })) {
+      const abs = resolve4(cwd, match);
+      const wsPkgPath = resolve4(abs, "package.json");
+      if (existsSync4(wsPkgPath)) {
+        dirs.push(abs);
+      }
+    }
+  }
+  const processes = {};
+  const usedNames = new Set;
+  for (const dir of dirs) {
+    const wsPkgPath = resolve4(dir, "package.json");
+    const wsPkg = JSON.parse(readFileSync2(wsPkgPath, "utf-8"));
+    const scripts = wsPkg.scripts;
+    if (!scripts?.[script])
+      continue;
+    let name;
+    if (typeof wsPkg.name === "string" && wsPkg.name) {
+      name = wsPkg.name.replace(/^@[^/]+\//, "");
+    } else {
+      name = basename(dir);
+    }
+    if (usedNames.has(name)) {
+      let suffix = 1;
+      while (usedNames.has(`${name}-${suffix}`))
+        suffix++;
+      name = `${name}-${suffix}`;
+    }
+    usedNames.add(name);
+    processes[name] = {
+      command: `${pm} run ${script}`,
+      cwd: dir,
+      persistent: true
+    };
+  }
+  if (Object.keys(processes).length === 0) {
+    throw new Error(`No workspaces have a "${script}" script`);
+  }
+  return processes;
+}
+
 // src/process/manager.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 
 // src/utils/watcher.ts
 import { watch } from "fs";
@@ -896,11 +970,11 @@ class FileWatcher {
 }
 
 // src/process/runner.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 
 // src/utils/env-file.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve5 } from "path";
 function parseEnvFile(content) {
   const vars = {};
   for (const line of content.split(/\r?\n/)) {
@@ -928,10 +1002,10 @@ function loadEnvFiles(envFile, cwd) {
   const files = Array.isArray(envFile) ? envFile : [envFile];
   const merged = {};
   for (const file of files) {
-    const path = resolve4(cwd, file);
+    const path = resolve5(cwd, file);
     let content;
     try {
-      content = readFileSync2(path, "utf-8");
+      content = readFileSync3(path, "utf-8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -1046,7 +1120,7 @@ class ProcessRunner {
     this.stopping = false;
     log(`[${this.name}] Starting (gen ${gen}): ${this.config.command}`);
     this.handler.onStatus("starting");
-    const cwd = this.config.cwd ? resolve5(this.config.cwd) : process.cwd();
+    const cwd = this.config.cwd ? resolve6(this.config.cwd) : process.cwd();
     try {
       const envFromFile = this.config.envFile ? loadEnvFiles(this.config.envFile, cwd) : {};
       const noColor = "NO_COLOR" in process.env;
@@ -1308,12 +1382,12 @@ class ProcessManager {
           this.updateStatus(name, "skipped");
           continue;
         }
-        const { promise, resolve: resolve7 } = Promise.withResolvers();
+        const { promise, resolve: resolve8 } = Promise.withResolvers();
         readyPromises.push(promise);
-        this.pendingReadyResolvers.set(name, resolve7);
+        this.pendingReadyResolvers.set(name, resolve8);
         this.createRunner(name, () => {
           this.pendingReadyResolvers.delete(name);
-          resolve7();
+          resolve8();
         });
         this.startProcess(name, cols, rows);
       }
@@ -1421,7 +1495,7 @@ class ProcessManager {
       if (!this.fileWatcher)
         this.fileWatcher = new FileWatcher;
       const patterns = Array.isArray(proc.watch) ? proc.watch : [proc.watch];
-      const cwd = proc.cwd ? resolve6(proc.cwd) : process.cwd();
+      const cwd = proc.cwd ? resolve7(proc.cwd) : process.cwd();
       this.fileWatcher.watch(name, patterns, cwd, (changedFile) => {
         const state = this.states.get(name);
         if (!state)
@@ -1527,8 +1601,8 @@ class ProcessManager {
       clearTimeout(timer);
     }
     this.restartTimers.clear();
-    for (const resolve7 of this.pendingReadyResolvers.values()) {
-      resolve7();
+    for (const resolve8 of this.pendingReadyResolvers.values()) {
+      resolve8();
     }
     this.pendingReadyResolvers.clear();
     const reversed = [...this.tiers].reverse();
@@ -2352,7 +2426,6 @@ class PrefixDisplay {
   noColor;
   decoders = new Map;
   buffers = new Map;
-  maxNameLen;
   logWriter;
   killOthers;
   timestamps;
@@ -2364,7 +2437,6 @@ class PrefixDisplay {
     this.timestamps = options.timestamps ?? false;
     this.noColor = "NO_COLOR" in process.env;
     const names = manager.getProcessNames();
-    this.maxNameLen = Math.max(...names.map((n) => n.length));
     this.colors = buildProcessColorMap(names, config);
     for (const name of names) {
       this.decoders.set(name, new TextDecoder("utf-8", { fatal: false }));
@@ -2438,15 +2510,14 @@ class PrefixDisplay {
     return `${h}:${m}:${s}`;
   }
   printLine(name, line) {
-    const padded = name.padEnd(this.maxNameLen);
     const ts = this.timestamps ? `${DIM}[${this.formatTimestamp()}]${RESET} ` : "";
     const tsPlain = this.timestamps ? `[${this.formatTimestamp()}] ` : "";
     if (this.noColor) {
-      process.stdout.write(`${tsPlain}[${padded}] ${stripAnsi(line)}
+      process.stdout.write(`${tsPlain}[${name}] ${stripAnsi(line)}
 `);
     } else {
       const color = this.colors.get(name) ?? "";
-      process.stdout.write(`${ts}${color}[${padded}]${RESET} ${line}
+      process.stdout.write(`${ts}${color}[${name}]${RESET} ${line}
 `);
     }
   }
@@ -2600,12 +2671,14 @@ Usage:
   numux                          Run processes from config file
   numux <cmd1> <cmd2> ...        Run ad-hoc commands in parallel
   numux -n name1=cmd1 -n name2=cmd2  Named ad-hoc commands
+  numux -w <script>              Run a script across all workspaces
   numux init                     Create a starter config file
   numux validate                 Validate config and show process graph
   numux exec <name> [--] <cmd>   Run a command in a process's environment
   numux completions <shell>      Generate shell completions (bash, zsh, fish)
 
 Options:
+  -w, --workspace <script>   Run a package.json script across all workspaces
   -n, --name <name=command>  Add a named process
   -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
@@ -2658,8 +2731,8 @@ async function main() {
     process.exit(0);
   }
   if (parsed.init) {
-    const target = resolve7("numux.config.ts");
-    if (existsSync4(target)) {
+    const target = resolve8("numux.config.ts");
+    if (existsSync5(target)) {
       console.error(`Already exists: ${target}`);
       process.exit(1);
     }
@@ -2717,7 +2790,7 @@ async function main() {
       const names = Object.keys(config2.processes);
       throw new Error(`Unknown process "${parsed.execName}". Available: ${names.join(", ")}`);
     }
-    const cwd = proc.cwd ? resolve7(proc.cwd) : process.cwd();
+    const cwd = proc.cwd ? resolve8(proc.cwd) : process.cwd();
     const envFromFile = proc.envFile ? loadEnvFiles(proc.envFile, cwd) : {};
     const env = {
       ...process.env,
@@ -2738,7 +2811,7 @@ async function main() {
   }
   let config;
   const warnings = [];
-  if (parsed.commands.length > 0 || parsed.named.length > 0) {
+  if (parsed.commands.length > 0 || parsed.named.length > 0 || parsed.workspace) {
     const isScriptPattern = (c) => c.startsWith("npm:") || /[*?[]/.test(c);
     const hasNpmPatterns = parsed.commands.some(isScriptPattern);
     if (hasNpmPatterns) {
@@ -2769,6 +2842,21 @@ async function main() {
         colors: parsed.colors
       });
     }
+    if (parsed.workspace) {
+      const wsProcesses = resolveWorkspaceProcesses(parsed.workspace, process.cwd());
+      for (const [name, proc] of Object.entries(wsProcesses)) {
+        let finalName = name;
+        if (config.processes[finalName]) {
+          let suffix = 1;
+          while (config.processes[`${finalName}-${suffix}`])
+            suffix++;
+          finalName = `${finalName}-${suffix}`;
+        }
+        if (parsed.noRestart)
+          proc.maxRestarts = 0;
+        config.processes[finalName] = proc;
+      }
+    }
   } else {
     const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
     config = validateConfig(raw, warnings);
@@ -2800,6 +2888,11 @@ async function main() {
   }
   printWarnings(warnings);
   if (parsed.prefix) {
+    if (!parsed.noRestart) {
+      for (const proc of Object.values(config.processes)) {
+        proc.maxRestarts ??= 0;
+      }
+    }
     const display = new PrefixDisplay(manager, config, {
       logWriter,
       killOthers: parsed.killOthers,

package/package.json

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