rman 2.15.0 → 2.15.2

package/commands/deps.command.js

@@ -200,9 +200,13 @@ function jsonPlan(entries) {
 function printPlan(entries, root) {
     const updated = entries.filter(e => e.status === 'update');
     const behind = entries.filter(e => e.status === 'held' || e.status === 'skipped' || e.status === 'error' || (e.status === 'update' && e.reason));
-    if (!updated.length && !behind.length) {
-        console.log(colors.gray('Every dependency is up to date.'));
-        return;
+    /** Said first when nothing moves, so a run whose only lines are majors left behind does not read
+     *  as a list of things to do. */
+    if (!updated.length) {
+        console.log(colors.green('All dependencies are up to date') +
+            (behind.length ? colors.gray(' - newer versions their settings leave out, or another rule holds back:') : '.'));
+        if (!behind.length)
+            return;
     }
     const shown = [...updated, ...behind];
     const nameWidth = Math.max(...shown.map(e => e.name.length));

package/commands/version.command.js

@@ -286,7 +286,8 @@ function printApplied(result) {
             console.log(`${colors.green('tags')}    ${release.map(label).join(', ')} ${colors.gray('(repository release)')}`);
     }
     console.log(result.pushed
-        ? `${colors.green('push')}    pushed, with tags`
+        ? `${colors.green('push')}    pushed the branch` +
+            (result.tags.length ? ` and ${result.tags.map(t => t.name).join(', ')}, together` : '')
         : `${colors.gray('push')}    ${colors.gray('not pushed - run with --push, or push it yourself')}`);
 }
 function printPlan(entries) {

package/constants.js

@@ -1 +1 @@
-export const version = '2.15.0';
+export const version = '2.15.2';

package/package.json

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

package/services/version.service.js

@@ -254,8 +254,21 @@ export class VersionService extends Service {
             tagged.push({ name: releaseTag, created: true, release: true });
         }
         const pushed = !!options.push && bumped.length > 0;
-        if (pushed)
-            await git.push();
+        if (pushed) {
+            /** Every tag this release names, including one that was already there: it is this release's
+             *  tag all the same, and a remote that lacks it is missing part of the release. */
+            const tags = tagged.map(t => t.name);
+            try {
+                await git.push({ tags });
+            }
+            catch (e) {
+                throw new Error(`${e.message}\n\n` +
+                    `  Nothing was pushed - the branch and its tags go up together or not at all. Left behind ` +
+                    `locally: ${commits.map(c => c.sha).join(', ') || 'no commit'}` +
+                    (tags.length ? `, tagged ${tags.join(', ')}` : '') +
+                    `.\n  Once the cause is fixed, push them with: git push --atomic origin HEAD ${tags.join(' ')}`.trimEnd(), { cause: e });
+            }
+        }
         return { entries: plan, updated: bumped, commits, tags: tagged, pushed };
     }
 }

package/utils/git.d.ts

@@ -121,11 +121,13 @@ export declare class GitHelper {
      *  Throws if a tag with that name already exists - callers wanting idempotent tagging should
      *  check `tagExists` first. */
     createTag(name: string, message?: string): Promise<void>;
-    /** Pushes the current branch to `remote` (default `"origin"`), and its tags too unless
-     *  `options.tags` is `false`. */
+    /**
+     * Pushes the current branch to `remote` (default `"origin"`) together with `options.tags`, by
+     * name, in **one atomic push**: the branch and every tag go up, or none of them does.
+     */
     push(options?: {
         remote?: string;
-        tags?: boolean;
+        tags?: readonly string[];
     }): Promise<void>;
     /** `git remote get-url <remote>` (default `"origin"`) - `undefined` when that remote isn't
      *  configured at all, which is a perfectly normal state for a local-only repository. */

package/utils/git.js

@@ -394,14 +394,24 @@ export class GitHelper {
             throw new Error(`Unable to create tag "${name}": ${e.message}`, { cause: e });
         }
     }
-    /** Pushes the current branch to `remote` (default `"origin"`), and its tags too unless
-     *  `options.tags` is `false`. */
+    /**
+     * Pushes the current branch to `remote` (default `"origin"`) together with `options.tags`, by
+     * name, in **one atomic push**: the branch and every tag go up, or none of them does.
+     */
+    /* **Named tags, not `--tags`.** `git push <remote> --tags` sends every tag in the clone, so one
+     * stale tag from months ago - re-created locally, diverged from the remote's - failed every
+     * release from then on, and failed it *after* the new tag had already gone up. Measured on
+     * `postgrejs` with 2.15.0: `v3.13.0` pushed, `v3.10.0` rejected, exit 1, and in CI the publish
+     * step after it never ran.
+     *
+     * **One command, `--atomic`.** The branch used to go first and the tags second, so a failure in
+     * the second - GitHub's own `fatal error in commit_refs` did it to the same repository an hour
+     * earlier - left a pushed version bump with no tag, which a re-run cannot repair because it has
+     * nothing left to bump. Atomic, a failure leaves the remote exactly as it was. */
     async push(options) {
         const remote = options?.remote ?? 'origin';
         try {
-            await execFileAsync('git', ['push', remote], { cwd: this.cwd });
-            if (options?.tags !== false)
-                await execFileAsync('git', ['push', remote, '--tags'], { cwd: this.cwd });
+            await execFileAsync('git', ['push', '--atomic', remote, 'HEAD', ...(options?.tags ?? [])], { cwd: this.cwd });
         }
         catch (e) {
             throw new Error(`Unable to push to "${remote}": ${e.message}`, { cause: e });

package/utils/status-region.d.ts

@@ -33,6 +33,12 @@ export declare class StatusRegion implements TerminalRegion {
      * there, so `runBin` keeps asking one object (`app.statusRegion`) whatever is actually drawing.
      */
     private takeover?;
+    /** Puts back the stream writes `guardWrites` replaced. */
+    private restoreWrites?;
+    /** Set while this region is writing its own frame, so the guard lets it through untouched. */
+    private drawing;
+    /** The last write from outside ended mid-line, so no frame is drawn until the line is finished. */
+    private partial;
     constructor(label: string, detail?: string, enabled?: boolean);
     /** Whether the spinner is actually drawn. `false` leaves `passThrough` a plain write and `stop`
      *  its single line, which is what a non-TTY wants. */
@@ -69,6 +75,14 @@ export declare class StatusRegion implements TerminalRegion {
     passThrough(text: string): void;
     /** Erases the spinner and leaves one line saying how it went. */
     stop(outcome: 'ok' | 'fail'): void;
+    /**
+     * Moves every write to stdout and stderr above the spinner: erase it, write, draw it again below.
+     * Undone by `stop`.
+     */
+    private guardWrites;
+    /** Runs `write` as one of this region's own writes, so the guard passes it through. */
+    private own;
+    private clear;
     private draw;
     /** `0.4s` while running and `950ms` / `4.1s` / `2m 03s` at the end - one formatter, because a
      *  duration that changes shape as it ticks reads as a glitch. */

package/utils/status-region.js

@@ -12,6 +12,12 @@ export class StatusRegion {
      * there, so `runBin` keeps asking one object (`app.statusRegion`) whatever is actually drawing.
      */
     takeover;
+    /** Puts back the stream writes `guardWrites` replaced. */
+    restoreWrites;
+    /** Set while this region is writing its own frame, so the guard lets it through untouched. */
+    drawing = false;
+    /** The last write from outside ended mid-line, so no frame is drawn until the line is finished. */
+    partial = false;
     constructor(label, detail = '', enabled) {
         this.label = label;
         this.detail = detail;
@@ -26,6 +32,7 @@ export class StatusRegion {
     start() {
         if (!this.region.enabled)
             return;
+        this.guardWrites();
         this.draw();
         /** **`unref`, so a spinner never holds the process open.** A command that finishes its work and
          *  leaves nothing else pending would otherwise wait out the interval before exiting. */
@@ -55,7 +62,7 @@ export class StatusRegion {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = undefined;
-        this.region.clear();
+        this.clear();
     }
     /**
      * Takes the terminal back - a no-op when it was never suspended.
@@ -88,8 +95,8 @@ export class StatusRegion {
             process.stderr.write(text);
             return;
         }
-        this.region.clear();
-        process.stderr.write(text);
+        this.clear();
+        this.own(() => process.stderr.write(text));
         this.draw();
     }
     /** Erases the spinner and leaves one line saying how it went. */
@@ -98,11 +105,62 @@ export class StatusRegion {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = undefined;
-        this.region.clear();
+        this.clear();
+        this.restoreWrites?.();
+        this.restoreWrites = undefined;
         const mark = outcome === 'ok' ? colors.green('✔') : colors.red('✖');
-        process.stderr.write(`${mark} ${colors.bold(this.label)} ${colors.gray(this.elapsed())}\n`);
+        const lead = this.partial ? '\n' : '';
+        process.stderr.write(`${lead}${mark} ${colors.bold(this.label)} ${colors.gray(this.elapsed())}\n`);
+    }
+    /**
+     * Moves every write to stdout and stderr above the spinner: erase it, write, draw it again below.
+     * Undone by `stop`.
+     */
+    /* **Here, once, rather than in every command.** Measured with a pseudo-terminal: `rman deps`
+     * printed its plan with `console.log`, the spinner's next erase moved up one row from *below* the
+     * plan, and the plan's last line - the one dependency it was reporting - was gone from the screen,
+     * leaving a "not updated" heading with nothing under it. `version --show` lost its closing
+     * "Nothing to version." the same way. Asking each command to route its output through
+     * `passThrough` is a rule every new command would have to remember; a command's own `console.log`
+     * is the ordinary thing to write.
+     *
+     * **Left alone while suspended**: the region that took over draws to stdout itself, and it owns the
+     * terminal until `resume`. **A write ending mid-line holds the next frame back** (`partial`), or the
+     * frame's `\r` + erase would wipe the half-written line. */
+    guardWrites() {
+        const streams = [process.stdout, process.stderr];
+        const originals = streams.map(stream => stream.write);
+        streams.forEach((stream, i) => {
+            const original = originals[i];
+            stream.write = ((chunk, ...rest) => {
+                if (this.drawing || this.takeover)
+                    return original.call(stream, chunk, ...rest);
+                this.clear();
+                const written = this.own(() => original.call(stream, chunk, ...rest));
+                this.partial = !String(chunk).endsWith('\n');
+                this.draw();
+                return written;
+            });
+        });
+        this.restoreWrites = () => streams.forEach((stream, i) => (stream.write = originals[i]));
+    }
+    /** Runs `write` as one of this region's own writes, so the guard passes it through. */
+    own(write) {
+        const was = this.drawing;
+        this.drawing = true;
+        try {
+            return write();
+        }
+        finally {
+            this.drawing = was;
+        }
+    }
+    clear() {
+        this.own(() => this.region.clear());
     }
     draw() {
+        if (this.partial)
+            return;
         const spinner = colors.cyan(FRAMES[this.frame % FRAMES.length]);
         const parts = [
             spinner,
@@ -110,7 +168,7 @@ export class StatusRegion {
             this.detail && colors.gray(this.detail),
             colors.gray(this.elapsed()),
         ];
-        this.region.render([parts.filter(Boolean).join(' ')]);
+        this.own(() => this.region.render([parts.filter(Boolean).join(' ')]));
     }
     /** `0.4s` while running and `950ms` / `4.1s` / `2m 03s` at the end - one formatter, because a
      *  duration that changes shape as it ticks reads as a glitch. */