rman 2.20.0 → 2.21.0

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.0';

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.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {