@coderook/cli 0.11.0 → 0.12.0

package/dist/cli/src/api.js

@@ -20,6 +20,8 @@ exports.invite = invite;
 exports.watch = watch;
 exports.setWatch = setWatch;
 exports.workflows = workflows;
+exports.runs = runs;
+exports.runLogs = runLogs;
 exports.tokens = tokens;
 exports.revokeToken = revokeToken;
 exports.deleteProject = deleteProject;
@@ -242,6 +244,47 @@ async function workflows(repositoryId) {
         archivedAt: row.archivedAt ? String(row.archivedAt) : null,
     }));
 }
+/**
+ * What has run on a project.
+ *
+ * The same route the workflow list comes from; the service returns both and
+ * the CLI was throwing half of it away. Filters are passed through rather
+ * than applied here, because a project with a thousand runs should not send
+ * a thousand rows to show ten.
+ */
+async function runs(repositoryId, filter = {}) {
+    const query = new URLSearchParams();
+    if (filter.status)
+        query.set("status", filter.status);
+    if (filter.workflow)
+        query.set("workflow", filter.workflow);
+    const suffix = query.size ? `?${query.toString()}` : "";
+    const body = await call(`/v1/repositories/${encodeURIComponent(repositoryId)}/workflows${suffix}`);
+    return (body.runs ?? []).map((row) => {
+        const workflow = (row.workflow ?? {});
+        const version = (row.version ?? null);
+        return {
+            id: String(row.id ?? ""),
+            number: Number(row.number ?? 0),
+            workflow: String(workflow.name ?? ""),
+            version: version ? Number(version.sequence ?? 0) : null,
+            status: String(row.status ?? ""),
+            summary: String(row.summary ?? ""),
+            claimedBy: row.claimedBy ? String(row.claimedBy) : null,
+            startedAt: row.startedAt ? String(row.startedAt) : null,
+            finishedAt: row.finishedAt ? String(row.finishedAt) : null,
+            durationMs: row.durationMs === null || row.durationMs === undefined
+                ? null
+                : Number(row.durationMs),
+        };
+    });
+}
+/** Everything a run printed, in the order it printed it. */
+async function runLogs(repositoryId, runId) {
+    const body = await call(`/v1/repositories/${encodeURIComponent(repositoryId)}/runs/` +
+        `${encodeURIComponent(runId)}/logs`);
+    return body.lines ?? [];
+}
 /** Personal access tokens on the account. */
 async function tokens() {
     const body = await call("/v1/account/tokens");

package/dist/cli/src/cli.js

@@ -1183,6 +1183,34 @@ const SPECS = [
             "runs have passed. Use `coderook runner` to execute them on this machine.",
         run: service_commands_js_1.commandWorkflows,
     },
+    {
+        name: "runs",
+        group: "Actions",
+        summary: "what has run, and how it went",
+        usage: "runs [project]",
+        detail: "Newest first, with the machine that took each one. A run that is still\n" +
+            "going shows the runner holding it, which is the first thing worth\n" +
+            "knowing when one is taking longer than it should.",
+        options: [
+            {
+                flags: "--status <state>",
+                description: "queued, running, passed, failed or cancelled",
+            },
+        ],
+        examples: ["coderook runs --status failed"],
+        run: service_commands_js_1.commandRuns,
+    },
+    {
+        name: "logs",
+        group: "Actions",
+        summary: "what one run printed",
+        usage: "logs <number> [project]",
+        detail: "The output the runner sent up, in order. Anything the command wrote to\n" +
+            "stderr is shown in red. Exits 1 when the run failed, so this can be\n" +
+            "the last line of a script.",
+        examples: ["coderook logs 12", "coderook logs #12 my-project"],
+        run: service_commands_js_1.commandLogs,
+    },
     {
         name: "delete",
         group: "Your projects",
@@ -1235,8 +1263,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/service_commands.js

@@ -16,6 +16,8 @@ exports.commandReleases = commandReleases;
 exports.commandCollaborators = commandCollaborators;
 exports.commandWatch = commandWatch;
 exports.commandWorkflows = commandWorkflows;
+exports.commandRuns = commandRuns;
+exports.commandLogs = commandLogs;
 exports.commandTokens = commandTokens;
 exports.commandDelete = commandDelete;
 const node_process_1 = __importDefault(require("node:process"));
@@ -182,6 +184,116 @@ async function commandWorkflows(parsed) {
     }
     return 0;
 }
+const RUN_STATES = ["queued", "running", "passed", "failed", "cancelled"];
+/** Colour a status the way somebody scanning the list would want it. */
+function statusText(status) {
+    if (status === "passed")
+        return green(status);
+    if (status === "failed" || status === "cancelled")
+        return red(status);
+    if (status === "running")
+        return accent(status);
+    return dim(status);
+}
+function elapsed(ms) {
+    if (ms === null)
+        return "";
+    const seconds = Math.round(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+}
+/**
+ * What has run, and how it went.
+ *
+ * The runner has always shipped every line of output to the service, and the
+ * service has always kept it — but the only way to read any of it back was
+ * the website. Somebody running a job from a terminal had to leave the
+ * terminal to find out why it failed.
+ */
+async function commandRuns(parsed) {
+    const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[0]);
+    if (!project)
+        return 1;
+    const status = parsed.flags.get("status");
+    if (typeof status === "string" && !RUN_STATES.includes(status)) {
+        console.error(red(`Status must be one of: ${RUN_STATES.join(", ")}`));
+        return 1;
+    }
+    const found = await (0, api_js_1.runs)(project.id, {
+        status: typeof status === "string" ? status : undefined,
+    });
+    if (!found.length) {
+        console.log(dim("Nothing has run on this project."));
+        return 0;
+    }
+    console.log(bold(project.name));
+    for (const run of found) {
+        const when = run.startedAt
+            ? new Date(run.startedAt).toLocaleString()
+            : dim("not started");
+        console.log(`  ${accent(`#${run.number}`).padEnd(15)} ${statusText(run.status).padEnd(20)} ` +
+            `${run.workflow.padEnd(24)} ${elapsed(run.durationMs).padEnd(9)} ${dim(when)}`);
+        const aside = [
+            run.version === null ? "" : `v${run.version}`,
+            run.claimedBy ?? "",
+            run.summary,
+        ].filter(Boolean);
+        if (aside.length)
+            console.log(`    ${dim(aside.join(" · "))}`);
+    }
+    console.log("");
+    console.log(dim("  Read one with: coderook logs <number>"));
+    return 0;
+}
+/**
+ * What one run printed.
+ *
+ * Taken by the number people actually say — "#12 failed" — rather than the
+ * identifier the service uses, which nobody has in front of them.
+ */
+async function commandLogs(parsed) {
+    const asked = parsed.positional[0];
+    if (!asked) {
+        console.error(red("Which run? Try: coderook logs 12"));
+        return 1;
+    }
+    const number = Number(asked.replace(/^#/, ""));
+    if (!Number.isInteger(number) || number < 1) {
+        console.error(red(`"${asked}" is not a run number.`));
+        return 1;
+    }
+    const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[1]);
+    if (!project)
+        return 1;
+    const found = await (0, api_js_1.runs)(project.id);
+    const run = found.find((one) => one.number === number);
+    if (!run) {
+        console.error(red(`${project.name} has no run #${number}.`));
+        if (found.length) {
+            console.error(dim(`  The most recent is #${found[0]?.number}.`));
+        }
+        return 1;
+    }
+    const lines = await (0, api_js_1.runLogs)(project.id, run.id);
+    console.log(`${accent(`#${run.number}`)} ${bold(run.workflow)} — ${statusText(run.status)}` +
+        `${run.summary ? ` · ${dim(run.summary)}` : ""}`);
+    if (!lines.length) {
+        /*
+          Told apart deliberately. A queued run has printed nothing yet, which is
+          normal; a finished run that printed nothing is a workflow whose command
+          said nothing, which is worth knowing.
+        */
+        console.log(dim(run.status === "queued"
+            ? "  Nothing yet; this run has not been picked up."
+            : "  This run recorded no output."));
+        return 0;
+    }
+    for (const line of lines) {
+        console.log(line.stream === "stderr" ? red(line.line) : line.line);
+    }
+    return run.status === "failed" ? 1 : 0;
+}
 /** The tokens that can act as this account. */
 async function commandTokens(parsed) {
     const revoke = parsed.flags.get("revoke");

package/package.json

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