@coderook/cli 0.25.3 → 0.26.0

package/dist/cli/src/git_remote_bin.js

@@ -14,9 +14,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 */
 const node_process_1 = __importDefault(require("node:process"));
 const git_remote_js_1 = require("./git_remote.js");
+/**
+ * Finish, without cutting the pipe to git mid-sentence.
+ *
+ * `process.exit()` ends the process immediately, while stdout may still hold
+ * writes queued for git. On Windows that surfaced as
+ *
+ *   Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), src\win\async.c
+ *
+ * on the way out of a clone — libuv tearing down a handle that was still
+ * being written to. Setting the code instead lets the loop drain what is
+ * owed and end on its own, which is also the only way git reliably sees the
+ * last of the protocol.
+ *
+ * The timer is the belt: it only fires if something else is still holding
+ * the loop open, and being unreferenced it cannot be the thing holding it.
+ */
+function finish(code) {
+    node_process_1.default.exitCode = code;
+    /* stdin is already at EOF by the time main returns; this releases it. */
+    node_process_1.default.stdin.pause();
+    setTimeout(() => node_process_1.default.exit(code), 5000).unref();
+}
 (0, git_remote_js_1.main)(node_process_1.default.argv.slice(2))
-    .then((code) => node_process_1.default.exit(code))
+    .then(finish)
     .catch((error) => {
-    node_process_1.default.stderr.write(`git-remote-coderook: ${error instanceof Error ? error.message : String(error)}\n`);
-    node_process_1.default.exit(1);
+    /*
+      Said once. A refusal that has already set itself out in full does not
+      want the same paragraph printed again with a program name in front of
+      it — which is what a reader got when a push was turned down for
+      carrying a credential.
+    */
+    if (!(error instanceof git_remote_js_1.AlreadyReported)) {
+        node_process_1.default.stderr.write(`git-remote-coderook: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    finish(1);
 });

package/dist/cli/src/project_commands.js

@@ -138,8 +138,30 @@ async function commandVersions(parsed) {
         const when = version.createdAt
             ? new Date(version.createdAt).toLocaleString()
             : "";
+        /*
+          What the project has made of this version, said before the numbers.
+    
+          A name, a pin and a set of labels are how somebody finds the version
+          they meant among forty; the file count is how they check it once they
+          have. Putting the arrangement first is the difference between a log and
+          a list they organised.
+        */
+        const marks = [
+            /* Which one the project is standing on, which is not the same as which
+               one is at the top once somebody has pinned something. */
+            version.head ? green("current") : "",
+            version.pinned ? accent("pinned") : "",
+            version.name ? bold(version.name) : "",
+            version.state === "held" ? red("held") : "",
+            version.state === "declined" ? dim("declined") : "",
+            version.removedAt ? dim("taken down") : "",
+            version.visibility === "private" ? dim("private") : "",
+            version.visibility === "unlisted" ? dim("link only") : "",
+            ...version.labels.map((label) => accent(label.name)),
+        ].filter(Boolean);
         console.log(`  ${accent(`v${version.sequence}`).padEnd(16)} ${when.padEnd(22)}` +
-            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}`);
+            `${String(version.fileCount).padStart(5)} files  ${bytes(version.storedSize)}` +
+            (marks.length ? `  ${marks.join(" ")}` : ""));
         if (version.message)
             console.log(`    ${dim(version.message)}`);
     }

package/dist/cli/src/publish.js

@@ -15,6 +15,7 @@ function uploadRequestFor(input) {
         baseVersionId: input.baseVersionId,
         ...(input.track ? { track: input.track } : {}),
         ...(input.allowIgnored ? { allowIgnored: true } : {}),
+        ...(input.allowSecrets ? { allowSecrets: true } : {}),
         ...(input.acknowledged ? { acknowledged: true } : {}),
         ...(input.acknowledgedNoLicence ? { acknowledgedNoLicence: true } : {}),
         ...(input.baseVersionId
@@ -29,6 +30,14 @@ function classifyPublishFailure(error) {
     if (code === "merge_required" || code === "track_moved") {
         return { kind: "conflict", message };
     }
+    /*
+      A credential the service refused. Named separately because the answer is
+      not "try again" — it is "take the key out", and for a push there is no
+      flag to pass instead, because git has nowhere to ask the question.
+    */
+    if (code === "version_credentials") {
+        return { kind: "credentials", message };
+    }
     if (!code &&
         /fetch failed|ECONNRESET|socket hang up|network|ETIMEDOUT/i.test(message)) {
         return { kind: "interrupted", message };

package/dist/cli/src/service_commands.js

@@ -105,7 +105,8 @@ async function commandRelease(parsed) {
     const wanted = parsed.flags.get("version");
     const target = typeof wanted === "string"
         ? all.find((version) => String(version.sequence) === wanted.replace(/^v/i, ""))
-        : all[0];
+        /* The newest by number rather than by position in the list. */
+        : all.reduce((newest, one) => (one.sequence > newest.sequence ? one : newest));
     if (!target) {
         console.error(red(`This project has no version ${String(wanted)}.`));
         return 1;

package/dist/cli/src/version_commands.js

@@ -0,0 +1,493 @@
+"use strict";
+/**
+ * Arranging a project's versions from the terminal.
+ *
+ * Every one of these things could already be done — from the website, and only
+ * from the website. That is the gap this closes: naming worked here, hiding
+ * did not, and colouring and pinning existed nowhere. A person who works in a
+ * terminal should not have to open a browser to say which version matters.
+ *
+ * One command does the changing, because the service takes one patch: `cbx
+ * version 12 --name v2.1 --hide --pin` is a single request that either happened
+ * or did not, rather than three that can half-happen.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = split;
+exports.commandVersion = commandVersion;
+exports.commandLabels = commandLabels;
+exports.commandHeld = commandHeld;
+exports.commandReview = commandReview;
+exports.commandTakeDown = commandTakeDown;
+exports.commandPromote = commandPromote;
+exports.commandUndo = commandUndo;
+const api_js_1 = require("./api.js");
+const project_commands_js_1 = require("./project_commands.js");
+const promises_1 = require("node:readline/promises");
+const node_process_1 = __importDefault(require("node:process"));
+/* Written out rather than imported: the same four escapes every other command
+   file in here declares for itself, and a shared module for four one-line
+   functions would be the only thing they all depend on. */
+const dim = (value) => `${value}`;
+const bold = (value) => `${value}`;
+const red = (value) => `${value}`;
+const accent = (value) => `${value}`;
+/**
+ * Which of `[n] [project]` the arguments actually were.
+ *
+ * Both are optional and both are positional, so `cbx undo blog` has to be read
+ * as a project and `cbx undo 41` as a save — the shape of the word is the only
+ * thing that separates them. A save is digits, optionally with a leading v;
+ * anything else is a project name.
+ *
+ * That leaves a project whose whole name is digits unreachable this way. It
+ * still works as `--project 41`, and reading a bare number as a save is the
+ * one that comes up.
+ */
+function split(parsed) {
+    const named = parsed.flags.get("project") ?? parsed.flags.get("p");
+    const flagged = typeof named === "string" && named ? named : undefined;
+    const [first, second] = parsed.positional;
+    if (second !== undefined)
+        return { n: first, project: flagged ?? second };
+    if (first === undefined)
+        return { project: flagged };
+    if (flagged)
+        return { n: first, project: flagged };
+    return /^v?\d+$/i.test(first) ? { n: first } : { project: first };
+}
+/** The version somebody meant, which is usually the newest one. */
+async function pick(repositoryId, wanted) {
+    const all = await (0, api_js_1.versions)(repositoryId);
+    if (!all.length) {
+        console.error(red("This project has no versions yet."));
+        return null;
+    }
+    /*
+      The newest by number, not by position.
+  
+      The list arrives newest first today, and relying on that is how three
+      callers started reporting a pinned old save as the current one when the
+      order changed for a while. Asking for the largest number cannot be broken
+      by how the list happens to be sorted.
+    */
+    if (!wanted) {
+        return all.reduce((newest, one) => (one.sequence > newest.sequence ? one : newest));
+    }
+    const sequence = wanted.replace(/^v/i, "");
+    const found = all.find((one) => String(one.sequence) === sequence);
+    if (!found) {
+        console.error(red(`This project has no version ${wanted}.`));
+        return null;
+    }
+    return found;
+}
+const SWATCH = {
+    red: "#e0574a",
+    amber: "#e8a13f",
+    yellow: "#e8d13f",
+    green: "#5fcf8d",
+    blue: "#5aa9e6",
+    purple: "#a98ae0",
+    pink: "#e68ab8",
+    grey: "#8c968f",
+    gray: "#8c968f",
+};
+/**
+ * A colour, given either as a name or as hex.
+ *
+ * Names because nobody remembers hex, hex because somebody will want their own
+ * exact one and being told "pick from these eight" is the kind of small refusal
+ * that makes a tool feel like it is arguing.
+ */
+function colourOf(given) {
+    const value = given.trim().toLowerCase();
+    if (SWATCH[value])
+        return SWATCH[value];
+    const hex = value.startsWith("#") ? value : `#${value}`;
+    return /^#[0-9a-f]{6}$/.test(hex) ? hex : null;
+}
+function paint(label) {
+    return accent(label.name);
+}
+async function commandVersion(parsed) {
+    const which = split(parsed);
+    const project = await (0, project_commands_js_1.resolveProject)(which.project);
+    if (!project)
+        return 1;
+    const target = await pick(project.id, which.n);
+    if (!target)
+        return 1;
+    const patch = {};
+    const name = parsed.flags.get("name");
+    if (typeof name === "string")
+        patch.name = name;
+    if (parsed.flags.get("unname") === true)
+        patch.name = null;
+    const notes = parsed.flags.get("notes");
+    if (typeof notes === "string")
+        patch.notes = notes;
+    if (parsed.flags.get("hide") === true)
+        patch.visibility = "private";
+    if (parsed.flags.get("show") === true)
+        patch.visibility = "public";
+    const visibility = parsed.flags.get("visibility");
+    if (typeof visibility === "string") {
+        if (!["private", "unlisted", "public"].includes(visibility)) {
+            console.error(red("Visibility is private, unlisted or public."));
+            return 1;
+        }
+        patch.visibility = visibility;
+    }
+    if (parsed.flags.get("pin") === true)
+        patch.pinned = true;
+    if (parsed.flags.get("unpin") === true)
+        patch.pinned = false;
+    const labelNames = parsed.flags.get("labels");
+    if (typeof labelNames === "string") {
+        const known = await (0, api_js_1.projectLabels)(project.id);
+        const wanted = labelNames
+            .split(",")
+            .map((one) => one.trim())
+            .filter(Boolean);
+        const ids = [];
+        for (const one of wanted) {
+            const found = known.find((label) => label.name.toLowerCase() === one.toLowerCase());
+            if (!found) {
+                console.error(red(`This project has no "${one}" label.`) +
+                    dim(`  Make one with cbx labels add ${one} green`));
+                return 1;
+            }
+            ids.push(found.id);
+        }
+        patch.labelIds = ids;
+    }
+    if (parsed.flags.get("clear-labels") === true)
+        patch.labelIds = [];
+    if (!Object.keys(patch).length) {
+        console.error(red("Say what to change.") +
+            dim("  --name, --notes, --hide, --show, --visibility, --pin, --labels"));
+        return 1;
+    }
+    try {
+        await (0, api_js_1.changeVersion)(project.id, target.id, patch);
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    const said = [];
+    if (patch.name !== undefined) {
+        said.push(patch.name ? `named ${accent(patch.name)}` : "name removed");
+    }
+    if (patch.visibility)
+        said.push(patch.visibility);
+    if (patch.pinned !== undefined)
+        said.push(patch.pinned ? "pinned" : "unpinned");
+    if (patch.labelIds) {
+        said.push(patch.labelIds.length ? "labelled" : "labels cleared");
+    }
+    console.log(`${bold(`v${target.sequence}`)} ${said.join(", ")}.`);
+    return 0;
+}
+async function commandLabels(parsed) {
+    const action = parsed.positional[0] ?? "list";
+    if (action === "list") {
+        const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[1]);
+        if (!project)
+            return 1;
+        const labels = await (0, api_js_1.projectLabels)(project.id);
+        if (!labels.length) {
+            console.log(dim("No labels yet. Make one with cbx labels add shipped green"));
+            return 0;
+        }
+        console.log(bold(project.name));
+        for (const label of labels) {
+            console.log(`  ${paint(label).padEnd(28)} ${dim(label.colour)}` +
+                (label.description ? `  ${dim(label.description)}` : ""));
+        }
+        return 0;
+    }
+    if (action === "add") {
+        const name = parsed.positional[1];
+        const colour = parsed.positional[2] ?? "grey";
+        if (!name) {
+            console.error(red("Name the label: cbx labels add shipped green"));
+            return 1;
+        }
+        const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[3]);
+        if (!project)
+            return 1;
+        const hex = colourOf(colour);
+        if (!hex) {
+            console.error(red(`"${colour}" is not a colour.`) +
+                dim(`  Try one of ${Object.keys(SWATCH).slice(0, 8).join(", ")}, or #rrggbb`));
+            return 1;
+        }
+        try {
+            const made = await (0, api_js_1.createProjectLabel)(project.id, name, hex);
+            console.log(`Added ${paint(made)} ${dim(made.colour)}.`);
+        }
+        catch (error) {
+            console.error(red(error instanceof Error ? error.message : String(error)));
+            return 1;
+        }
+        return 0;
+    }
+    if (action === "remove" || action === "rm") {
+        const name = parsed.positional[1];
+        if (!name) {
+            console.error(red("Name the label to remove: cbx labels remove shipped"));
+            return 1;
+        }
+        const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[2]);
+        if (!project)
+            return 1;
+        const labels = await (0, api_js_1.projectLabels)(project.id);
+        const found = labels.find((one) => one.name.toLowerCase() === name.toLowerCase());
+        if (!found) {
+            console.error(red(`This project has no "${name}" label.`));
+            return 1;
+        }
+        await (0, api_js_1.deleteProjectLabel)(project.id, found.id);
+        console.log(`Removed ${found.name}. ` +
+            dim("Versions that wore it keep everything else about them."));
+        return 0;
+    }
+    console.error(red(`Unknown: cbx labels ${action}`) + dim("  Try list, add or remove"));
+    return 1;
+}
+/**
+ * The versions a project is holding until somebody says yes.
+ *
+ * Listed first rather than requiring a version number, because the person
+ * running this is usually asking "is there anything waiting for me" rather
+ * than acting on one they already know about.
+ */
+async function commandHeld(parsed) {
+    const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[0]);
+    if (!project)
+        return 1;
+    const waiting = (await (0, api_js_1.versions)(project.id)).filter((one) => one.state === "held");
+    if (!waiting.length) {
+        console.log(dim("Nothing is waiting for a decision."));
+        return 0;
+    }
+    console.log(bold(`${waiting.length} waiting on ${project.name}`));
+    for (const one of waiting) {
+        console.log(`  ${accent(`v${one.sequence}`).padEnd(16)} ${one.authorName.padEnd(20)} ` +
+            dim(one.message));
+    }
+    console.log(dim(`\n  cbx review v${waiting[0].sequence} --approve`));
+    return 0;
+}
+async function commandReview(parsed) {
+    const which = split(parsed);
+    const approve = parsed.flags.get("approve") === true;
+    const decline = parsed.flags.get("decline") === true;
+    if (approve === decline) {
+        console.error(red("Say which: --approve or --decline."));
+        return 1;
+    }
+    const project = await (0, project_commands_js_1.resolveProject)(which.project);
+    if (!project)
+        return 1;
+    const target = await pick(project.id, which.n);
+    if (!target)
+        return 1;
+    if (target.state !== "held") {
+        console.error(red(`v${target.sequence} is not waiting for a decision.`));
+        return 1;
+    }
+    const note = parsed.flags.get("note");
+    try {
+        await (0, api_js_1.reviewVersion)(project.id, target.id, approve ? "approve" : "decline", typeof note === "string" ? note : null);
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    console.log(approve
+        ? `${bold(`v${target.sequence}`)} approved. It is now the current version.`
+        : `${bold(`v${target.sequence}`)} declined. It stays in the history as a version that was not accepted.`);
+    return 0;
+}
+/**
+ * Take a version's content down.
+ *
+ * Asks first, and says exactly what will survive, because this is the one
+ * command here that destroys something. The version itself stays — the list
+ * keeps a gap saying what went and who removed it — and that distinction is
+ * the difference between this and rewriting history.
+ */
+async function commandTakeDown(parsed) {
+    const which = split(parsed);
+    const project = await (0, project_commands_js_1.resolveProject)(which.project);
+    if (!project)
+        return 1;
+    const target = await pick(project.id, which.n);
+    if (!target)
+        return 1;
+    const reason = parsed.flags.get("reason");
+    if (parsed.flags.get("yes") !== true) {
+        console.log(red(`This removes the files in v${target.sequence}. They do not come back.`));
+        console.log(dim(`  The version stays in the history as a gap saying it was removed.\n` +
+            `  Add --yes when you are sure.`));
+        return 1;
+    }
+    try {
+        await (0, api_js_1.removeVersionContent)(project.id, target.id, typeof reason === "string" ? reason : null);
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    console.log(`${bold(`v${target.sequence}`)} taken down.`);
+    return 0;
+}
+/**
+ * Turning a commit into a version.
+ *
+ * A project's history is its working history — most of it says "fix that
+ * file", and none of that is anybody else's business. A version is a commit
+ * somebody decided was worth showing, and this is where that decision gets
+ * made: the last ten, pick one, name it.
+ *
+ * Named rather than numbered on purpose. A version people fetch is "v2.1" or
+ * "the one for the client", and inventing a second counter beside the commit
+ * numbers would give everybody two numbers to hold and tell them nothing.
+ */
+async function commandPromote(parsed) {
+    const which = split(parsed);
+    const project = await (0, project_commands_js_1.resolveProject)(which.project);
+    if (!project)
+        return 1;
+    const all = await (0, api_js_1.versions)(project.id);
+    if (!all.length) {
+        console.error(red("This project has nothing saved yet."));
+        return 1;
+    }
+    const named = parsed.flags.get("name");
+    const notes = parsed.flags.get("notes");
+    /* A number given outright skips the list, for anybody scripting this. */
+    const asked = which.n;
+    let target = asked
+        ? all.find((one) => String(one.sequence) === asked.replace(/^v/i, ""))
+        : null;
+    if (asked && !target) {
+        console.error(red(`This project has no ${asked}.`));
+        return 1;
+    }
+    if (!target) {
+        const recent = all.filter((one) => one.state === "verified").slice(0, 10);
+        if (!recent.length) {
+            console.error(red("Nothing here can be promoted yet."));
+            return 1;
+        }
+        console.log(bold(`Recent commits on ${project.name}`));
+        recent.forEach((one, at) => {
+            const when = one.createdAt
+                ? new Date(one.createdAt).toLocaleString()
+                : "";
+            const already = one.name ? accent(`  → ${one.name}`) : "";
+            console.log(`  ${String(at + 1).padStart(2)}. ${accent(`v${one.sequence}`).padEnd(16)}` +
+                `${when.padEnd(22)}${dim(one.message)}${already}`);
+        });
+        const prompt = (0, promises_1.createInterface)({
+            input: node_process_1.default.stdin,
+            output: node_process_1.default.stdout,
+        });
+        const typed = await prompt.question("\nWhich one? (1-" + recent.length + ", or blank to stop) ");
+        prompt.close();
+        const choice = Number(typed.trim());
+        if (!typed.trim()) {
+            console.log(dim("Nothing promoted."));
+            return 0;
+        }
+        if (!Number.isInteger(choice) || choice < 1 || choice > recent.length) {
+            console.error(red("That was not one of the numbers listed."));
+            return 1;
+        }
+        target = recent[choice - 1];
+    }
+    let versionName = typeof named === "string" ? named.trim() : "";
+    if (!versionName) {
+        const prompt = (0, promises_1.createInterface)({
+            input: node_process_1.default.stdin,
+            output: node_process_1.default.stdout,
+        });
+        const typed = await prompt.question(`Call it what? (blank for v${target.sequence}.0) `);
+        prompt.close();
+        versionName = typed.trim() || `v${target.sequence}.0`;
+    }
+    try {
+        await (0, api_js_1.changeVersion)(project.id, target.id, {
+            name: versionName,
+            ...(typeof notes === "string" ? { notes } : {}),
+        });
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    console.log(`${bold(versionName)} is now a version. ` +
+        dim("It is what the public side of this project offers."));
+    return 0;
+}
+/**
+ * Putting the project back where it was.
+ *
+ * Hiding a bad push stops strangers reading it and leaves everybody on the
+ * team standing on it. This moves the project itself, which is the half that
+ * was missing — and it destroys nothing: the commits that get passed over stay
+ * in the history with their numbers, and a later save carries on from here.
+ */
+async function commandUndo(parsed) {
+    const which = split(parsed);
+    const project = await (0, project_commands_js_1.resolveProject)(which.project);
+    if (!project)
+        return 1;
+    const all = await (0, api_js_1.versions)(project.id);
+    if (all.length < 2) {
+        console.error(red("There is nothing before this to go back to."));
+        return 1;
+    }
+    let to = null;
+    const asked = which.n;
+    if (asked) {
+        const wanted = all.find((one) => String(one.sequence) === asked.replace(/^v/i, ""));
+        if (!wanted) {
+            console.error(red(`This project has no ${asked}.`));
+            return 1;
+        }
+        to = wanted.id;
+    }
+    try {
+        const undone = await (0, api_js_1.undoTo)(project.id, to);
+        console.log(`${bold(project.name)} is back on ${accent(`v${undone.to.sequence}`)}.`);
+        if (undone.skipped.length) {
+            /*
+              Named rather than counted. "3 commits passed over" tells somebody
+              nothing they can act on; the numbers let them look at one, or promote
+              one, or put the head back where it was.
+            */
+            console.log(dim(`  Passed over: ${undone.skipped
+                .map((one) => `v${one.sequence}${one.name ? ` (${one.name})` : ""}`)
+                .join(", ")}`));
+            console.log(dim("  They are still here. Nothing was deleted and nothing renumbered."));
+            const stillPublic = undone.skipped.filter((one) => one.name);
+            if (stillPublic.length) {
+                console.log(dim(`  ${stillPublic.map((one) => one.name).join(", ")} ` +
+                    `${stillPublic.length === 1 ? "is" : "are"} still a published version — ` +
+                    `use cbx mark to take ${stillPublic.length === 1 ? "it" : "them"} down.`));
+            }
+        }
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    return 0;
+}