rman 1.0.12 → 1.2.1

package/utils/run-bin.js

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import colors from 'ansi-colors';
+import { BinPath } from './bin-path.js';
+import { trackChild } from './child-tracker.js';
+import { LOG_LEVELS } from './logger.js';
+/**
+ * Runs one of the repository's locally installed binaries, passing **argv as an array** - no shell.
+ *
+ * Use this over `exec` whenever the arguments aren't a fixed string: `exec` runs through a shell, so
+ * an interpolated path containing a space silently becomes two arguments, and a value containing
+ * `;` or `&&` becomes another command. Here they cannot - each element of `argv` arrives as exactly
+ * one argument. `exec` remains the right tool for a command the config author wrote as a string,
+ * shell operators and all (`run.<script>`, `version` hooks).
+ *
+ * The binary is found by PATH, not spawned by path: `BinPath.env` prepends whatever the repository's
+ * plugins say a local install lives in (`node_modules/.bin`
+ * from `cwd` up the directory tree, which is what makes `eslint` resolve to the repository's own
+ * copy - and on Windows resolve `eslint.cmd`, which spawning a bare path would not.
+ *
+ * Rejects on a non-zero exit (the error names the command and the code) and on a missing binary,
+ * where it asks the useful question instead of reporting `ENOENT`. A non-zero exit has to be an
+ * error rather than a returned code: a lint or type-check step that passes in CI having checked
+ * nothing is the outcome worth ruling out, and that is what silently discarding a code produces.
+ */
+export async function runBin(bin, argv, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const logLevel = options.logLevel ?? 'info';
+    const atLeast = (level) => LOG_LEVELS.indexOf(logLevel) >= LOG_LEVELS.indexOf(level);
+    /** Below 'info' the output is captured rather than streamed, so a quiet run stays quiet and a
+     *  failing one can still say what went wrong. */
+    const stdio = options.stdio ?? (atLeast('info') ? 'inherit' : 'pipe');
+    if (atLeast('verbose'))
+        console.log(colors.magenta('verbose'), colors.gray('$'), bin, argv.join(' '));
+    const child = spawn(process.platform === 'win32' ? `${bin}.cmd` : bin, argv, {
+        cwd,
+        stdio: stdio === 'inherit' ? 'inherit' : 'pipe',
+        env: BinPath.env({ cwd, env: options.env }),
+        windowsHide: true,
+    });
+    /** So an interrupted rman does not leave this running - `exec` always did this and this did not,
+     *  which meant a plugin command's child outlived a Ctrl-C. See `trackChild`. */
+    trackChild(child);
+    let output = '';
+    child.stdout?.on('data', (d) => (output += d.toString()));
+    child.stderr?.on('data', (d) => (output += d.toString()));
+    return new Promise((resolve, reject) => {
+        child.on('error', (e) => {
+            reject(e?.code === 'ENOENT' ? new Error(`"${bin}" was not found - is it installed in this repository?`) : e);
+        });
+        child.on('close', code => {
+            if (code === 0)
+                return resolve({ code: 0, output });
+            /** Captured output has to be surfaced here or it is lost with the process - the one thing
+             *  worse than a noisy failure is a silent one. 'silent' is the caller saying otherwise. */
+            if (stdio === 'pipe' && output && logLevel !== 'silent')
+                process.stderr.write(output);
+            const err = new Error(`"${bin} ${argv.join(' ')}" exited with code ${code}`);
+            err.code = code;
+            err.output = output;
+            reject(err);
+        });
+    });
+}

package/utils/version-stamp.d.ts

@@ -19,18 +19,26 @@ export declare const OCI_VERSION_LABEL = "org.opencontainers.image.version";
  */
 export declare function stampVersionLabel(content: string, version: string): string | undefined;
 /**
- * Rewrites the string assigned to a `name` constant (default `version`) in a source file to
- * `version`, returning the new content - or `undefined` when there was nothing to change, so a
- * caller can skip writing the file at all. Both an assignment and an object property are matched:
+ * Rewrites the **quoted string assigned to `name`** (default `version`) to `version`, returning the
+ * new content - or `undefined` when there was nothing to change, so a caller can write nothing and
+ * report a file that matched nothing. Both an assignment and an object property are matched:
  *
  * ```ts
  * export const version = '1';   ->   export const version = '6.0.10';
  * { name: 'app', version: '1' } ->   { name: 'app', version: '6.0.10' }
  * ```
  *
- * Unlike the Dockerfile label there is no standard naming a file as holding the version, so this
- * only ever runs against files `.rmanrc "version.stamp"` explicitly lists - which is also what
- * keeps a match this broad safe.
+ * **A helper, not a policy**: which shape a language declares a version in is
+ * `ManifestProvider.stampVersion`'s answer, and this is the one most of them share, exported so
+ * every provider need not re-derive the same regex. Measured, it reaches a Go `const version =
+ * "…"`, a Gradle/TOML `version = "…"` and a JS/TS `const version = '…'`.
+ *
+ * **What it does not reach**, all measured, and the reason the decision is a seam: an identifier
+ * with anything between it and the value (`pub const VERSION: &str = "…"`, and equally TypeScript's
+ * own `const version: string = '…'`), an unquoted value (`pom.xml`'s `<version>1.0.0</version>`),
+ * and - unless `name` says so - any other spelling (`VERSION`, `Version`, `__version__`,
+ * `appVersion`). `name` was dead for exactly that reason: nothing passed it, so only the lowercase
+ * word `version` was ever matched.
  *
  * Stamping the *source* rather than the build output is the point: a build-time rewrite leaves the
  * checked-in file claiming some placeholder, so anything running from source (tests, ts-node, the

package/utils/version-stamp.js

@@ -41,18 +41,26 @@ export function stampVersionLabel(content, version) {
     return changed ? lines.join('\n') : undefined;
 }
 /**
- * Rewrites the string assigned to a `name` constant (default `version`) in a source file to
- * `version`, returning the new content - or `undefined` when there was nothing to change, so a
- * caller can skip writing the file at all. Both an assignment and an object property are matched:
+ * Rewrites the **quoted string assigned to `name`** (default `version`) to `version`, returning the
+ * new content - or `undefined` when there was nothing to change, so a caller can write nothing and
+ * report a file that matched nothing. Both an assignment and an object property are matched:
  *
  * ```ts
  * export const version = '1';   ->   export const version = '6.0.10';
  * { name: 'app', version: '1' } ->   { name: 'app', version: '6.0.10' }
  * ```
  *
- * Unlike the Dockerfile label there is no standard naming a file as holding the version, so this
- * only ever runs against files `.rmanrc "version.stamp"` explicitly lists - which is also what
- * keeps a match this broad safe.
+ * **A helper, not a policy**: which shape a language declares a version in is
+ * `ManifestProvider.stampVersion`'s answer, and this is the one most of them share, exported so
+ * every provider need not re-derive the same regex. Measured, it reaches a Go `const version =
+ * "…"`, a Gradle/TOML `version = "…"` and a JS/TS `const version = '…'`.
+ *
+ * **What it does not reach**, all measured, and the reason the decision is a seam: an identifier
+ * with anything between it and the value (`pub const VERSION: &str = "…"`, and equally TypeScript's
+ * own `const version: string = '…'`), an unquoted value (`pom.xml`'s `<version>1.0.0</version>`),
+ * and - unless `name` says so - any other spelling (`VERSION`, `Version`, `__version__`,
+ * `appVersion`). `name` was dead for exactly that reason: nothing passed it, so only the lowercase
+ * word `version` was ever matched.
  *
  * Stamping the *source* rather than the build output is the point: a build-time rewrite leaves the
  * checked-in file claiming some placeholder, so anything running from source (tests, ts-node, the
@@ -60,15 +68,19 @@ export function stampVersionLabel(content, version) {
  * to be redone on every build.
  */
 export function stampVersionConstant(content, version, name = 'version') {
-    let changed = false;
+    let matched = false;
     const pattern = new RegExp(`(\\b${escapeRegExp(name)}\\s*[:=]\\s*)(['"\`])([^'"\`\\n]*)\\2`, 'g');
-    const result = content.replace(pattern, (whole, prefix, quote) => {
-        const next = `${prefix}${quote}${version}${quote}`;
-        if (next !== whole)
-            changed = true;
-        return next;
+    const result = content.replace(pattern, (_whole, prefix, quote) => {
+        matched = true;
+        return `${prefix}${quote}${version}${quote}`;
     });
-    return changed ? result : undefined;
+    /**
+     * `undefined` means **nothing matched**, not "no change was needed" - the two used to be the same
+     * answer, and that made the caller's error message a liar: a file already holding the target
+     * version reported that nothing in it could be rewritten. A caller that wants to skip an identical
+     * write compares the result with what it passed in.
+     */
+    return matched ? result : undefined;
 }
 const LABEL_VALUE = new RegExp(`(${OCI_VERSION_LABEL.replace(/\./g, '\\.')}\\s*=\\s*)("[^"\\n]*"|'[^'\\n]*'|[^\\s\\\\]+)`, 'g');
 function escapeRegExp(value) {

package/commands/ci.command.js

@@ -1,30 +0,0 @@
-import { CiService } from '../services/ci.service.js';
-import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-export function initCli(repository, program) {
-    program.command({
-        command: 'ci',
-        describe: 'Deletes node_modules and lockfiles in every package, then reinstalls from scratch',
-        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
-            .example('$0 ci', '')
-            .option('package-manager', {
-            describe: 'Package manager to install with (default: npm, or .rmanrc "packageManager")',
-            choices: PACKAGE_MANAGERS,
-        })
-            .option('progress', {
-            describe: 'Show a live progress panel while running (default: true; auto-disabled when not a TTY). ' +
-                'Unlike run/build, completion is not reported as a per-package tally - only failures are called out.',
-            type: 'boolean',
-        }),
-        handler: async (args) => {
-            await assertAllowedBranch(repository, readBranchGuardOptions(args));
-            await CiService.reinstall(repository, {
-                ...readPackageFilterOptions(args),
-                packageManager: args.packageManager,
-                progress: args.progress,
-                logLevel: args.logLevel,
-            });
-        },
-    });
-}
-const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];

package/commands/clean.command.d.ts

@@ -1,3 +0,0 @@
-import type { Argv } from 'yargs';
-import type { Repository } from '../core/repository.js';
-export declare function initCli(repository: Repository, program: Argv): void;

package/commands/clean.command.js

@@ -1,36 +0,0 @@
-import { CleanService } from '../services/clean.service.js';
-import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-export function initCli(repository, program) {
-    program.command({
-        command: 'clean',
-        describe: 'Removes compiled TypeScript output and any extra files/dirs configured via .rmanrc "clean"',
-        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
-            .example('$0 clean', '')
-            .example('$0 clean --dry-run', '# Preview what would be removed')
-            .option('progress', {
-            describe: 'Show a live progress panel (default: true; auto-disabled when not a TTY)',
-            type: 'boolean',
-        })
-            .option('dry-run', {
-            describe: 'Report what would be removed without actually removing anything',
-            type: 'boolean',
-        })
-            .option('root', {
-            alias: 'r',
-            describe: 'Clean the whole repository even when the current directory is inside a single ' +
-                'package (which otherwise scopes cleaning to just that package). No effect elsewhere.',
-            type: 'boolean',
-        }),
-        handler: async (args) => {
-            await assertAllowedBranch(repository, readBranchGuardOptions(args));
-            await CleanService.clean(repository, {
-                ...readPackageFilterOptions(args),
-                progress: args.progress,
-                dryRun: args.dryRun,
-                root: args.root,
-                logLevel: args.logLevel,
-            });
-        },
-    });
-}

package/commands/publish.command.d.ts

@@ -1,3 +0,0 @@
-import type { Argv } from 'yargs';
-import type { Repository } from '../core/repository.js';
-export declare function initCli(repository: Repository, program: Argv): void;

package/commands/publish.command.js

@@ -1,225 +0,0 @@
-import readline from 'node:readline/promises';
-import colors from 'ansi-colors';
-import { CiService } from '../services/ci.service.js';
-import { DockerPublishService } from '../services/docker-publish.service.js';
-import { PublishService } from '../services/publish.service.js';
-import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-export function initCli(repository, program) {
-    program.command({
-        command: 'publish',
-        describe: 'Publishes every package to its configured target(s) (npm by default, or .rmanrc "publish.target")',
-        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
-            .example('$0 publish', '# Show the plan, then ask for confirmation')
-            .example('$0 publish --yes', '# Publish immediately, no confirmation')
-            .example('$0 publish --dry-run', '# Only show the plan, never publish')
-            .example('$0 publish --target docker', '# Only the packages configured for the "docker" target')
-            .option('yes', {
-            alias: 'y',
-            describe: 'Skip the confirmation prompt and publish immediately',
-            type: 'boolean',
-        })
-            .option('dry-run', {
-            describe: 'Only show the plan - never publishes, regardless of --yes',
-            type: 'boolean',
-        })
-            .option('json', {
-            alias: 'j',
-            describe: 'Print the plan as JSON instead of text - one entry per package and target. Combine with ' +
-                '--dry-run to ask "is there anything to publish?" without publishing (e.g. a CI release gate).',
-            type: 'boolean',
-        })
-            .option('target', {
-            describe: 'Restrict this run to just these publish target(s) ("npm"/"docker", repeatable) - default: ' +
-                'every target each package itself is configured for (.rmanrc "publish.target", "npm" when unset). ' +
-                'A package that opts into "docker" but has no "publish.docker" config errors clearly instead of ' +
-                'being silently skipped.',
-            type: 'array',
-            choices: ['npm', 'docker'],
-        })
-            .option('ignore-dirty', {
-            describe: 'Exclude a package with uncommitted local changes instead of aborting the whole run',
-            type: 'boolean',
-        })
-            .option('package-manager', {
-            describe: 'Package manager to publish with (default: npm, or .rmanrc "packageManager")',
-            choices: PACKAGE_MANAGERS,
-        })
-            .option('access', {
-            describe: 'npm publish --access <public|restricted> - required by the registry for a new scoped package',
-            choices: ['public', 'restricted'],
-        })
-            .option('tag', {
-            describe: 'npm publish --tag <tag> - the dist-tag this version is published under (default "latest")',
-            type: 'string',
-        })
-            .option('otp', {
-            describe: 'npm publish --otp <otp> - a 2FA one-time password, for registries that require it',
-            type: 'string',
-        })
-            .option('registry', {
-            describe: 'Registry to check against and publish to (default: whatever .npmrc already configures)',
-            type: 'string',
-        })
-            .option('userconfig', {
-            describe: 'Path to a custom .npmrc to use for both the registry check and the actual publish',
-            type: 'string',
-        })
-            .option('contents', {
-            describe: "Subdirectory to publish from, relative to each package's own directory - only consulted when a " +
-                'package has no "publishConfig.directory" of its own (that always wins when present)',
-            type: 'string',
-        })
-            .option('docker-namespace', {
-            describe: 'Prefixed onto a bare (no "/") "publish.docker.image" - default: the DOCKERHUB_NAMESPACE ' +
-                'environment variable.',
-            type: 'string',
-        }),
-        handler: async (args) => {
-            await assertAllowedBranch(repository, readBranchGuardOptions(args));
-            const targets = resolveTargets(args.target);
-            const explicitTargets = !!args.target?.length;
-            const explicitDockerTarget = explicitTargets && targets.has('docker');
-            const ignoreDirty = args.ignoreDirty;
-            const npmOptions = {
-                ...readPackageFilterOptions(args),
-                ignoreDirty,
-                registry: args.registry,
-                userconfig: args.userconfig,
-            };
-            const dockerOptions = {
-                ...readPackageFilterOptions(args),
-                ignoreDirty,
-                namespace: args.dockerNamespace,
-            };
-            const npmPlan = targets.has('npm') ? await PublishService.getPlan(repository, npmOptions) : [];
-            const dockerPlan = targets.has('docker') ? await DockerPublishService.getPlan(repository, dockerOptions) : [];
-            if (args.json) {
-                console.log(JSON.stringify([...npmPlan.map(e => jsonEntry(e, 'npm')), ...dockerPlan.map(e => jsonEntry(e, 'docker'))], undefined, 2));
-            }
-            else {
-                printPlan(npmPlan);
-                printPlan(dockerPlan, 'docker');
-            }
-            if (explicitDockerTarget && !dockerPlan.length) {
-                const message = '--target docker was given, but no package\'s .rmanrc configures "publish.docker".';
-                console.log(colors.red(message));
-                const err = new Error(message);
-                err.logged = true;
-                throw err;
-            }
-            const errors = [...npmPlan, ...dockerPlan].filter(e => e.status === 'error');
-            if (errors.length) {
-                const allDirty = errors.every(e => e.reason === 'uncommitted local changes');
-                const message = allDirty
-                    ? `${errors.length} package(s) have uncommitted local changes ` +
-                        '(pass --ignore-dirty to exclude them instead of aborting)'
-                    : `${errors.length} package(s) failed to prepare for publish - see the errors above`;
-                console.log(colors.red(message));
-                const err = new Error(message);
-                err.logged = true;
-                throw err;
-            }
-            if (![...npmPlan, ...dockerPlan].some(e => e.status === 'publish')) {
-                if (!args.json)
-                    console.log(colors.gray('Nothing to publish.'));
-                return;
-            }
-            if (args.dryRun)
-                return;
-            let proceed = !!args.yes;
-            if (!proceed) {
-                if (!process.stdout.isTTY) {
-                    console.log(colors.gray('Not a TTY - refusing to prompt. Pass --yes to publish non-interactively.'));
-                    return;
-                }
-                proceed = await confirm('Publish these packages?');
-            }
-            if (!proceed)
-                return;
-            const appliedNpm = targets.has('npm')
-                ? await PublishService.applyPlan(repository, npmPlan, {
-                    ...npmOptions,
-                    packageManager: args.packageManager,
-                    access: args.access,
-                    tag: args.tag,
-                    otp: args.otp,
-                    contents: args.contents,
-                })
-                : [];
-            const appliedDocker = targets.has('docker') ? await DockerPublishService.applyPlan(repository, dockerPlan) : [];
-            let failed = false;
-            for (const entry of appliedNpm) {
-                if (entry.status === 'publish') {
-                    console.log(colors.green('published'), colors.cyan(entry.package.name), entry.version);
-                }
-                else if (entry.status === 'error' && npmPlan.find(e => e.package === entry.package)?.status === 'publish') {
-                    failed = true;
-                    console.log(colors.red('failed'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
-                }
-            }
-            for (const entry of appliedDocker) {
-                if (entry.status === 'publish') {
-                    console.log(colors.green('published'), colors.gray('[docker]'), colors.cyan(entry.package.name), entry.image);
-                }
-                else if (entry.status === 'error' &&
-                    dockerPlan.find(e => e.package === entry.package)?.status === 'publish') {
-                    failed = true;
-                    console.log(colors.red('failed'), colors.gray('[docker]'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
-                }
-            }
-            if (failed) {
-                const err = new Error('"publish" failed');
-                err.logged = true;
-                throw err;
-            }
-        },
-    });
-}
-function resolveTargets(input) {
-    if (!input?.length)
-        return new Set(['npm', 'docker']);
-    return new Set(input);
-}
-/** One `--json` row. `target` is what distinguishes otherwise-identical rows for a package that
- *  ships to several targets at once, so a consumer can tell which one still needs publishing. */
-function jsonEntry(entry, target) {
-    return {
-        name: entry.package.name,
-        target,
-        status: entry.status,
-        version: entry.version,
-        reason: entry.reason,
-    };
-}
-function printPlan(entries, label) {
-    const prefix = label ? colors.gray(`[${label}] `) : '';
-    for (const e of entries) {
-        const name = prefix + colors.cyan(e.package.name);
-        switch (e.status) {
-            case 'publish':
-                console.log(colors.green('publish'), name, e.version, colors.gray(e.reason ?? ''));
-                break;
-            case 'up-to-date':
-                console.log(colors.gray('up-to-date'), name, e.version);
-                break;
-            case 'skip':
-                console.log(colors.cyan('skip'), name, colors.gray(e.reason ?? ''));
-                break;
-            case 'error':
-                console.log(colors.red('error'), name, colors.red(e.reason ?? ''));
-                break;
-        }
-    }
-}
-async function confirm(question) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = await rl.question(`${question} (y/N) `);
-        return /^y(es)?$/i.test(answer.trim());
-    }
-    finally {
-        rl.close();
-    }
-}
-const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];