@coderook/cli 0.10.1 → 0.11.1

package/dist/cli/src/cli.js

@@ -22,6 +22,7 @@ const node_process_1 = __importDefault(require("node:process"));
 const api_js_1 = require("./api.js");
 const registry_js_1 = require("./registry.js");
 const help_js_1 = require("./help.js");
+const progress_js_1 = require("./progress.js");
 const project_commands_js_1 = require("./project_commands.js");
 const service_commands_js_1 = require("./service_commands.js");
 const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
@@ -74,11 +75,19 @@ function progressLine() {
     return (text) => {
         if (!node_process_1.default.stdout.isTTY)
             return;
-        const padded = text.padEnd(last);
-        last = text.length;
+        /*
+          Measured without the colour codes. Padding to the raw length of a string
+          carrying escape sequences overshoots by however many invisible
+          characters it holds, which drags the cursor past the end of the line.
+        */
+        const visible = text.replace(/\[[0-9;]*m/g, "").length;
+        const padded = text + " ".repeat(Math.max(0, last - visible));
+        last = visible;
         node_process_1.default.stdout.write(`\r${padded}`);
     };
 }
+/** The shared bar, drawn from a percentage and this session's colour setting. */
+const track = (percent) => (0, progress_js_1.bar)(percent / 100, 18, dim);
 const done = (line) => {
     if (node_process_1.default.stdout.isTTY) {
         line("");
@@ -383,8 +392,9 @@ async function commandSubmit(parsed) {
             */
             ...(link ? { known: link.local ?? link.manifest ?? {} } : {}),
         }, (progress) => {
-            line(`  ${String(progress.percent).padStart(3)}%  ${progress.stage.padEnd(7)} ` +
-                `${progress.files}/${progress.totalFiles}  ${progress.path.slice(-48)}`);
+            line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+                `${progress.stage.padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
+                dim(progress.path.slice(-40)));
         });
     }
     catch (error) {
@@ -660,8 +670,9 @@ held, mode = "replace") {
     }
     const line = progressLine();
     const result = await downloader.run(repositoryId, latest.id, destination, (progress) => {
-        line(`  ${String(progress.percent).padStart(3)}%  ${progress.files}/${progress.totalFiles}` +
-            `  ${progress.path.slice(-48)}`);
+        line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+            `${progress.files}/${progress.totalFiles}  ` +
+            dim(progress.path.slice(-40)));
     }, 
     // What this folder received last time, so a file the project has since
     // dropped is removed while everything untracked is left alone.
@@ -710,7 +721,8 @@ async function commandBundle(parsed) {
     const entries = (await (0, worktree_js_1.changedFiles)(folder, rules, null)).map((file) => file.path);
     const line = progressLine();
     const result = await (0, cbx_js_1.packBundle)({ root: folder, target, entries, sourceName: node_path_1.default.basename(folder) }, (progress) => {
-        line(`  ${String(progress.percent).padStart(3)}%  ${progress.path.slice(-48)}`);
+        line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+            dim(progress.path.slice(-40)));
     });
     done(line);
     const saved = Math.max(0, 100 - Math.ceil((result.archiveBytes / Math.max(result.sourceBytes, 1)) * 100));
@@ -728,7 +740,8 @@ async function commandUnbundle(parsed) {
     const destination = node_path_1.default.resolve(parsed.positional[1] ?? manifest.source_name);
     const line = progressLine();
     const result = await (0, cbx_js_1.unpackBundle)(node_path_1.default.resolve(source), destination, (progress) => {
-        line(`  ${String(progress.percent).padStart(3)}%  ${progress.path.slice(-48)}`);
+        line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+            dim(progress.path.slice(-40)));
     });
     done(line);
     console.log(`${result.files} files · ${bytes(result.bytes)} into ${destination}`);
@@ -1222,8 +1235,10 @@ const SPECS = [
     {
         name: "merges",
         group: "When somebody saved first",
-        summary: "uploads of yours waiting on a decision",
-        usage: "merges",
+        summary: "this folder's uploads waiting on a decision",
+        usage: "merges [folder]",
+        detail: "Both merge commands read the project this folder is linked to, so run\n" +
+            "them from a working copy — or name one.",
         run: commandMerges,
     },
     {

package/dist/cli/src/progress.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Showing a run as it happens.
+ *
+ * The runner used to print the name of a job, fall silent for however long the
+ * work took, and then print the result. For a five-second echo that is merely
+ * odd; for a ten-minute build it means watching a blank terminal with no way
+ * to tell compiling from hung from waiting on a prompt that will never be
+ * answered. Every byte of output was being captured and shipped to the
+ * service, and none of it shown to the person sitting in front of it.
+ *
+ * Two things fix that, and they are different problems.
+ *
+ * The fetch has a known total — the version says how many files it holds — so
+ * that gets a real bar with a real percentage. The command does not: nothing
+ * knows how long `npm run build` takes, and a bar that invents a percentage is
+ * worse than no bar, because people plan around it. That phase gets a spinner,
+ * an elapsed clock, and the command's own output as it arrives, which is the
+ * honest answer to "what is it doing".
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunProgress = void 0;
+exports.bar = bar;
+const node_process_1 = __importDefault(require("node:process"));
+/** Braille frames: dense, monospaced, and they animate in one column. */
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const dim = (value) => `${value}`;
+const accent = (value) => `${value}`;
+/**
+ * Whether to animate at all.
+ *
+ * A spinner written to a file or a CI log is thousands of lines of escape
+ * codes nobody can read. When there is no terminal, phases are announced once
+ * as plain lines and nothing rewrites itself.
+ */
+const live = Boolean(node_process_1.default.stdout.isTTY) && !node_process_1.default.env.NO_COLOR;
+function clock(from) {
+    const seconds = Math.floor((Date.now() - from) / 1000);
+    const minutes = Math.floor(seconds / 60);
+    return minutes
+        ? `${minutes}:${String(seconds % 60).padStart(2, "0")}`
+        : `${seconds}s`;
+}
+/**
+ * A bar drawn from block characters, for a phase that knows its own size.
+ *
+ * Shared with push, pull and get, which had a percentage and no bar. `fade` is
+ * a parameter because the commands honour NO_COLOR through their own helper,
+ * and a track drawn with escape codes somebody asked not to receive is worse
+ * than an undimmed one.
+ */
+function bar(fraction, width = 18, fade = dim) {
+    const safe = Number.isFinite(fraction) ? fraction : 0;
+    /*
+      Floored, so the bar fills only when the work is actually done. Rounding
+      drew a solid bar from 97% onwards, which is the same lie the percentage
+      used to tell — just harder to argue with.
+    */
+    const filled = Math.max(0, Math.min(width, Math.floor(safe * width)));
+    return `${"█".repeat(filled)}${fade("░".repeat(width - filled))}`;
+}
+class RunProgress {
+    frame = 0;
+    timer;
+    phase = "";
+    detail = "";
+    fraction = null;
+    started = Date.now();
+    painted = false;
+    /**
+     * Move to a new phase.
+     *
+     * `fraction` is only passed where something real is being counted. Left out,
+     * the line shows a spinner and an elapsed time instead of a made-up number.
+     */
+    step(phase, detail = "", fraction = null) {
+        const previous = this.phase;
+        this.phase = phase;
+        this.detail = detail;
+        this.fraction = fraction;
+        if (!live) {
+            /*
+              Without a terminal each phase is announced once, rather than repeating
+              the same line every time a file lands.
+            */
+            if (phase !== previous)
+                console.log(`  ${phase}${detail ? `: ${detail}` : ""}`);
+            return;
+        }
+        this.paint();
+        if (!this.timer) {
+            this.timer = setInterval(() => {
+                this.frame = (this.frame + 1) % FRAMES.length;
+                this.paint();
+            }, 90);
+            this.timer.unref?.();
+        }
+    }
+    /**
+     * Update the counted part of the current phase without changing it.
+     *
+     * Records the numbers and leaves the drawing to the spinner's own timer. A
+     * version with thirty thousand files calls this thirty thousand times, and
+     * repainting on each one is thirty thousand writes to render eleven frames
+     * a person can actually read — the download ends up waiting on the
+     * terminal.
+     */
+    advance(detail, fraction = null) {
+        this.detail = detail;
+        this.fraction = fraction;
+    }
+    /**
+     * Output the command itself printed.
+     *
+     * Cleared out of the way first so the text and the status line do not fight
+     * over the same row, then the status line is drawn again underneath — which
+     * keeps the newest output directly above where the progress is. A whole
+     * chunk at a time, because a build that prints a hundred lines in one breath
+     * should cost one repaint rather than a hundred.
+     */
+    say(chunk) {
+        const lines = chunk.split(/\r?\n/).filter((line) => line.trim() !== "");
+        if (!lines.length)
+            return;
+        if (!live) {
+            for (const line of lines)
+                console.log(`    ${line.replace(/\s+$/, "")}`);
+            return;
+        }
+        this.clear();
+        for (const line of lines)
+            console.log(`    ${dim(line.replace(/\s+$/, ""))}`);
+        this.paint();
+    }
+    /**
+     * Stop, and take the status line with it.
+     *
+     * Deliberately silent. The runner already prints the verdict — which is the
+     * line somebody scrolls back to — and a progress display that also announced
+     * the result would say the same thing twice, differently.
+     */
+    done() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.clear();
+    }
+    clear() {
+        if (!live || !this.painted)
+            return;
+        node_process_1.default.stdout.write("\r");
+        this.painted = false;
+    }
+    paint() {
+        if (!live)
+            return;
+        const spinner = accent(FRAMES[this.frame] ?? "⠋");
+        const measured = this.fraction === null
+            ? ""
+            : /*
+                 Floored to agree with the bar. Rounding printed 100% beside a bar
+                 with a block still to fill, and two readings of the same number
+                 disagreeing is worse than either of them being pessimistic.
+               */
+                `${bar(this.fraction)} ${String(Math.floor(this.fraction * 100)).padStart(3)}%  `;
+        const line = `${spinner} ${this.phase}  ${measured}${dim(this.detail)}  ${dim(clock(this.started))}`;
+        /*
+          Truncated to the terminal so a long file path does not wrap and leave
+          half a status line stranded above the next repaint.
+        */
+        const width = node_process_1.default.stdout.columns ?? 80;
+        node_process_1.default.stdout.write(`\r${line.slice(0, width + 40)}`);
+        this.painted = true;
+    }
+}
+exports.RunProgress = RunProgress;

package/dist/cli/src/runner.js

@@ -37,6 +37,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const download_js_1 = require("../../desktop-app/src/main/download.js");
 const identify_js_1 = require("../../desktop-app/src/main/identify.js");
 const config_js_1 = require("./config.js");
+const progress_js_1 = require("./progress.js");
 /** How often to tell the service the machine is still working. */
 const HEARTBEAT_MS = 30_000;
 /** How often log lines are sent up while a command is running. */
@@ -73,12 +74,19 @@ async function call(route, options = {}) {
 class LogShipper {
     repositoryId;
     runId;
+    say;
     pending = [];
     sent = 0;
     failed = false;
-    constructor(repositoryId, runId) {
+    constructor(repositoryId, runId, 
+    /*
+      Said through the progress display rather than straight to the console:
+      a line written while the status line is on screen lands on top of it.
+    */
+    say = console.error) {
         this.repositoryId = repositoryId;
         this.runId = runId;
+        this.say = say;
     }
     add(chunk, stream) {
         for (const line of chunk.split(/\r?\n/)) {
@@ -110,7 +118,7 @@ class LogShipper {
               that cannot deliver says so once and stops trying.
             */
             this.failed = true;
-            console.error(`  (log upload stopped: ${errorText(error)})`);
+            this.say(`  (log upload stopped: ${errorText(error)})`);
         }
     }
 }
@@ -317,7 +325,8 @@ function patternMatcher(pattern) {
  * directory would let one job's leftovers decide the next job's result.
  */
 async function performRun(repositoryId, run, runner) {
-    const logs = new LogShipper(repositoryId, run.runId);
+    const progress = new progress_js_1.RunProgress();
+    const logs = new LogShipper(repositoryId, run.runId, (line) => progress.say(line));
     const started = Date.now();
     const workspace = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "coderook-run-"));
     let beating;
@@ -338,8 +347,14 @@ async function performRun(repositoryId, run, runner) {
         }, HEARTBEAT_MS);
         if (run.versionId) {
             logs.add(`Fetching v${run.versionSequence ?? "?"}…`, "stdout");
+            /*
+              The one phase that knows its own size. The version says how many files
+              it holds, so this gets a real proportion rather than a spinner
+              pretending to measure something.
+            */
+            progress.step(`Fetching v${run.versionSequence ?? "?"}`, "", 0);
             const downloader = new download_js_1.Downloader(config_js_1.credentials);
-            const got = await downloader.run(repositoryId, run.versionId, workspace, () => { }, null, "replace");
+            const got = await downloader.run(repositoryId, run.versionId, workspace, (state) => progress.advance(`${state.files}/${state.totalFiles} files`, state.totalFiles ? state.files / state.totalFiles : null), null, "replace");
             logs.add(`Fetched ${got.files} files.`, "stdout");
         }
         else {
@@ -353,6 +368,7 @@ async function performRun(repositoryId, run, runner) {
         const directory = run.workingDirectory
             ? insideWorkspace(workspace, run.workingDirectory)
             : workspace;
+        progress.step("Running", command);
         flushing = setInterval(() => void logs.flush(), FLUSH_MS);
         const code = await new Promise((settle) => {
             /*
@@ -373,8 +389,18 @@ async function performRun(repositoryId, run, runner) {
                         : "",
                 },
             });
-            child.stdout?.on("data", (chunk) => logs.add(chunk.toString("utf8"), "stdout"));
-            child.stderr?.on("data", (chunk) => logs.add(chunk.toString("utf8"), "stderr"));
+            /*
+              Shipped and shown, not one or the other. The service needs the log so
+              a failed run can be read later; the person watching needs it so they
+              can tell a slow build from a stuck one.
+            */
+            const tee = (chunk, stream) => {
+                const text = chunk.toString("utf8");
+                logs.add(text, stream);
+                progress.say(text);
+            };
+            child.stdout?.on("data", (chunk) => tee(chunk, "stdout"));
+            child.stderr?.on("data", (chunk) => tee(chunk, "stderr"));
             child.on("error", (error) => {
                 logs.add(errorText(error), "stderr");
                 settle(1);
@@ -389,7 +415,11 @@ async function performRun(repositoryId, run, runner) {
           that away is exactly when they would have wanted it.
         */
         if (run.artifactPaths?.length) {
-            const kept = await uploadArtifacts(repositoryId, run.runId, workspace, run.artifactPaths, (line) => logs.add(line, "stdout"));
+            progress.step("Keeping what it built");
+            const kept = await uploadArtifacts(repositoryId, run.runId, workspace, run.artifactPaths, (line) => {
+                logs.add(line, "stdout");
+                progress.say(line);
+            });
             if (!kept) {
                 logs.add("Nothing matched the paths this workflow keeps.", "stdout");
             }
@@ -406,6 +436,11 @@ async function performRun(repositoryId, run, runner) {
         return { status: "failed", summary: errorText(error).slice(0, 200) };
     }
     finally {
+        /*
+          Before anything else. A spinner still repainting while the last flush
+          goes out would overwrite the verdict the caller is about to print.
+        */
+        progress.done();
         if (beating)
             clearInterval(beating);
         if (flushing)

package/dist/desktop-app/src/main/cbx.js

@@ -31,6 +31,7 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const node_zlib_1 = require("node:zlib");
+const download_js_1 = require("./download.js");
 exports.HEADER_MAGIC = "CBX1";
 exports.CHUNK_MAGIC = "CHNK";
 exports.MANIFEST_MAGIC = "MANF";
@@ -175,7 +176,7 @@ async function packBundle(request, report) {
                 bytes: sourceBytes,
                 totalBytes,
                 path: relative,
-                percent: Math.round((sourceBytes / Math.max(totalBytes, 1)) * 100),
+                percent: (0, download_js_1.underway)(sourceBytes, totalBytes),
             });
             const whole = (0, node_crypto_1.createHash)("sha256");
             const references = [];
@@ -261,6 +262,19 @@ async function packBundle(request, report) {
         await handle.close();
         await (0, promises_1.rm)(request.target, { force: true });
         await (0, promises_1.rename)(partial, request.target);
+        /*
+          The bundle is written; say so. Every other reporter here ends on a full
+          bar, and this one used to stop wherever the last file started — which
+          left a bundle that finished looking like one that gave up near the end.
+        */
+        report?.({
+            files: request.entries.length,
+            totalFiles: request.entries.length,
+            bytes: sourceBytes,
+            totalBytes,
+            path: "Done",
+            percent: 100,
+        });
         return {
             archiveBytes: offset,
             sourceBytes,
@@ -374,7 +388,7 @@ async function unpackBundle(source, destination, report) {
                 bytes,
                 totalBytes,
                 path: record.path,
-                percent: Math.round((bytes / Math.max(totalBytes, 1)) * 100),
+                percent: (0, download_js_1.underway)(bytes, totalBytes),
             });
             const parts = safeParts(record.path);
             if (!parts.length)

package/dist/desktop-app/src/main/download.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Downloader = exports.DownloadCancelled = void 0;
+exports.underway = underway;
 /**
  * Bringing a project down: the file list for a version, then its bytes.
  *
@@ -56,6 +57,20 @@ async function pruneEmpty(root, removed) {
         directory = node_path_1.default.dirname(directory);
     }
 }
+/**
+ * A percentage for work that is still going.
+ *
+ * Rounding hit 100 while files were still arriving. A project where one asset
+ * is most of the bytes — which is most projects with an asset — read "100%,
+ * 3 of 11" for the rest of the download, and the number people trust most is
+ * the one that had stopped meaning anything. Held at 99 until the caller says
+ * it is finished, and floored so it never rounds up into a lie either.
+ */
+function underway(done, total) {
+    if (total <= 0)
+        return 0;
+    return Math.min(99, Math.floor((done / total) * 100));
+}
 class DownloadCancelled extends Error {
     constructor() {
         super("Download cancelled");
@@ -172,7 +187,7 @@ class Downloader {
                     bytes,
                     totalBytes,
                     path: file.path,
-                    percent: Math.round((bytes / Math.max(totalBytes, 1)) * 100),
+                    percent: underway(bytes, totalBytes),
                 });
                 // A path that climbs out of the destination is refused outright.
                 const parts = file.path.split("/").filter(Boolean);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",