numux 1.9.0 → 1.10.1

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) |
@@ -181,6 +226,7 @@ Each process accepts:
 | `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 |
+| `errorMatcher` | `boolean \| string` | — | `true` detects ANSI red output, string = regex pattern — shows error indicator on tab |
 
 ### File watching
 

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.1",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -75,10 +75,230 @@ 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-flags.ts
+var commaSplit = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
+var FLAGS = [
+  {
+    type: "value",
+    long: "--workspace",
+    short: "-w",
+    key: "workspace",
+    description: "Run a package.json script across all workspaces",
+    valueName: "<script>",
+    completionHint: "none"
+  },
+  {
+    type: "value",
+    long: "--name",
+    short: "-n",
+    key: "named",
+    description: "Add a named process",
+    valueName: "<name=command>",
+    completionHint: "none",
+    parse(raw) {
+      const eq = raw.indexOf("=");
+      if (eq < 1) {
+        throw new Error(`Invalid --name value: expected "name=command", got "${raw}"`);
+      }
+      return { name: raw.slice(0, eq), command: raw.slice(eq + 1) };
+    }
+  },
+  {
+    type: "value",
+    long: "--color",
+    short: "-c",
+    key: "colors",
+    description: "Comma-separated colors (hex or names: black, red, green, yellow, blue, magenta, cyan, white, gray, orange, purple)",
+    valueName: "<colors>",
+    completionHint: "none",
+    parse: commaSplit
+  },
+  {
+    type: "boolean",
+    long: "--colors",
+    key: "autoColors",
+    description: "Auto-assign colors to processes based on their name"
+  },
+  {
+    type: "value",
+    long: "--config",
+    key: "configPath",
+    description: "Config file path (default: auto-detect)",
+    valueName: "<path>",
+    completionHint: "file"
+  },
+  {
+    type: "boolean",
+    long: "--prefix",
+    short: "-p",
+    key: "prefix",
+    description: "Prefixed output mode (no TUI, for CI/scripts)"
+  },
+  {
+    type: "value",
+    long: "--only",
+    key: "only",
+    description: "Only run these processes (+ their dependencies)",
+    valueName: "<a,b,...>",
+    completionHint: "none",
+    parse: commaSplit
+  },
+  {
+    type: "value",
+    long: "--exclude",
+    key: "exclude",
+    description: "Exclude these processes",
+    valueName: "<a,b,...>",
+    completionHint: "none",
+    parse: commaSplit
+  },
+  {
+    type: "boolean",
+    long: "--kill-others",
+    key: "killOthers",
+    description: "Kill all processes when any exits"
+  },
+  {
+    type: "boolean",
+    long: "--no-restart",
+    key: "noRestart",
+    description: "Disable auto-restart for crashed processes"
+  },
+  {
+    type: "boolean",
+    long: "--no-watch",
+    key: "noWatch",
+    description: "Disable file watching even if config has watch patterns"
+  },
+  {
+    type: "boolean",
+    long: "--timestamps",
+    short: "-t",
+    key: "timestamps",
+    description: "Add timestamps to prefixed output lines"
+  },
+  {
+    type: "value",
+    long: "--log-dir",
+    key: "logDir",
+    description: "Write per-process logs to directory",
+    valueName: "<path>",
+    completionHint: "directory"
+  },
+  {
+    type: "boolean",
+    long: "--debug",
+    key: "debug",
+    description: "Enable debug logging to .numux/debug.log"
+  },
+  {
+    type: "boolean",
+    long: "--help",
+    short: "-h",
+    key: "help",
+    description: "Show this help"
+  },
+  {
+    type: "boolean",
+    long: "--version",
+    short: "-v",
+    key: "version",
+    description: "Show version"
+  }
+];
+var SUBCOMMANDS = [
+  {
+    name: "init",
+    description: "Create a starter config file",
+    parse: (_args, i, result) => {
+      result.init = true;
+      return i;
+    }
+  },
+  {
+    name: "validate",
+    description: "Validate config and show process graph",
+    parse: (_args, i, result) => {
+      result.validate = true;
+      return i;
+    }
+  },
+  {
+    name: "exec",
+    description: "Run a command in a process's environment",
+    usage: "exec <name> [--] <cmd>",
+    parse: (args, i, result) => {
+      result.exec = true;
+      const name = args[++i];
+      if (!name)
+        throw new Error("exec requires a process name");
+      result.execName = name;
+      if (args[i + 1] === "--")
+        i++;
+      const rest = args.slice(i + 1);
+      if (rest.length === 0)
+        throw new Error("exec requires a command to run");
+      result.execCommand = rest.join(" ");
+      return "break";
+    }
+  },
+  {
+    name: "completions",
+    description: "Generate shell completions (bash, zsh, fish)",
+    usage: "completions <shell>",
+    parse: (args, i, result) => {
+      const next = args[++i];
+      if (next === undefined)
+        throw new Error("Missing value for completions");
+      result.completions = next;
+      return i;
+    }
+  }
+];
+function generateHelp() {
+  const lines = [
+    "numux \u2014 terminal multiplexer with dependency orchestration",
+    "",
+    "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"
+  ];
+  for (const sub of SUBCOMMANDS) {
+    const label = `  numux ${sub.usage ?? sub.name}`;
+    lines.push(`${label.padEnd(33)}${sub.description}`);
+  }
+  lines.push("", "Options:");
+  for (const f of FLAGS) {
+    const parts = [];
+    if (f.short)
+      parts.push(`${f.short},`);
+    parts.push(f.long);
+    if (f.type === "value")
+      parts.push(f.valueName);
+    const left = `  ${parts.join(" ")}`;
+    lines.push(`${left.padEnd(29)}${f.description}`);
+  }
+  lines.push("", "Config files (auto-detected):", "  numux.config.ts, numux.config.js");
+  return lines.join(`
+`);
+}
 
 // src/cli.ts
+var flagByName = new Map;
+for (const f of FLAGS) {
+  flagByName.set(f.long, f);
+  if (f.short)
+    flagByName.set(f.short, f);
+}
+var subcommandByName = new Map;
+for (const s of SUBCOMMANDS) {
+  subcommandByName.set(s.name, s);
+}
 function parseArgs(argv) {
   const result = {
     help: false,
@@ -99,74 +319,35 @@ function parseArgs(argv) {
   };
   const args = argv.slice(2);
   let i = 0;
-  const consumeValue = (flag) => {
-    const next = args[++i];
-    if (next === undefined) {
-      throw new Error(`Missing value for ${flag}`);
-    }
-    return next;
-  };
   while (i < args.length) {
     const arg = args[i];
-    if (arg === "-h" || arg === "--help") {
-      result.help = true;
-    } else if (arg === "-v" || arg === "--version") {
-      result.version = true;
-    } else if (arg === "--debug") {
-      result.debug = true;
-    } else if (arg === "-p" || arg === "--prefix") {
-      result.prefix = true;
-    } else if (arg === "--kill-others") {
-      result.killOthers = true;
-    } else if (arg === "-t" || arg === "--timestamps") {
-      result.timestamps = true;
-    } else if (arg === "--no-restart") {
-      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") {
-      result.colors = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
-    } else if (arg === "--log-dir") {
-      result.logDir = consumeValue(arg);
-    } else if (arg === "--only") {
-      result.only = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
-    } else if (arg === "--exclude") {
-      result.exclude = consumeValue(arg).split(",").map((s) => s.trim()).filter(Boolean);
-    } else if (arg === "-n" || arg === "--name") {
-      const value = consumeValue(arg);
-      const eq = value.indexOf("=");
-      if (eq < 1) {
-        throw new Error(`Invalid --name value: expected "name=command", got "${value}"`);
+    const flag = flagByName.get(arg);
+    if (flag) {
+      if (flag.type === "boolean") {
+        result[flag.key] = true;
+      } else {
+        const next = args[++i];
+        if (next === undefined) {
+          throw new Error(`Missing value for ${arg}`);
+        }
+        const value = flag.parse ? flag.parse(next, arg) : next;
+        const current = result[flag.key];
+        if (Array.isArray(current)) {
+          current.push(value);
+        } else {
+          result[flag.key] = value;
+        }
       }
-      result.named.push({
-        name: value.slice(0, eq),
-        command: value.slice(eq + 1)
-      });
-    } else if (arg === "init" && result.commands.length === 0) {
-      result.init = true;
-    } else if (arg === "validate" && result.commands.length === 0) {
-      result.validate = true;
-    } else if (arg === "exec" && result.commands.length === 0) {
-      result.exec = true;
-      const name = args[++i];
-      if (!name)
-        throw new Error("exec requires a process name");
-      result.execName = name;
-      if (args[i + 1] === "--")
-        i++;
-      const rest = args.slice(i + 1);
-      if (rest.length === 0)
-        throw new Error("exec requires a command to run");
-      result.execCommand = rest.join(" ");
-      break;
-    } else if (arg === "completions" && result.commands.length === 0) {
-      result.completions = consumeValue(arg);
     } else if (!arg.startsWith("-")) {
-      result.commands.push(arg);
+      const sub = result.commands.length === 0 ? subcommandByName.get(arg) : undefined;
+      if (sub) {
+        const ret = sub.parse(args, i, result);
+        if (ret === "break")
+          break;
+        i = ret;
+      } else {
+        result.commands.push(arg);
+      }
     } else {
       throw new Error(`Unknown option: ${arg}`);
     }
@@ -257,7 +438,36 @@ function generateCompletions(shell) {
       throw new Error(`Unknown shell: "${shell}". Supported: ${SUPPORTED_SHELLS.join(", ")}`);
   }
 }
+function longName(f) {
+  return f.long.replace(/^-+/, "");
+}
+function sq(s) {
+  return s.replace(/'/g, "'\\''");
+}
 function bashCompletions() {
+  const caseEntries = [];
+  for (const f of FLAGS) {
+    if (f.type !== "value")
+      continue;
+    const names = f.short ? `${f.short}|${f.long}` : f.long;
+    if (f.completionHint === "file") {
+      caseEntries.push(`    ${names})
+      COMPREPLY=( $(compgen -f -- "$cur") )
+      return ;;`);
+    } else if (f.completionHint === "directory") {
+      caseEntries.push(`    ${names})
+      COMPREPLY=( $(compgen -d -- "$cur") )
+      return ;;`);
+    } else {
+      caseEntries.push(`    ${names})
+      return ;;`);
+    }
+  }
+  caseEntries.push(`    completions)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
+      return ;;`);
+  const allFlags = FLAGS.flatMap((f) => f.short ? [f.short, f.long] : [f.long]);
+  const subcmds = SUBCOMMANDS.map((s) => s.name);
   return `# numux bash completions
 # Add to ~/.bashrc: eval "$(numux completions bash)"
 _numux() {
@@ -266,59 +476,66 @@ _numux() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
   case "$prev" in
-    --config)
-      COMPREPLY=( $(compgen -f -- "$cur") )
-      return ;;
-    --log-dir)
-      COMPREPLY=( $(compgen -d -- "$cur") )
-      return ;;
-    --only|--exclude)
-      return ;;
-    -n|--name)
-      return ;;
-    completions)
-      COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
-      return ;;
+${caseEntries.join(`
+`)}
   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 "${allFlags.join(" ")}" -- "$cur") )
   else
-    local subcmds="init validate exec completions"
+    local subcmds="${subcmds.join(" ")}"
     COMPREPLY=( $(compgen -W "$subcmds" -- "$cur") )
   fi
 }
 complete -F _numux numux`;
 }
 function zshCompletions() {
+  const subcmdLines = SUBCOMMANDS.map((s) => `    '${s.name}:${sq(s.description)}'`).join(`
+`);
+  const argLines = [];
+  for (const f of FLAGS) {
+    const desc = sq(f.description);
+    if (f.short) {
+      if (f.type === "value") {
+        let suffix = "";
+        if (f.completionHint === "file")
+          suffix = ":file:_files";
+        else if (f.completionHint === "directory")
+          suffix = ":directory:_directories";
+        else
+          suffix = `:${longName(f)}`;
+        argLines.push(`    '(${f.short} ${f.long})'{${f.short},${f.long}}'[${desc}]${suffix}'`);
+      } else {
+        argLines.push(`    '(${f.short} ${f.long})'{${f.short},${f.long}}'[${desc}]'`);
+      }
+    } else {
+      if (f.type === "value") {
+        let suffix = "";
+        if (f.completionHint === "file")
+          suffix = ":file:_files";
+        else if (f.completionHint === "directory")
+          suffix = ":directory:_directories";
+        else
+          suffix = `:${longName(f)}`;
+        argLines.push(`    '${f.long}[${desc}]${suffix}'`);
+      } else {
+        argLines.push(`    '${f.long}[${desc}]'`);
+      }
+    }
+  }
+  const argsBlock = argLines.map((l) => `${l} \\`).join(`
+`);
   return `#compdef numux
 # numux zsh completions
 # Add to ~/.zshrc: eval "$(numux completions zsh)"
 _numux() {
   local -a subcmds
   subcmds=(
-    'init:Create a starter config file'
-    'validate:Validate config and show process graph'
-    'exec:Run a command in a process environment'
-    'completions:Generate shell completions'
+${subcmdLines}
   )
 
   _arguments -s \\
-    '(-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]' \\
-    '--only[Only run these processes]:processes' \\
-    '--exclude[Exclude these processes]:processes' \\
-    '--kill-others[Kill all when any exits]' \\
-    '--no-restart[Disable auto-restart]' \\
-    '--no-watch[Disable file watching]' \\
-    '(-t --timestamps)'{-t,--timestamps}'[Add timestamps to output]' \\
-    '--log-dir[Log directory]:directory:_directories' \\
-    '--debug[Enable debug logging]' \\
+${argsBlock}
     '1:subcommand:->subcmd' \\
     '*:command' \\
     && return
@@ -332,36 +549,37 @@ _numux() {
 _numux`;
 }
 function fishCompletions() {
-  return `# numux fish completions
-# Add to fish: numux completions fish | source
-# Or save to: ~/.config/fish/completions/numux.fish
-complete -c numux -f
-
-# Subcommands
-complete -c numux -n __fish_use_subcommand -a init -d 'Create a starter config file'
-complete -c numux -n __fish_use_subcommand -a validate -d 'Validate config and show process graph'
-complete -c numux -n __fish_use_subcommand -a exec -d 'Run a command in a process environment'
-complete -c numux -n __fish_use_subcommand -a completions -d 'Generate shell completions'
-
-# Completions subcommand
-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 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'
-complete -c numux -l only -r -d 'Only run these processes'
-complete -c numux -l exclude -r -d 'Exclude these processes'
-complete -c numux -l kill-others -d 'Kill all when any exits'
-complete -c numux -l no-restart -d 'Disable auto-restart'
-complete -c numux -l no-watch -d 'Disable file watching'
-complete -c numux -s t -l timestamps -d 'Add timestamps to output'
-complete -c numux -l log-dir -ra '(__fish_complete_directories)' -d 'Log directory'
-complete -c numux -l debug -d 'Enable debug logging'`;
+  const lines = [
+    "# numux fish completions",
+    "# Add to fish: numux completions fish | source",
+    "# Or save to: ~/.config/fish/completions/numux.fish",
+    "complete -c numux -f",
+    "",
+    "# Subcommands"
+  ];
+  for (const s of SUBCOMMANDS) {
+    lines.push(`complete -c numux -n __fish_use_subcommand -a ${s.name} -d '${sq(s.description)}'`);
+  }
+  lines.push("", "# Completions subcommand", "complete -c numux -n '__fish_seen_subcommand_from completions' -a 'bash zsh fish'", "", "# Options");
+  for (const f of FLAGS) {
+    const parts = ["complete -c numux"];
+    if (f.short)
+      parts.push(`-s ${f.short.replace("-", "")}`);
+    parts.push(`-l ${longName(f)}`);
+    if (f.type === "value") {
+      if (f.completionHint === "file") {
+        parts.push("-rF");
+      } else if (f.completionHint === "directory") {
+        parts.push("-ra '(__fish_complete_directories)'");
+      } else {
+        parts.push("-r");
+      }
+    }
+    parts.push(`-d '${sq(f.description)}'`);
+    lines.push(parts.join(" "));
+  }
+  return lines.join(`
+`);
 }
 
 // src/config/expand-scripts.ts
@@ -390,6 +608,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 +637,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 +659,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 +1072,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 +1184,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 +1216,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 +1334,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 +1596,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 +1709,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 +1815,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();
@@ -1579,6 +1867,8 @@ class Pane {
   decoder = new TextDecoder;
   _onScroll = null;
   _onCopy = null;
+  _textLines = null;
+  _textLinesLower = null;
   constructor(renderer, name, cols, rows, interactive = false) {
     this.scrollBox = new ScrollBoxRenderable(renderer, {
       id: `pane-${name}`,
@@ -1614,10 +1904,14 @@ 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;
@@ -1649,16 +1943,19 @@ class Pane {
   search(query) {
     if (!query)
       return [];
-    const text = this.terminal.getText();
-    const lines = text.split(`
+    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++) {
-      const lowerLine = lines[line].toLowerCase();
       let pos = 0;
       while (true) {
-        const idx = lowerLine.indexOf(lowerQuery, pos);
+        const idx = lines[line].indexOf(lowerQuery, pos);
         if (idx === -1)
           break;
         matches.push({ line, start: idx, end: idx + query.length });
@@ -1668,12 +1965,22 @@ class Pane {
     return matches;
   }
   setHighlights(matches, currentIndex) {
-    const regions = matches.map((m, i) => ({
-      line: m.line,
-      start: m.start,
-      end: m.end,
-      backgroundColor: i === currentIndex ? "#b58900" : "#073642"
-    }));
+    const firstVisible = Math.max(0, Math.floor(this.scrollBox.scrollTop) - 2);
+    const lastVisible = Math.ceil(this.scrollBox.scrollTop + this.scrollBox.viewport.height) + 2;
+    const regions = [];
+    for (let i = 0;i < matches.length; i++) {
+      const m = matches[i];
+      if (m.line < firstVisible || m.line > lastVisible) {
+        if (i !== currentIndex)
+          continue;
+      }
+      regions.push({
+        line: m.line,
+        start: m.start,
+        end: m.end,
+        backgroundColor: i === currentIndex ? "#b58900" : "#073642"
+      });
+    }
     this.terminal.highlights = regions;
   }
   clearHighlights() {
@@ -1685,6 +1992,8 @@ class Pane {
   }
   clear() {
     this.terminal.reset();
+    this._textLines = null;
+    this._textLinesLower = null;
   }
   destroy() {
     this.terminal.destroy();
@@ -1823,6 +2132,7 @@ class ColoredSelectRenderable extends SelectRenderable {
     const visibleCount = Math.min(maxVisibleItems, options.length - scrollOffset);
     const baseTextColor = this._focused ? this._focusedTextColor : this._textColor;
     const selectedTextColor = this._selectedTextColor;
+    const lineWidth = fb.width;
     for (let i = 0;i < visibleCount; i++) {
       const actualIndex = scrollOffset + i;
       const itemY = i * linesPerItem;
@@ -1830,13 +2140,11 @@ class ColoredSelectRenderable extends SelectRenderable {
       const isSelected = actualIndex === selectedIndex;
       const defaultColor = isSelected ? selectedTextColor : baseTextColor;
       const colors = this._optionColors[actualIndex];
-      fb.drawText(`${optName}  `, 1, itemY, defaultColor);
+      const textColor = colors?.name ?? defaultColor;
+      fb.drawText(optName.padEnd(lineWidth), 1, itemY, textColor);
       if (colors?.icon) {
         fb.drawText(optName.charAt(0), 1, itemY, colors.icon);
       }
-      if (colors?.name) {
-        fb.drawText(optName.slice(2), 3, itemY, colors.name);
-      }
     }
   }
 }
@@ -1993,6 +2301,7 @@ class App {
   sidebarWidth = 20;
   config;
   resizeTimer = null;
+  searchTimer = null;
   searchMode = false;
   searchQuery = "";
   searchMatches = [];
@@ -2048,6 +2357,11 @@ class App {
       const interactive = this.config.processes[name].interactive === true;
       const pane = new Pane(this.renderer, name, termCols, termRows, interactive);
       pane.onCopy(() => this.statusBar.showTemporaryMessage("Copied!"));
+      pane.onScroll(() => {
+        if (this.searchMode && this.searchMatches.length > 0 && this.activePane === name) {
+          this.updateSearchHighlights();
+        }
+      });
       this.panes.set(name, pane);
       paneContainer.add(pane.scrollBox);
     }
@@ -2248,6 +2562,10 @@ class App {
     this.searchQuery = "";
     this.searchMatches = [];
     this.searchIndex = -1;
+    if (this.searchTimer) {
+      clearTimeout(this.searchTimer);
+      this.searchTimer = null;
+    }
     if (this.activePane) {
       this.panes.get(this.activePane)?.clearHighlights();
     }
@@ -2273,15 +2591,24 @@ class App {
     if (key.name === "backspace") {
       if (this.searchQuery.length > 0) {
         this.searchQuery = this.searchQuery.slice(0, -1);
-        this.runSearch();
+        this.scheduleSearch();
       }
       return;
     }
     if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta) {
       this.searchQuery += key.sequence;
-      this.runSearch();
+      this.scheduleSearch();
     }
   }
+  scheduleSearch() {
+    this.statusBar.setSearchMode(true, this.searchQuery, this.searchMatches.length, this.searchIndex);
+    if (this.searchTimer)
+      clearTimeout(this.searchTimer);
+    this.searchTimer = setTimeout(() => {
+      this.searchTimer = null;
+      this.runSearch();
+    }, 100);
+  }
   runSearch() {
     if (!this.activePane)
       return;
@@ -2325,6 +2652,10 @@ class App {
       clearTimeout(this.resizeTimer);
       this.resizeTimer = null;
     }
+    if (this.searchTimer) {
+      clearTimeout(this.searchTimer);
+      this.searchTimer = null;
+    }
     for (const timer of this.inputWaitTimers.values()) {
       clearTimeout(timer);
     }
@@ -2352,7 +2683,6 @@ class PrefixDisplay {
   noColor;
   decoders = new Map;
   buffers = new Map;
-  maxNameLen;
   logWriter;
   killOthers;
   timestamps;
@@ -2364,7 +2694,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 +2767,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}
 `);
     }
   }
@@ -2594,36 +2922,7 @@ function setupShutdownHandlers(app, logWriter) {
 }
 
 // src/index.ts
-var HELP = `numux \u2014 terminal multiplexer with dependency orchestration
-
-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 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:
-  -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
-  --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
-  --kill-others              Kill all processes when any exits
-  --no-restart               Disable auto-restart for crashed processes
-  --no-watch                 Disable file watching even if config has watch patterns
-  -t, --timestamps           Add timestamps to prefixed output lines
-  --log-dir <path>           Write per-process logs to directory
-  --debug                    Enable debug logging to .numux/debug.log
-  -h, --help                 Show this help
-  -v, --version              Show version
-
-Config files (auto-detected):
-  numux.config.ts, numux.config.js`;
+var HELP = generateHelp();
 var INIT_TEMPLATE = `import { defineConfig } from 'numux'
 
 export default defineConfig({
@@ -2658,8 +2957,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 +3016,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 +3037,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 +3068,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 +3114,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.1",
   "description": "Terminal multiplexer with dependency orchestration",
   "type": "module",
   "license": "MIT",