rman 1.0.12 → 1.2.1

package/services/run.service.js

@@ -1,49 +1,142 @@
 import os from 'node:os';
-import parseNpmScript from '@netlify/parse-npm-script';
+import { inspect } from 'node:util';
 import colors from 'ansi-colors';
 import { tokenize } from 'fast-tokenizer';
 import { Task } from 'power-tasks';
 import { exec } from '../utils/exec.js';
-import { LOG_LEVELS, resolveRootLogLevel } from '../utils/logger.js';
+import { LOG_LEVELS, Logger, resolveRootLogLevel } from '../utils/logger.js';
 import { filterPackages } from '../utils/package-filter.js';
 import { ProgressPanel } from '../utils/progress-panel.js';
+import { runBin } from '../utils/run-bin.js';
 export var RunService;
 (function (RunService) {
     /**
-     * A package's `.rmanrc` (cascaded) can configure `run.<script>.*` - e.g.
-     *   run:
-     *     build:
-     *       concurrency: 2
-     *     lint:
-     *       topo: false
-     *       bail: false
-     * and a package can opt itself out of a script entirely:
-     *   run:
-     *     build:
-     *       skip: true
-     * or supply the command(s) to run when its own package.json doesn't define this script (or its
-     * pre/post hooks) at all - a single string, or an array to run several in sequence - see
-     * `getScriptSteps`:
-     *   run:
-     *     build:
-     *       before: [node ./generate.js, node ./validate.js]
-     *       exec: tsc -b
-     *       after: node ./copy-assets.js
-     *       override: true   # use these even if the package *does* define its own
+     * Registers a source. Called by `loadPlugins` for each plugin's `runSteps`, in `plugins`
+     * declaration order - never as an import side effect, so what is registered is exactly what the
+     * repository's `.rmanrc` asked for.
+     */
+    function addStepSource(source) {
+        /** Idempotent per source: a plugin both declares `runSteps` (registered by `loadPlugins`) and
+         *  may call its own `augmentRun()` for programmatic callers, so the same function arrives
+         *  twice. Pushing twice is harmless - the first match wins - but it makes the registry lie
+         *  about what is in it. */
+        if (stepSources.includes(source))
+            return;
+        stepSources.push(source);
+    }
+    RunService.addStepSource = addStepSource;
+    /** For tests, which would otherwise leak a source into every later case in the process. */
+    function clearStepSources() {
+        stepSources.length = 0;
+    }
+    RunService.clearStepSources = clearStepSources;
+    /**
+     * What the *package itself* declares for the lifecycle `script`, from the contributed sources
+     * alone - no `.rmanrc` involved. `undefined` when it declares nothing.
+     *
+     * Exported because `run` is not the only lifecycle rman wraps: `version` runs hooks around the
+     * version write, and npm spells those `preversion`/`version`/`postversion` in `package.json` -
+     * which is the same `pre<script>`/`<script>`/`post<script>` shape a step source already answers.
+     * So `VersionService` asks here for `'version'` instead of reading `manifest.raw.scripts` itself,
+     * and npm's version lifecycle keeps working with no second seam and no extra line in any plugin.
+     * A plugin for another ecosystem gets its own lifecycle hooks the moment it contributes steps.
+     */
+    function contributedSlots(pkg, script) {
+        return firstContributed(pkg, script);
+    }
+    RunService.contributedSlots = contributedSlots;
+    /**
+     * Runs one slot of a lifecycle belonging to some operation other than `run` itself - `version`'s
+     * hooks around the version write are the only one so far.
+     *
+     * **Here rather than in `VersionService`, because the rule it applies is this service's**: the
+     * package's own declaration for `script` wins over the caller's `fallback`, slot by slot, exactly
+     * as `getScriptSteps` decides it for `run`. Kept in two places that rule would drift, and one of
+     * the copies would sit in the file that writes versions - which now runs no command of its own at
+     * all.
+     *
+     * `fallback` is the caller's own configured step(s), **already evaluated**: `version`'s three
+     * paths are in `DEFERRED_PATHS` precisely because only the caller can bind
+     * `${{ pkg.targetVersion }}`, so interpolating here would either be too early or need a scope this
+     * service has no business holding.
      *
-     * A bare string is shorthand for `exec`, which is by far the common case - a script that is just
-     * a command, with nothing to configure about how it runs:
-     *   run:
-     *     test: mocha          # same as   test: { exec: mocha }
+     * **A list, not one joined string.** `VersionService` used to `join(' && ')` an array into a
+     * single shell line, which a function step cannot be part of - and which quietly changed the
+     * semantics of the shell case too, since `cd x && y` in one process is not the same as two.
      */
+    async function runLifecycleSlot(pkg, script, slot, fallback) {
+        const own = contributedSlots(pkg, script)?.[slot] ?? [];
+        const values = own.length ? own : (fallback ?? []);
+        for (const value of values) {
+            if (typeof value === 'function') {
+                await value(createStepContext(pkg, pkg.dirname));
+                continue;
+            }
+            await exec(value, { cwd: pkg.dirname, stdio: 'inherit' });
+        }
+    }
+    RunService.runLifecycleSlot = runLifecycleSlot;
     function getConfig(pkg, script) {
         const runCfg = pkg.config?.run;
         const cfg = runCfg && typeof runCfg === 'object' ? runCfg[script] : undefined;
-        if (typeof cfg === 'string' || Array.isArray(cfg))
+        /** The bare-value shorthand. A function is `typeof 'function'`, not `'object'`, so without
+         *  naming it here `run: { build: myFn }` fell through to the `{}` below - the long form would
+         *  have worked and the short one silently done nothing, an arbitrary difference. */
+        if (typeof cfg === 'string' || typeof cfg === 'function' || Array.isArray(cfg))
             return { exec: cfg };
         return cfg && typeof cfg === 'object' ? cfg : {};
     }
     RunService.getConfig = getConfig;
+    /**
+     * The context a function step or `if` is handed - see [`RunStepContext`](../core/run-step.ts).
+     *
+     * `runBin` and `logger` are bound to *this run* rather than left to be imported, which is the
+     * whole reason they are handed over: an imported `runBin` knows neither the cwd nor the resolved
+     * log level.
+     */
+    /**
+     * A `run.<script>.before`/`.exec`/`.after` (or `version.<slot>`) value: one step, or several to
+     * run in sequence. A shell command or a function, and a list may mix them.
+     *
+     * **Anything else throws, naming the path.** It used to `return []`, which meant a value rman did
+     * not recognize was dropped with no trace: writing a function here - the obvious guess, and now
+     * the supported form - produced `1 succeeded, 0 failed` with the step never run (measured). A
+     * configuration mistake has to be loud; silence here reads as success.
+     *
+     * Exported, and the only implementation: `VersionService` used to carry a second one that behaved
+     * differently, which is how `version.<slot>` came to join its array with `' && '`.
+     */
+    function normalizeScriptValue(value, at) {
+        const items = Array.isArray(value) ? value : [value];
+        const steps = [];
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            /** An empty string and an absent value are both "nothing here", which is how a `"[*]"` block
+             *  declaring a slot some packages don't use has always behaved. */
+            if (item === undefined || item === null || item === '')
+                continue;
+            if (typeof item === 'string' || typeof item === 'function') {
+                steps.push(item);
+                continue;
+            }
+            const where = Array.isArray(value) ? `${at}[${i}]` : at;
+            throw new Error(`"${where}" must be a shell command or a function, but it is ${describeValue(item)}.\n` +
+                `  A list of either (or both) runs them in sequence.`);
+        }
+        return steps;
+    }
+    RunService.normalizeScriptValue = normalizeScriptValue;
+    function createStepContext(pkg, cwd) {
+        const logLevel = resolveRootLogLevel(pkg.repository);
+        return {
+            pkg,
+            repository: pkg.repository,
+            cwd,
+            runBin: (bin, argv, opts) => runBin(bin, argv, { cwd, logLevel, ...opts }),
+            logger: new Logger(logLevel),
+        };
+    }
+    RunService.createStepContext = createStepContext;
     function resolveEnvPlaceholders(value) {
         return value.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => process.env[name] ?? '');
     }
@@ -151,7 +244,7 @@ export var RunService;
          *  abort using *its own* resolved bail setting (see `runSteps` below) - power-tasks' own
          *  `bail` is a single blanket policy for the whole batch, it can't vary per package. */
         let rootTask;
-        const runSteps = async (ctx, pkgLabel, steps, cwd, pkgBail, pkgLogLevel) => {
+        const runSteps = async (ctx, pkg, pkgLabel, steps, cwd, pkgBail, pkgLogLevel) => {
             ctx.status = 'running';
             ctx.startedAt = Date.now();
             try {
@@ -160,15 +253,14 @@ export var RunService;
                     ctx.currentStep = step.name;
                     ctx.stepIndex = i;
                     if (panel.enabled) {
-                        await exec(step.command, {
-                            cwd,
-                            stdio: 'pipe',
-                            onLine: (line, stdio) => {
-                                ctx.log.push(line);
-                                ctx.lastLine = line;
-                                void stdio;
-                            },
-                        });
+                        const onLine = (line) => {
+                            ctx.log.push(line);
+                            ctx.lastLine = line;
+                        };
+                        if (step.run)
+                            await runFunctionStep(step.run, pkg, cwd, onLine);
+                        else
+                            await exec(step.command, { cwd, stdio: 'pipe', onLine });
                     }
                     else {
                         /** Match the classic rman output: raw command output streams straight through
@@ -177,7 +269,12 @@ export var RunService;
                         const stepStart = Date.now();
                         let stepError;
                         try {
-                            await exec(step.command, { cwd, stdio: 'inherit' });
+                            /** No capture with the panel off: the step owns the terminal, exactly as a shell
+                             *  step's `stdio: 'inherit'` does. */
+                            if (step.run)
+                                await runFunctionStep(step.run, pkg, cwd);
+                            else
+                                await exec(step.command, { cwd, stdio: 'inherit' });
                         }
                         catch (e) {
                             stepError = e;
@@ -209,19 +306,25 @@ export var RunService;
          *  Only in a monorepo. Without one the root *is* the single package, already in the loop below
          *  with the same hooks and the same directory - a bookend would simply run each of them a
          *  second time. */
-        const rootIf = !cwdScope && repository.monorepo && parseIfExpr(rootCfg.if);
-        const rootIfPasses = rootIf ? await evaluateIf(repository, repository.rootPackage, rootIf, ifStatusCache) : true;
-        const rootSkipped = !!cwdScope || !repository.monorepo || rootCfg.skip === true || !rootIfPasses;
+        /** Short-circuited deliberately: a root already out of the run for a structural reason must not
+         *  have its `if` evaluated, now that evaluating one can mean calling the repository's own code. */
+        const rootSkipped = !!cwdScope ||
+            !repository.monorepo ||
+            rootCfg.skip === true ||
+            !(await passesIf(repository, repository.rootPackage, rootCfg.if, repository.dirname, ifStatusCache));
         const rootSteps = rootSkipped ? [] : getScriptSteps(repository.rootPackage, script);
-        const rootPre = rootSteps.filter(s => s.name === 'pre' + script);
-        const rootPost = rootSteps.filter(s => s.name === 'post' + script);
+        /** Filtered on the slot, not on `'pre' + script`: the step labels are `before`/`exec`/`after`
+         *  now - the same words the config uses - rather than npm's `pre<script>` naming, which moved
+         *  out with the package.json source. */
+        const rootPre = rootSteps.filter(s => s.name === 'before');
+        const rootPost = rootSteps.filter(s => s.name === 'after');
         const rootPreName = 'root (pre)';
         const rootPostName = 'root (post)';
         if (rootPre.length) {
             const ctx = panel.addItem(rootPreName, rootPre.length);
             const pkgBail = resolveBail(options.bail, repository.rootPackage, script, true);
             const pkgLogLevel = resolveLogLevel(options.logLevel, repository.rootPackage, script, logLevelDefault);
-            children.push(new Task(() => runSteps(ctx, 'root', rootPre, repository.dirname, pkgBail, pkgLogLevel), {
+            children.push(new Task(() => runSteps(ctx, repository.rootPackage, 'root', rootPre, repository.dirname, pkgBail, pkgLogLevel), {
                 name: ctx.name,
                 exclusive: true,
             }));
@@ -231,8 +334,7 @@ export var RunService;
             const pkgCfg = getConfig(pkg, script);
             if (pkgCfg.skip === true)
                 continue;
-            const pkgIf = parseIfExpr(pkgCfg.if);
-            if (pkgIf && !(await evaluateIf(repository, pkg, pkgIf, ifStatusCache)))
+            if (!(await passesIf(repository, pkg, pkgCfg.if, pkg.dirname, ifStatusCache)))
                 continue;
             const steps = getScriptSteps(pkg, script);
             if (steps.length)
@@ -246,10 +348,12 @@ export var RunService;
             const pkgTopo = resolveBool(options.topo, pkg, script, 'topo', topo);
             const pkgBail = resolveBail(options.bail, pkg, script, true);
             const pkgLogLevel = resolveLogLevel(options.logLevel, pkg, script, logLevelDefault);
-            const dependencies = pkgTopo ? pkg.dependencies.filter(d => stepsByPackage.has(d)) : [];
+            /** power-tasks identifies a task by its name string, so the graph is handed over as names -
+             *  the references are what rman reasons with, the names are what the scheduler wants. */
+            const dependencies = pkgTopo ? pkg.dependencies.filter(d => stepsByPackage.has(d.name)).map(d => d.name) : [];
             if (rootPre.length)
                 dependencies.push(rootPreName);
-            children.push(new Task(() => runSteps(ctx, pkg.name, steps, pkg.dirname, pkgBail, pkgLogLevel), {
+            children.push(new Task(() => runSteps(ctx, pkg, pkg.name, steps, pkg.dirname, pkgBail, pkgLogLevel), {
                 name: ctx.name,
                 dependencies,
             }));
@@ -258,7 +362,7 @@ export var RunService;
             const ctx = panel.addItem(rootPostName, rootPost.length);
             const pkgBail = resolveBail(options.bail, repository.rootPackage, script, true);
             const pkgLogLevel = resolveLogLevel(options.logLevel, repository.rootPackage, script, logLevelDefault);
-            children.push(new Task(() => runSteps(ctx, 'root', rootPost, repository.dirname, pkgBail, pkgLogLevel), {
+            children.push(new Task(() => runSteps(ctx, repository.rootPackage, 'root', rootPost, repository.dirname, pkgBail, pkgLogLevel), {
                 name: ctx.name,
                 exclusive: true,
                 /** Must wait for every package task to finish, not just be "exclusive" once it starts. */
@@ -341,7 +445,7 @@ function printLegacyExecutingLine(commandName, pkgLabel, step, level) {
     if (LOG_LEVELS.indexOf(level) < LOG_LEVELS.indexOf('verbose'))
         return;
     const sep = colors.gray('┆');
-    console.log(colors.magenta('verbose'), commandName, colors.cyan(pkgLabel), sep, colors.cyanBright.bold(step.name), colors.cyanBright.bold('executing'), sep, step.command);
+    console.log(colors.magenta('verbose'), commandName, colors.cyan(pkgLabel), sep, colors.cyanBright.bold(step.name), colors.cyanBright.bold('executing'), sep, step.label);
 }
 function printLegacyStepLine(commandName, pkgLabel, step, durationMs, level, error) {
     if (!error && LOG_LEVELS.indexOf(level) < LOG_LEVELS.indexOf('info'))
@@ -351,57 +455,129 @@ function printLegacyStepLine(commandName, pkgLabel, step, durationMs, level, err
     const sep = colors.gray('┆');
     const levelLabel = error ? colors.red('error') : colors.green('info');
     const status = error ? colors.red.bold('failed') : colors.green.bold('success');
-    console.log(levelLabel, commandName, colors.cyan(pkgLabel), sep, colors.cyanBright.bold(step.name), status, sep, step.command, colors.yellow(` (${durationMs} ms)`));
+    console.log(levelLabel, commandName, colors.cyan(pkgLabel), sep, colors.cyanBright.bold(step.name), status, sep, step.label, colors.yellow(` (${durationMs} ms)`));
+}
+function describeValue(value) {
+    if (Array.isArray(value))
+        return 'a nested array';
+    if (value && typeof value === 'object')
+        return 'an object';
+    return `a ${typeof value} (${JSON.stringify(value)})`;
 }
-/** A `run.<script>.script`/`.preScript`/`.postScript` value: one command, or several to run in sequence. */
-function normalizeScriptValue(value) {
-    if (typeof value === 'string')
-        return value || undefined;
-    if (Array.isArray(value)) {
-        // joined with "&&", same as a multi-command package.json script - each entry becomes its
-        // own step below, and an earlier failure stops the rest (npm's own semantics).
-        const parts = value.filter((v) => typeof v === 'string' && !!v);
-        return parts.length ? parts.join(' && ') : undefined;
+/** One step, with the label the panel and the per-step log show. A function's own name - so
+ *  `function copyDocs()` and `const copyDocs = () => {}` both read as `copyDocs` - falling back to
+ *  the slot's own word for one passed inline, which has no name at all. */
+function toStep(slot, value) {
+    if (typeof value === 'function')
+        return { name: slot, label: value.name || `${slot} (js)`, run: value };
+    return { name: slot, label: value, command: value };
+}
+/**
+ * Runs a function step.
+ *
+ * **`console` is redirected while it runs, but only when the panel is on** - and that is the same
+ * split a shell step already makes. `exec` hands the panel its output through `stdio: 'pipe'` and
+ * `onLine`, so a function writing straight to the real stdout would print *over* the panel it is
+ * being rendered inside. With the panel off, `exec` uses `stdio: 'inherit'` and the step owns the
+ * terminal; a function gets the same, untouched.
+ *
+ * Restored in a `finally`, because a step that throws must not leave the rest of the run writing
+ * into a log nobody reads.
+ */
+async function runFunctionStep(run, pkg, cwd, onLine) {
+    const context = RunService.createStepContext(pkg, cwd);
+    if (!onLine) {
+        await run(context);
+        return;
     }
-    return undefined;
+    const console_ = globalThis.console;
+    const original = {};
+    for (const method of CAPTURED_CONSOLE) {
+        original[method] = console_[method];
+        console_[method] = (...args) => {
+            /** Split, because one `console.log` may carry several lines and the panel's log is a list of
+             *  them - a multi-line entry would render as one unreadable row. */
+            for (const line of format(args).split('\n'))
+                onLine(line);
+        };
+    }
+    try {
+        await run(context);
+    }
+    finally {
+        for (const method of CAPTURED_CONSOLE)
+            console_[method] = original[method];
+    }
+}
+const CAPTURED_CONSOLE = ['log', 'info', 'warn', 'error', 'debug'];
+function format(args) {
+    return args.map(arg => (typeof arg === 'string' ? arg : inspect(arg))).join(' ');
 }
 /**
- * Resolves a package's steps for `script`, including its own pre/post hooks (npm's own
- * convention) - `.rmanrc run.<script>.script`/`.preScript`/`.postScript` (cascaded) can each supply
- * a command (or an array of them, run in sequence) to use when the package's own package.json has
- * none for that slot (`script`/`pre<script>`/`post<script>`), letting a package run a script it
- * never defined at all. `run.<script>.override` goes further: with it, the config's command
- * replaces the package's own for a slot even when the package *does* define one there.
+ * Whether a script runs for `pkg` at all - `run.<script>.if`, in either of its two forms.
+ *
+ * The function form is checked **first**: `parseIfExpr` answers `undefined` for anything that is
+ * not a string, which the caller reads as "no condition given", so a function reaching it would be
+ * a condition that silently always passed.
+ */
+async function passesIf(repository, pkg, raw, cwd, statusCache) {
+    if (typeof raw === 'function') {
+        return !!(await raw(RunService.createStepContext(pkg, cwd)));
+    }
+    const node = RunService.parseIfExpr(raw);
+    return node ? RunService.evaluateIf(repository, pkg, node, statusCache) : true;
+}
+/**
+ * Resolves a package's steps for `script`, from its `.rmanrc` and from whatever sources plugins
+ * contributed (`RunService.addStepSource`).
+ *
+ * **Resolved slot by slot, not script by script**, and that is load-bearing: a package whose
+ * `package.json` defines only `build` still gets `before`/`after` from a `"[*]"` config block. A
+ * whole-script precedence would silently drop them.
+ *
+ * Precedence per slot, first match winning:
+ *
+ * 1. `run.<script>.override: true` -> the config, always. The escape hatch for "ignore what the
+ *    package says it does".
+ * 2. a **contributed** source - `package.json#scripts` via `rman-node`. It wins over the config
+ *    because it is the *package's own* declaration, while a config value typically arrives
+ *    cascaded from the root or an `extends` base; the more specific statement wins, as everywhere
+ *    else in rman.
+ * 3. the config's own `before`/`exec`/`after`, letting a package run a script it never declared.
+ * 4. nothing - and an empty result is what tells `runScript` this package defines no such script.
  */
 function getScriptSteps(pkg, script) {
     const cfg = RunService.getConfig(pkg, script);
-    const json = { ...pkg.json, scripts: { ...(pkg.json.scripts || {}) } };
-    const applyConfigScript = (key, rawValue) => {
-        const value = normalizeScriptValue(rawValue);
-        if (!value)
-            return;
-        const hasOwn = typeof json.scripts[key] === 'string' && json.scripts[key];
-        if (cfg.override === true || !hasOwn)
-            json.scripts[key] = value;
+    const override = cfg.override === true;
+    const contributed = firstContributed(pkg, script);
+    const fromConfig = {
+        before: RunService.normalizeScriptValue(cfg.before, `run.${script}.before`),
+        exec: RunService.normalizeScriptValue(cfg.exec, `run.${script}.exec`),
+        after: RunService.normalizeScriptValue(cfg.after, `run.${script}.after`),
     };
-    applyConfigScript(script, cfg.exec);
-    applyConfigScript('pre' + script, cfg.before);
-    applyConfigScript('post' + script, cfg.after);
-    json.scripts[script] = json.scripts[script] || '#';
-    const info = parseNpmScript(json, 'npm run ' + script);
-    if (!info?.raw?.length)
-        return [];
     const steps = [];
-    for (const s of info.steps) {
-        const parsed = Array.isArray(s.parsed) ? s.parsed : [s.parsed];
-        for (const command of parsed) {
-            if (command === '#')
-                continue;
-            steps.push({ name: s.name, command });
-        }
+    for (const slot of SCRIPT_SLOTS) {
+        const own = contributed?.[slot] ?? [];
+        const configured = fromConfig[slot] ?? [];
+        const values = override ? (configured.length ? configured : own) : own.length ? own : configured;
+        for (const value of values)
+            steps.push(toStep(slot, value));
     }
     return steps;
 }
+/** The first source that says this package declares the script at all. Declaration order, so a
+ *  repository listing two plugins gets a predictable answer rather than a merged one. */
+function firstContributed(pkg, script) {
+    for (const source of stepSources) {
+        const slots = source(pkg, script);
+        if (slots && (slots.before?.length || slots.exec?.length || slots.after?.length))
+            return slots;
+    }
+    return undefined;
+}
+/** In execution order - `before`, the script itself, then `after`. */
+const SCRIPT_SLOTS = ['before', 'exec', 'after'];
+const stepSources = [];
 /**
  * Splits on whitespace, but a `(...)` group collapses to a single token holding its inner text
  * (parens stripped, inner whitespace kept) - `evaluate` below re-tokenizes any token that still

package/services/system-info.d.ts

@@ -8,15 +8,30 @@ export declare namespace SystemInfo {
         root: string;
         packageCount: number;
     }
-    /** Whatever `envinfo` reports (OS/CPU/Memory/Shell, Node + the resolved package manager, git,
-     *  installed rman/typescript versions), grouped by category - shape is `envinfo`'s own, not ours. */
+    /** Whatever `envinfo` reports, grouped by category - shape is `envinfo`'s own, not ours. */
     type SystemInfo = Record<string, Record<string, unknown>>;
     /**
-     * `packageManager` (the repository's resolved `.rmanrc "packageManager"`, default `'npm'`)
-     * decides which package manager's version actually gets queried/reported - a pnpm-configured
-     * repo has no real use for npm's own version, since every package-manager-aware command
-     * (`ci`/`publish`) already shells out to pnpm, not npm, for it.
+     * **Deliberately empty of anything language-specific.** A plugin adds what its own ecosystem
+     * needs by augmenting this interface - see `rman-node`, which adds `packageManager` and turns it
+     * into `envinfo` categories. There is no `packageManager` here, and that is the point: the core
+     * has no opinion about npm, so a repository in another language cannot end up reporting
+     * "npm: Not Found", which is a wrong answer rather than a missing feature.
      */
-    function getSystemInfo(packageManager?: 'npm' | 'yarn' | 'pnpm' | 'bun', options?: envinfo.RunConfig): Promise<SystemInfo.SystemInfo>;
+    interface Options {
+        /**
+         * The repository the report is about. The core uses it for nothing - `getRepositoryInfo` is a
+         * separate call - and it is here **for augmentations**, which need somewhere to read a setting
+         * from: `rman-node` takes `.rmanrc "packageManager"` off it.
+         */
+        repository?: Repository;
+        /** Extra `envinfo` categories, merged **over** the defaults - so an augmentation can replace
+         *  `Binaries` rather than only append to it. */
+        envinfo?: envinfo.RunConfig;
+    }
+    /** The shape of `getSystemInfo` - named so a plugin can wrap it without restating the signature
+     *  (see `rman-node`'s system-info augmentation). */
+    type GetSystemInfo = (options?: Options) => Promise<SystemInfo.SystemInfo>;
+    /** What this machine is, in terms true of any repository: OS, CPU, memory, shell, Node, git. */
+    function getSystemInfo(options?: Options): Promise<SystemInfo.SystemInfo>;
     function getRepositoryInfo(repository: Repository): SystemInfo.RepositoryInfo;
 }

package/services/system-info.js

@@ -1,33 +1,18 @@
 import envinfo from 'envinfo';
 export var SystemInfo;
 (function (SystemInfo) {
-    /** `.rmanrc "packageManager"` value -> the `Binaries` key `envinfo` recognizes for it (`npm`/
-     *  `pnpm`/`bun` are lowercase, `Yarn` isn't - envinfo's own naming, not ours). */
-    const PACKAGE_MANAGER_BINARY = {
-        npm: 'npm',
-        yarn: 'Yarn',
-        pnpm: 'pnpm',
-        bun: 'bun',
-    };
-    /**
-     * `packageManager` (the repository's resolved `.rmanrc "packageManager"`, default `'npm'`)
-     * decides which package manager's version actually gets queried/reported - a pnpm-configured
-     * repo has no real use for npm's own version, since every package-manager-aware command
-     * (`ci`/`publish`) already shells out to pnpm, not npm, for it.
-     */
-    async function getSystemInfo(packageManager, options) {
+    /** What this machine is, in terms true of any repository: OS, CPU, memory, shell, Node, git. */
+    async function getSystemInfo(options) {
         return JSON.parse(await envinfo.run({
             System: ['OS', 'CPU', 'Memory', 'Shell'],
-            Binaries: ['Node', PACKAGE_MANAGER_BINARY[packageManager ?? 'npm']],
+            Binaries: ['Node'],
             Utilities: ['Git'],
-            npmPackages: ['rman', 'typescript'],
-            npmGlobalPackages: ['typescript'],
-            ...options,
+            ...options?.envinfo,
         }, 
-        // showNotFound: without it, envinfo *omits* a configured-but-uninstalled package manager
-        // from Binaries entirely (indistinguishable from never having asked) instead of reporting
-        // "Not Found" - worth surfacing, since it means .rmanrc "packageManager" points at
-        // something that isn't actually on this machine.
+        // showNotFound: without it, envinfo *omits* a configured-but-uninstalled binary from
+        // Binaries entirely (indistinguishable from never having asked) instead of reporting
+        // "Not Found" - worth surfacing, since it means something a config points at isn't
+        // actually on this machine.
         { json: true, showNotFound: true }));
     }
     SystemInfo.getSystemInfo = getSystemInfo;