numux 2.5.1 → 2.6.1

package/README.md

@@ -244,6 +244,32 @@ Each process accepts:
 | `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 |
 | `showCommand` | `boolean` | `true` | Print the command being run as the first line of output |
+| `workspaces` | `boolean \| string \| string[]` | — | Run command in monorepo workspaces (see below) |
+
+### Workspace expansion
+
+Use `workspaces` on a process to expand it into per-workspace processes. Reads the `workspaces` field from your root `package.json`.
+
+```ts
+export default defineConfig({
+  processes: {
+    // All workspaces — filters by script availability for PM run commands
+    lint: { command: 'npm run lint', workspaces: true },
+
+    // Specific workspace by package name
+    validate: { command: 'npm run validate', workspaces: '@repo/image-worker' },
+
+    // Multiple specific workspaces
+    dev: { command: 'npm run dev', workspaces: ['@repo/api', '@repo/web'] },
+  },
+})
+```
+
+Each entry expands into `{name}:{wsName}` processes (e.g. `lint:api`, `lint:web`) with `cwd` set to the workspace directory. All other config (env, dependsOn, color, etc.) is inherited from the template.
+
+When `workspaces: true` is used with a PM run command (`npm run lint`), only workspaces that have the matching script are included. Raw commands (`eslint .`) run in all workspaces.
+
+String values resolve by package name first (with or without scope), then fall back to relative path. Cannot be combined with `cwd`.
 
 ### File watching
 

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: "2.5.1",
+    version: "2.6.1",
     description: "Terminal multiplexer with dependency orchestration",
     type: "module",
     license: "MIT",
@@ -713,29 +713,47 @@ function splitPatternArgs(raw) {
     return { glob: raw, extraArgs: "" };
   return { glob: raw.slice(0, i), extraArgs: raw.slice(i) };
 }
+function expandScriptCommand(raw, pm) {
+  const { glob: script, extraArgs } = splitPatternArgs(raw);
+  if (extraArgs) {
+    return `${pm} run ${script} --${extraArgs}`;
+  }
+  return `${pm} run ${script}`;
+}
 function expandScriptPatterns(config, cwd) {
   const entries = Object.entries(config.processes);
+  const cmd = (v) => typeof v === "string" ? v : v?.command;
   const hasScriptRef = entries.some(([name, value]) => isScriptReference(name, value));
-  if (!hasScriptRef)
+  const hasNpmCommand = entries.some(([, v]) => {
+    const c = cmd(v);
+    return typeof c === "string" && c.startsWith("npm:");
+  });
+  if (!(hasScriptRef || hasNpmCommand))
     return config;
   const dir = config.cwd ?? cwd ?? process.cwd();
   const pkgPath = resolve(dir, "package.json");
-  if (!existsSync(pkgPath)) {
+  if (!existsSync(pkgPath) && hasScriptRef) {
     throw new Error(`Wildcard patterns require a package.json (looked in ${dir})`);
   }
-  const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const pkgJson = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : {};
   const scripts = pkgJson.scripts;
-  if (!scripts || typeof scripts !== "object") {
-    throw new Error('package.json has no "scripts" field');
-  }
-  const scriptNames = Object.keys(scripts);
+  const scriptNames = scripts && typeof scripts === "object" ? Object.keys(scripts) : [];
   const pm = detectPackageManager(pkgJson, dir);
   const expanded = {};
   for (const [name, value] of entries) {
     if (!isScriptReference(name, value)) {
-      expanded[name] = value;
+      let proc = value;
+      const c = cmd(proc);
+      if (typeof c === "string" && c.startsWith("npm:")) {
+        const expandedCmd = expandScriptCommand(c.slice(4), pm);
+        proc = typeof proc === "string" ? expandedCmd : { ...proc, command: expandedCmd };
+      }
+      expanded[name] = proc;
       continue;
     }
+    if (!scripts || typeof scripts !== "object") {
+      throw new Error('package.json has no "scripts" field');
+    }
     const rawPattern = name.startsWith("npm:") ? name.slice(4) : name;
     const { glob: globPattern, extraArgs } = splitPatternArgs(rawPattern);
     const template = value ?? {};
@@ -762,7 +780,7 @@ function expandScriptPatterns(config, cwd) {
       const { color: _color, ...rest } = template;
       expanded[displayName] = {
         ...rest,
-        command: `${pm} run ${scriptName}${extraArgs}`,
+        command: expandScriptCommand(`${scriptName}${extraArgs}`, pm),
         ...color ? { color } : {}
       };
     }
@@ -1278,13 +1296,12 @@ function validateStopSignal(value) {
 // src/config/workspaces.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { basename, resolve as resolve4 } from "path";
-function resolveWorkspaceProcesses(script, cwd) {
+function discoverWorkspaces(cwd) {
   const pkgPath = resolve4(cwd, "package.json");
   if (!existsSync4(pkgPath)) {
     throw new Error(`No package.json found in ${cwd}`);
   }
   const pkgJson = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-  const pm = detectPackageManager(pkgJson, cwd);
   const raw = pkgJson.workspaces;
   let patterns;
   if (Array.isArray(raw)) {
@@ -1294,31 +1311,113 @@ function resolveWorkspaceProcesses(script, cwd) {
   } else {
     throw new Error('No "workspaces" field found in package.json');
   }
-  const dirs = [];
+  const workspaces = [];
   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);
+      if (!existsSync4(wsPkgPath))
+        continue;
+      const wsPkg = JSON.parse(readFileSync3(wsPkgPath, "utf-8"));
+      const pkgName = typeof wsPkg.name === "string" && wsPkg.name ? wsPkg.name : undefined;
+      const name = pkgName ? pkgName.replace(/^@[^/]+\//, "") : basename(abs);
+      const scripts = wsPkg.scripts ?? {};
+      workspaces.push({ dir: abs, name, pkgName, scripts });
+    }
+  }
+  return workspaces.sort((a, b) => a.name.localeCompare(b.name));
+}
+function findWorkspace(nameOrPath, workspaces, cwd) {
+  const byPkgName = workspaces.find((ws) => ws.pkgName === nameOrPath);
+  if (byPkgName)
+    return byPkgName;
+  const byName = workspaces.find((ws) => ws.name === nameOrPath);
+  if (byName)
+    return byName;
+  const absPath = resolve4(cwd, nameOrPath);
+  return workspaces.find((ws) => ws.dir === absPath);
+}
+function extractScriptFromCommand(command) {
+  const match = command.match(/^(?:npm|yarn|pnpm|bun)\s+run\s+(\S+)/);
+  return match ? match[1] : null;
+}
+function expandWorkspaces(config) {
+  const cwd = config.cwd ? resolve4(config.cwd) : process.cwd();
+  const newProcesses = {};
+  let discoveredWorkspaces = null;
+  for (const [name, entry] of Object.entries(config.processes)) {
+    if (typeof entry === "string" || !entry.workspaces) {
+      newProcesses[name] = entry;
+      continue;
+    }
+    const proc = entry;
+    const wsField = proc.workspaces;
+    if (!proc.command) {
+      throw new Error(`Process "${name}": workspaces requires a "command"`);
+    }
+    if (proc.cwd) {
+      throw new Error(`Process "${name}": cannot set both "workspaces" and "cwd"`);
+    }
+    if (!discoveredWorkspaces) {
+      discoveredWorkspaces = discoverWorkspaces(cwd);
+    }
+    if (discoveredWorkspaces.length === 0) {
+      throw new Error(`Process "${name}": no workspaces found`);
+    }
+    const { workspaces: _, ...template } = proc;
+    let targets;
+    if (wsField === true) {
+      const script = extractScriptFromCommand(proc.command);
+      if (script) {
+        targets = discoveredWorkspaces.filter((ws) => ws.scripts[script]);
+        if (targets.length === 0) {
+          throw new Error(`Process "${name}": no workspaces have a "${script}" script`);
+        }
+      } else {
+        targets = discoveredWorkspaces;
       }
+    } else {
+      const names = Array.isArray(wsField) ? wsField : [wsField];
+      targets = [];
+      for (const wsName of names) {
+        const ws = findWorkspace(wsName, discoveredWorkspaces, cwd);
+        if (!ws) {
+          const available = discoveredWorkspaces.map((w) => w.name).join(", ");
+          throw new Error(`Process "${name}": workspace "${wsName}" not found. Available: ${available}`);
+        }
+        targets.push(ws);
+      }
+    }
+    const usedNames = new Set(Object.keys(newProcesses));
+    for (const ws of targets) {
+      let wsKey = `${name}:${ws.name}`;
+      if (usedNames.has(wsKey)) {
+        let suffix = 1;
+        while (usedNames.has(`${wsKey}-${suffix}`))
+          suffix++;
+        wsKey = `${wsKey}-${suffix}`;
+      }
+      usedNames.add(wsKey);
+      newProcesses[wsKey] = { ...template, cwd: ws.dir };
     }
   }
+  return { ...config, processes: newProcesses };
+}
+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(readFileSync3(pkgPath, "utf-8"));
+  const pm = detectPackageManager(pkgJson, cwd);
+  const workspaces = discoverWorkspaces(cwd);
   const processes = {};
   const usedNames = new Set;
-  for (const dir of dirs) {
-    const wsPkgPath = resolve4(dir, "package.json");
-    const wsPkg = JSON.parse(readFileSync3(wsPkgPath, "utf-8"));
-    const scripts = wsPkg.scripts;
-    if (!scripts?.[script])
+  for (const ws of workspaces) {
+    if (!ws.scripts[script])
       continue;
-    let name;
-    if (typeof wsPkg.name === "string" && wsPkg.name) {
-      name = wsPkg.name.replace(/^@[^/]+\//, "");
-    } else {
-      name = basename(dir);
-    }
+    let name = ws.name;
     if (usedNames.has(name)) {
       let suffix = 1;
       while (usedNames.has(`${name}-${suffix}`))
@@ -1328,7 +1427,7 @@ function resolveWorkspaceProcesses(script, cwd) {
     usedNames.add(name);
     processes[name] = {
       command: `${pm} run ${script}`,
-      cwd: dir
+      cwd: ws.dir
     };
   }
   if (Object.keys(processes).length === 0) {
@@ -3851,7 +3950,7 @@ async function main() {
     process.exit(0);
   }
   if (parsed.validate) {
-    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    const raw = expandWorkspaces(expandScriptPatterns(await loadConfig(parsed.configPath)));
     const warnings2 = [];
     let config2 = validateConfig(raw, warnings2);
     config2 = filterByPlatform(config2);
@@ -3894,7 +3993,7 @@ async function main() {
     process.exit(0);
   }
   if (parsed.exec) {
-    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    const raw = expandWorkspaces(expandScriptPatterns(await loadConfig(parsed.configPath)));
     const config2 = validateConfig(raw);
     const proc = config2.processes[parsed.execName];
     if (!proc) {
@@ -3966,7 +4065,7 @@ async function main() {
       }
     }
   } else {
-    const raw = expandScriptPatterns(await loadConfig(parsed.configPath));
+    const raw = expandWorkspaces(expandScriptPatterns(await loadConfig(parsed.configPath)));
     config = validateConfig(raw, warnings);
     config = filterByPlatform(config);
   }

package/dist/types.d.ts

@@ -45,6 +45,11 @@ export interface NumuxProcessConfig<K extends string = string> {
     interactive?: boolean;
     /** `true` = detect ANSI red output, string = regex pattern */
     errorMatcher?: boolean | string;
+    /**
+     * Run command in monorepo workspaces.
+     * `true` = all workspaces, string = specific workspace by name/path, string[] = multiple workspaces
+     */
+    workspaces?: boolean | string | string[];
     /**
      * Print the command being run as the first line of output
      * @default true
@@ -118,7 +123,7 @@ export interface NumuxConfig<K extends string = 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'> {
+export interface ResolvedProcessConfig extends Omit<NumuxProcessConfig, 'dependsOn' | 'workspaces'> {
     dependsOn?: string[];
 }
 /** Validated config with all shorthand expanded to full objects */

package/package.json

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