rman 2.20.0 → 2.21.1

package/builtins/platforms/node/services/clean.service.js

@@ -119,7 +119,9 @@ async function remove(file, dryRun) {
 function pruneEmptyDirs(dir, includeSelf, dryRun) {
     if (dryRun || !fs.existsSync(dir))
         return;
-    const entries = fg.sync('**', { cwd: dir, onlyDirectories: true, dot: true });
+    /** Not through a link: a link to a directory is not a directory of this one to prune - removing
+     *  it as one is `ENOTDIR`, and walking into it reaches somewhere else entirely. */
+    const entries = fg.sync('**', { cwd: dir, onlyDirectories: true, dot: true, followSymbolicLinks: false });
     entries.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
     for (const rel of entries) {
         const abs = path.join(dir, rel);
@@ -140,23 +142,48 @@ function pruneEmptyDirs(dir, includeSelf, dryRun) {
  * matching files *inside* an otherwise-deleted directory, leaving the rest of it gone and the
  * protected files (and their now non-empty parent) in place.
  */
+/* **A symbolic link is removed as a link, and never followed.** A build directory routinely holds
+ * one - `build/node_modules/@scope/sibling` pointing at another package's own build - and walking
+ * through it deleted *that* package's output, then failed `rmdir` on the link with `ENOTDIR`.
+ * Measured on `panates/syncbridge`: cleaning `syncbuild` emptied `common/build`, and the run
+ * reported only `0 succeeded, 1 failed`. fast-glob follows links by default, so every glob here
+ * says `followSymbolicLinks: false`. */
 async function cleanGlobs(dirname, include, exclude, dryRun) {
     if (!include.length)
         return [];
-    const matches = await fg(include, { cwd: dirname, ignore: exclude, onlyFiles: false, dot: true, absolute: true });
+    const matches = await fg(include, {
+        cwd: dirname,
+        ignore: exclude,
+        onlyFiles: false,
+        dot: true,
+        absolute: true,
+        followSymbolicLinks: false,
+    });
     const protectedFiles = exclude.length
-        ? new Set(await fg(exclude, { cwd: dirname, onlyFiles: true, dot: true, absolute: true }))
+        ? new Set(await fg(exclude, { cwd: dirname, onlyFiles: true, dot: true, absolute: true, followSymbolicLinks: false }))
         : new Set();
     const removed = [];
     for (const m of matches) {
-        const stat = await fs.promises.stat(m).catch(() => undefined);
+        /** `lstat`, not `stat`: a link is removed as the link it is, and never read as the thing it
+         *  points at. */
+        const stat = await fs.promises.lstat(m).catch(() => undefined);
         if (!stat)
             continue;
         if (stat.isDirectory()) {
-            const filesInside = await fg('**', { cwd: m, onlyFiles: true, dot: true, absolute: true });
-            for (const f of filesInside) {
+            /** Files *and* links inside, and a link never entered - see `cleanGlobs`' own note. */
+            const inside = await fg('**', {
+                cwd: m,
+                onlyFiles: false,
+                dot: true,
+                absolute: true,
+                followSymbolicLinks: false,
+            });
+            for (const f of inside) {
                 if (protectedFiles.has(f))
                     continue;
+                const entry = await fs.promises.lstat(f).catch(() => undefined);
+                if (!entry || entry.isDirectory())
+                    continue;
                 await remove(f, dryRun);
                 removed.push(path.relative(dirname, f));
             }
@@ -208,6 +235,8 @@ async function cleanTsArtifacts(pkg, dryRun) {
         onlyFiles: true,
         dot: true,
         absolute: true,
+        /** A link to a directory elsewhere is not this package's source to sweep. */
+        followSymbolicLinks: false,
     });
     const removed = [];
     for (const f of files) {
@@ -277,6 +306,7 @@ async function cleanTsBuildInfo(dirname, dryRun) {
         onlyFiles: true,
         dot: true,
         absolute: true,
+        followSymbolicLinks: false,
     });
     for (const f of files)
         await remove(f, dryRun);
@@ -310,7 +340,12 @@ async function cleanPackage(pkg, item, panelEnabled, dryRun, logger) {
     }
     catch (e) {
         item.status = 'failed';
-        item.log.push(e?.message ?? String(e));
+        const message = e?.message ?? String(e);
+        item.log.push(message);
+        /** The panel replays `log` in its recap; with no panel nothing does, and the run said only
+         *  `0 succeeded, 1 failed` - which is how the link bug above went unexplained. */
+        if (!panelEnabled)
+            logger.error(colors.red('clean'), colors.cyan(item.name), message);
         throw e;
     }
     finally {

package/cli.js

@@ -99,6 +99,12 @@ export async function runCli(options) {
                         ? err.message
                         : '';
                 console.log('\n' + colors.red(text));
+                /** The handler's own error is marked too, because it is the one that comes back: yargs
+                 *  rejects `parseAsync` with what the handler threw, not with what this throws, so
+                 *  `runCli`'s catch saw it unmarked and printed the same line again on stderr - every
+                 *  failing command said its reason twice. */
+                if (err && typeof err === 'object')
+                    err.logged = true;
                 /** A real `Error`, marked `logged` since the text above just went out: yargs hands the
                  *  reason over as a bare string, and rethrowing that raw made bad argv indistinguishable
                  *  from success to anything holding the promise - or the shell. */

package/constants.js

@@ -1 +1 @@
-export const version = '2.20.0';
+export const version = '2.21.1';

package/core/classes/progress-panel.d.ts

@@ -24,6 +24,20 @@ export interface ProgressItem {
     finishedAt?: number;
     /** Captured output, printed back out if the item ends up failing. */
     log: string[];
+    /**
+     * The same output split by the step that printed it, when the driver reports steps (`run`'s
+     * scheduler does). A failed item's recap then names the steps that passed in a line each and
+     * prints the output of the one that failed; without it, `log` is printed whole.
+     */
+    steps?: StepLog[];
+}
+/** One step of an item, as the recap shows it - see `ProgressItem.steps`. */
+export interface StepLog {
+    /** `before: rman check` - the slot and what ran in it. */
+    label: string;
+    /** Unset while it runs, and for a step that never got to end. */
+    status?: 'success' | 'failed';
+    lines: string[];
 }
 export interface ProgressSummary {
     successCount: number;
@@ -81,6 +95,11 @@ export declare class ProgressPanel implements TerminalRegion {
      *  `TerminalRegion` half of the takeover, so a `runBin` child's output goes somewhere sane while
      *  a panel is up. */
     passThrough(text: string): void;
+    /**
+     * A failed item's steps: one line for each that passed, and the one that failed - or never got to
+     * end - with its whole output under it.
+     */
+    protected stepRecap(steps: readonly StepLog[]): string;
     /** Every line of a replayed log moved two columns right - an empty line left empty. */
     protected indentLog(text: string): string;
     private render;

package/core/classes/progress-panel.js

@@ -79,6 +79,28 @@ export class ProgressPanel {
         process.stdout.write(text);
         this.render();
     }
+    /**
+     * A failed item's steps: one line for each that passed, and the one that failed - or never got to
+     * end - with its whole output under it.
+     */
+    /* **Only the failing step's output, and the user's call.** The whole log used to be replayed, on
+     * the reasoning that an earlier step's output can explain a later failure. In a real build that
+     * put `rman check`'s file count and its own recap above every lint error, four lines of success
+     * the reader had to skip to reach the one that mattered. The passing steps keep a line each, so
+     * the order is still there; `--log-file` keeps every line. */
+    stepRecap(steps) {
+        const out = [];
+        for (const step of steps) {
+            if (step.status === 'success') {
+                out.push(`${colors.green('✔')} ${colors.gray(step.label)}`);
+                continue;
+            }
+            out.push(`${colors.red('✖')} ${step.label}`);
+            if (step.lines.length)
+                out.push(this.indentLog(step.lines.join('\n')));
+        }
+        return out.join('\n');
+    }
     /** Every line of a replayed log moved two columns right - an empty line left empty. */
     indentLog(text) {
         return text
@@ -284,7 +306,9 @@ export class ProgressPanel {
                      *
                      * **Indented two columns**, so the log reads as belonging to the `X` line above it - level
                      * with the recap's own lines it ran together with them, a nested rman's recap most of all. */
-                    if (item.log.length)
+                    if (item.steps?.length)
+                        console.log(this.indentLog(this.stepRecap(item.steps)));
+                    else if (item.log.length)
                         console.log(this.indentLog(item.log.join('\n')));
                 }
             }
@@ -349,6 +373,7 @@ class PanelItem {
     startedAt;
     finishedAt;
     log = [];
+    steps = [];
     _currentStep;
     _currentCommand;
     constructor(name, stepsTotal) {

package/core/classes/run-reporters.d.ts

@@ -54,11 +54,16 @@ export declare class PanelReporter extends PlainReporter {
      *  would only be escape codes counted as text there. */
     readonly childEnv: undefined;
     constructor(commandName: string, panel: ProgressPanel);
-    /** The row names the step itself; there is no separate line to print. */
-    protected started(): void;
+    /** The row names the step itself; there is no separate line to print - but the recap needs to
+     *  know which lines were whose, so a step is opened here. */
+    protected started(event: Extract<LogEvent, {
+        event: 'start';
+    }>, origin: ReportOrigin): void;
     protected output(event: Extract<LogEvent, {
         event: 'output';
     }>, origin: ReportOrigin): void;
-    /** The row shows the step's outcome; the recap prints the package's. */
-    protected ended(): void;
+    /** The row shows the step's outcome; the recap prints the package's - and reads it from here. */
+    protected ended(event: Extract<LogEvent, {
+        event: 'end';
+    }>, origin: ReportOrigin): void;
 }

package/core/classes/run-reporters.js

@@ -124,12 +124,20 @@ export class PanelReporter extends PlainReporter {
     constructor(commandName, panel) {
         super(commandName, panel);
     }
-    /** The row names the step itself; there is no separate line to print. */
-    started() { }
+    /** The row names the step itself; there is no separate line to print - but the recap needs to
+     *  know which lines were whose, so a step is opened here. */
+    started(event, origin) {
+        origin.item.steps?.push({ label: event.command ? `${event.step}: ${event.command}` : event.step, lines: [] });
+    }
     output(event, origin) {
         origin.item.log.push(event.line);
+        origin.item.steps?.at(-1)?.lines.push(event.line);
         origin.item.lastLine = event.line;
     }
-    /** The row shows the step's outcome; the recap prints the package's. */
-    ended() { }
+    /** The row shows the step's outcome; the recap prints the package's - and reads it from here. */
+    ended(event, origin) {
+        const step = origin.item.steps?.at(-1);
+        if (step)
+            step.status = event.status;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.20.0",
+  "version": "2.21.1",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {