@uic-coe-connect/cli 0.11.0 → 0.12.0

package/dist/commands/deploy.js

@@ -5,21 +5,37 @@ import { resolveApp } from "./apps.js";
 /** Sentinels the deploy stream ends with — the server's own success signal. */
 const OK = "__DEPLOY_OK__";
 const FAILED = "__DEPLOY_FAILED__";
+const CANCELLED = "__DEPLOY_CANCELLED__";
 /**
  * Machine markers the server interleaves for the web UI's pipeline diagram.
  * They're meaningless here and read as debug noise, so they never reach the
  * console or the JSON log — the stream already carries a human line for each.
  */
-const MARKER = /^__(NODE|COMMIT)__:/;
+const MARKER = /^__(NODE|COMMIT|PREV)__:/;
+/**
+ * The engine's marker for a line worth remembering after the run.
+ *
+ * Unlike the others it carries text a person should read, so it is unwrapped
+ * rather than dropped — the summary at the end counts the same lines.
+ */
+const WARN_MARKER = "__WARN__:";
 export function registerDeployCommands() {
     register({
         name: "deploy",
         summary: "Run a deploy pipeline, streaming its output",
-        usage: "deploy <app> [--pipeline <p>] [--branch <b>|--current] [--version <v>]",
+        usage: "deploy <app> [--pipeline <p>] [--branch <b>|--commit <sha>] [--version <v>] [--confirm-script]",
         details: [
             "Streams the live console. Exits 0 only if the deploy succeeded, so it's",
             "safe to chain. A pipeline containing a DB migrate step needs",
             "--confirm-migrate, matching the confirmation the web UI asks for.",
+            "",
+            "--commit deploys an exact commit rather than a branch tip, which is what",
+            "a rollback is: `coe builds <app>` prints each build's previous commit.",
+            "Exit code 8 means somebody cancelled the run, which is not a failure.",
+            "",
+            "A pipeline with a `script` step needs --confirm-script on every run, not",
+            "once: the pipeline fixes which file runs, not what is in it, and that",
+            "changes with the commit being deployed.",
         ],
         async run({ args, client }) {
             const c = client();
@@ -37,35 +53,60 @@ export function registerDeployCommands() {
                 throw new CliError(`No pipeline "${ref}" on ${app.id}.`, 4, `Available: ${pipelines.map((p) => p.name).join(", ")}`);
             }
             const branch = args.flag("branch");
-            const source = args.bool("current")
-                ? { mode: "current" }
-                : branch
-                    ? { mode: "branch", branch }
-                    : {};
+            const commit = args.flag("commit");
+            if (commit && !/^[0-9a-f]{7,40}$/i.test(commit)) {
+                throw new CliError(`"${commit}" is not a commit SHA.`, 4, "Pass the short or full SHA, e.g. --commit a1b2c3d.");
+            }
+            const source = commit
+                ? { mode: "commit", commit, branch }
+                : args.bool("current")
+                    ? { mode: "current" }
+                    : branch
+                        ? { mode: "branch", branch }
+                        : {};
             const body = {
                 pipelineId: chosen.id,
                 version: args.flag("version"),
                 source,
                 confirmMigrate: args.bool("confirm-migrate"),
+                confirmScript: args.bool("confirm-script"),
             };
             const needsMigrate = chosen.config.steps.some((s) => s.type === "migrate");
             if (needsMigrate && !args.bool("confirm-migrate")) {
                 throw new CliError(`Pipeline "${chosen.name}" runs database migrations.`, 6, "Re-run with --confirm-migrate once you've checked the migration is safe.");
             }
+            /**
+             * A script step is confirmed on every run, not once when it was added.
+             *
+             * Every other step's behaviour is fixed by the pipeline. A script's is
+             * whatever the file says on the commit being deployed — so approving it
+             * once would approve code that had not been written yet.
+             */
+            const scripts = chosen.config.steps.filter((x) => x.type === "script");
+            if (scripts.length > 0 && !args.bool("confirm-script")) {
+                const files = scripts.map((x) => [x.subdir, x.file].filter(Boolean).join("/"));
+                throw new CliError(`Pipeline "${chosen.name}" runs ${files.join(", ")} from the app's repo as root.`, 6, "Read that file on the commit you're deploying, then re-run with --confirm-script.");
+            }
             info(`Deploying ${app.id} · pipeline "${chosen.name}"${branch ? ` · branch ${branch}` : ""}`);
             const lines = [];
             const sentinels = [];
-            let commit;
+            const warnings = [];
+            let deployed;
             await c.stream("POST", `/registered-apps/${app.id}/deploy`, body, (line) => {
-                if (line === OK || line === FAILED) {
+                if (line === OK || line === FAILED || line === CANCELLED) {
                     sentinels.push(line);
                     return;
                 }
-                if (MARKER.test(line)) {
+                if (line.startsWith(WARN_MARKER)) {
+                    const text = line.slice(WARN_MARKER.length);
+                    warnings.push(text);
+                    line = `⚠ ${text}`;
+                }
+                else if (MARKER.test(line)) {
                     // Keep the one piece of information a marker carries that the
                     // human stream doesn't structure: which commit got deployed.
                     if (line.startsWith("__COMMIT__:"))
-                        commit = line.split(":")[1];
+                        deployed = line.split(":")[1];
                     return;
                 }
                 lines.push(line);
@@ -81,32 +122,63 @@ export function registerDeployCommands() {
             // ends the stream with no sentinel at all.
             const outcome = sentinels.includes(OK)
                 ? "ok"
-                : sentinels.includes(FAILED)
-                    ? "failed"
-                    : "unknown";
-            emit({ appId: app.id, pipeline: chosen.name, status: outcome, commit, log: lines }, () => {
-                info(outcome === "ok" ? `\n✓ Deploy succeeded` : `\n✗ Deploy ${outcome}`);
+                : sentinels.includes(CANCELLED)
+                    ? "cancelled"
+                    : sentinels.includes(FAILED)
+                        ? "failed"
+                        : "unknown";
+            emit({
+                appId: app.id,
+                pipeline: chosen.name,
+                status: outcome,
+                commit: deployed,
+                warnings,
+                log: lines,
+            }, () => {
+                info(outcome === "ok"
+                    ? "\n✓ Deploy succeeded"
+                    : outcome === "cancelled"
+                        ? "\n■ Deploy cancelled"
+                        : `\n✗ Deploy ${outcome}`);
+                // The console has usually scrolled well past these by now, and a
+                // deploy that worked is the case where nobody scrolls back.
+                if (warnings.length > 0) {
+                    info(`\n${warnings.length} warning(s):`);
+                    for (const w of warnings)
+                        info(`  ⚠ ${w}`);
+                }
             });
             // A stream that ended without a sentinel means the connection dropped
             // mid-deploy — the deploy may still be running, so don't report success.
             if (outcome !== "ok") {
                 throw new CliError(outcome === "failed"
                     ? "The deploy failed — see the output above."
-                    : "The deploy stream ended without a result; check build history.", 7);
+                    : outcome === "cancelled"
+                        ? "The deploy was cancelled. The app is in whatever state the stopped step left it."
+                        : "The deploy stream ended without a result; check build history.", outcome === "cancelled" ? 8 : 7);
             }
         },
     }, {
         name: "builds",
         summary: "Show an app's build history",
-        usage: "builds <app> [--limit <n>]",
+        usage: "builds <app> [--limit <n>] [--offset <n>]",
+        details: [
+            "The `warn` column counts warnings the build produced — things that did",
+            "not stop it and that nobody reads in a console nobody reopens. Use",
+            "`coe build-log` to see them in context.",
+            "",
+            "`rollback` is the commit that was live before that build: deploying it",
+            "is what undoing that build means.",
+        ],
         async run({ args, client }) {
             const c = client();
             const app = await resolveApp(c, args.arg(0, "app"));
-            const { builds } = await c.request("GET", `/registered-apps/${app.id}/builds`);
             const limit = Number(args.flag("limit") ?? 20);
-            const shown = builds.slice(0, Number.isFinite(limit) ? limit : 20);
-            emit({ appId: app.id, builds: shown }, () => {
-                table(shown.map((b) => ({
+            const offset = Number(args.flag("offset") ?? 0);
+            const { builds, total } = await c.request("GET", `/registered-apps/${app.id}/builds?limit=${Number.isFinite(limit) ? limit : 20}` +
+                `&offset=${Number.isFinite(offset) ? offset : 0}`);
+            emit({ appId: app.id, builds, total, offset }, () => {
+                table(builds.map((b) => ({
                     started: new Date(b.startedAt).toLocaleString(),
                     status: b.status,
                     version: b.version ?? "—",
@@ -114,7 +186,94 @@ export function registerDeployCommands() {
                     source: b.source,
                     by: b.by ?? "—",
                     commit: b.commit?.slice(0, 8) ?? "—",
-                })), ["started", "status", "version", "pipeline", "source", "by", "commit"]);
+                    rollback: b.previousCommit?.slice(0, 8) ?? "—",
+                    warn: String((b.warnings ?? []).reduce((n, w) => n + w.count, 0) || "—"),
+                })), ["started", "status", "version", "pipeline", "source", "by", "commit", "rollback", "warn"]);
+                if (total > builds.length) {
+                    info(`\nShowing ${builds.length} of ${total} — use --offset to page back.`);
+                }
+            });
+        },
+    }, {
+        name: "build-log",
+        summary: "Print a past build's console",
+        usage: "build-log <app> <buildId>",
+        details: [
+            "Only the most recent builds keep a console — `coe builds` marks the ones",
+            "that still have one. A build's warnings are printed first, because they",
+            "are the part of a successful deploy worth reading.",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const app = await resolveApp(c, args.arg(0, "app"));
+            const buildId = args.arg(1, "buildId");
+            const { builds } = await c.request("GET", `/registered-apps/${app.id}/builds?limit=100`);
+            const build = builds.find((b) => b.id === buildId || b.version === buildId);
+            if (!build) {
+                throw new CliError(`No build "${buildId}" on ${app.id}.`, 4, "List them with: coe builds " + app.id);
+            }
+            const { lines } = await c.request("GET", `/registered-apps/${app.id}/builds/${build.id}/log`);
+            emit({ appId: app.id, build, lines }, () => {
+                for (const w of build.warnings ?? []) {
+                    info(`⚠ ${w.count > 1 ? `${w.count}× ` : ""}${w.label}`);
+                    if (w.hint)
+                        info(`  ${w.hint}`);
+                }
+                if ((build.warnings ?? []).length > 0)
+                    info("");
+                for (const line of lines)
+                    process.stdout.write(`${line}\n`);
+            });
+        },
+    }, {
+        name: "commits",
+        summary: "List recent commits on a branch of an app's repo",
+        usage: "commits <app> [--branch <b>] [--limit <n>]",
+        details: [
+            "Reads the app's own checkout on its VM, so this is what `coe deploy",
+            "--commit` can actually deploy — not what your local clone has.",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const app = await resolveApp(c, args.arg(0, "app"));
+            const branch = args.flag("branch") ?? app.branch;
+            if (!branch) {
+                throw new CliError(`${app.id} has no default branch set.`, 4, "Name one with --branch, or set it on the app.");
+            }
+            const limit = Number(args.flag("limit") ?? 25);
+            const { commits } = await c.request("GET", `/registered-apps/${app.id}/commits?branch=${encodeURIComponent(branch)}` +
+                `&limit=${Number.isFinite(limit) ? limit : 25}`);
+            emit({ appId: app.id, branch, commits }, () => {
+                table(commits.map((x) => ({
+                    commit: x.sha,
+                    subject: x.subject,
+                    author: x.author,
+                    date: new Date(x.date).toLocaleString(),
+                })), ["commit", "subject", "author", "date"]);
+            });
+        },
+    }, {
+        name: "cancel",
+        summary: "Stop the deploy running on an app",
+        usage: "cancel <app>",
+        details: [
+            "Stops the pipeline: the running command is killed and no further step",
+            "starts. It does not put anything back — the checkout is wherever the",
+            "stopped step left it, and if that step was building or installing, the",
+            "app needs another deploy to reach a state somebody chose.",
+            "",
+            "To undo a deploy, deploy what was live before it:",
+            "  coe deploy <app> --commit $(coe builds <app> --limit 1 --json | …)",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const app = await resolveApp(c, args.arg(0, "app"));
+            // A 409 — "nothing is deploying on this app right now" — is the ordinary
+            // race, not an error worth dressing up: it finished while you typed.
+            // The server's own message says exactly that, so it is left to surface.
+            const result = await c.request("POST", `/registered-apps/${app.id}/deploy/cancel`);
+            emit({ appId: app.id, ...result }, () => {
+                info(`■ Asked ${app.id}'s deploy to stop. Watch it finish with: coe logs ${app.id}`);
             });
         },
     }, {

package/dist/commands/pipelines.js

@@ -7,11 +7,22 @@ import { resolveApp } from "./apps.js";
  * Steps are written as a compact `type:arg` list so a pipeline can be created
  * in one command instead of hand-authoring JSON:
  *
- *   pull  scan  env:backend  npm:ci@backend  migrate:backend  chown  pm2:restart@my-api
+ *   preflight  pull  scan  backup:db  npm:ci@backend  chown  pm2:restart@my-api  health:/healthz
  *
  * `--steps-file` takes the raw JSON array instead, for anything this shorthand
- * can't express.
+ * can't express — a `script` step's arguments, say.
  */
+/** Everything `clean` is allowed to delete. Mirrors the engine's allowlist. */
+const CLEAN_TARGETS = [
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "target",
+    "vendor",
+];
 function parseStep(token) {
     const [head, subdir] = token.split("@");
     const [type, arg] = head.split(":");
@@ -41,8 +52,36 @@ function parseStep(token) {
             if (!arg)
                 throw new CliError(`pm2 step needs an action: pm2:restart@process-name`, 6);
             return { type: "pm2", action: arg, process: subdir || undefined };
+        case "preflight":
+            return { type: "preflight", minFreeMb: arg ? Number(arg) || undefined : undefined };
+        case "apache":
+            return { type: "apache" };
+        case "clean": {
+            // Comma-separated, and each one checked here so a typo is a refusal with
+            // the valid list rather than a step that silently cleans nothing.
+            const wanted = (arg || "dist").split(",").filter(Boolean);
+            const bad = wanted.filter((t) => !CLEAN_TARGETS.includes(t));
+            if (bad.length > 0) {
+                throw new CliError(`clean step can't remove ${bad.join(", ")}.`, 6, `It only removes well-known build output: ${CLEAN_TARGETS.join(", ")}`);
+            }
+            return { type: "clean", targets: wanted, subdir: subdir || undefined };
+        }
+        case "backup":
+            if (arg && arg !== "db") {
+                throw new CliError(`backup step takes "db" or nothing: got "${arg}"`, 6);
+            }
+            return { type: "backup", db: arg === "db", subdir: subdir || undefined };
+        case "health":
+            // `health:/healthz` — the path keeps its slash because only the first
+            // colon splits the token.
+            return { type: "health", path: arg ? `/${arg.replace(/^\//, "")}` : undefined };
+        case "script":
+            if (!arg) {
+                throw new CliError(`script step needs a file: script:deploy/after-build.sh`, 6, "It must be an executable committed to the app's repo. Use --steps-file to pass arguments.");
+            }
+            return { type: "script", file: arg, subdir: subdir || undefined };
         default:
-            throw new CliError(`Unknown step "${token}".`, 6, "Valid: pull, scan, env[:subdir], chown, npm:<script>[@subdir], migrate[:subdir], docker[:<up|restart|build>][@subdir], pm2:<action>[@process]");
+            throw new CliError(`Unknown step "${token}".`, 6, "Valid: preflight[:minFreeMb], pull, scan, backup[:db][@subdir], clean[:a,b][@subdir], env[:subdir], chown, npm:<script>[@subdir], migrate[:subdir], docker[:<up|restart|build>][@subdir], pm2:<action>[@process], apache, health[:path], script:<file>[@subdir]");
     }
 }
 function describeStep(step) {
@@ -57,6 +96,18 @@ function describeStep(step) {
             return `docker compose ${step.action ?? "up"}${step.subdir ? ` (${step.subdir})` : ""}`;
         case "pm2":
             return `pm2 ${step.action}${step.process ? ` ${step.process}` : ""}`;
+        case "preflight":
+            return "pre-flight checks";
+        case "clean":
+            return `clean ${(step.targets ?? ["dist"]).join(", ")}${step.subdir ? ` (${step.subdir})` : ""}`;
+        case "backup":
+            return step.db ? "backup (code + database)" : "backup (code)";
+        case "health":
+            return `health check ${step.path ?? "/"}`;
+        case "apache":
+            return "apache configtest + reload";
+        case "script":
+            return `run ${step.file}${step.subdir ? ` (${step.subdir})` : ""}`;
         default:
             return step.type;
     }

package/dist/commands/tips.d.ts

@@ -0,0 +1 @@
+export declare function registerTipCommands(): void;

package/dist/commands/tips.js

@@ -0,0 +1,113 @@
+import { CliError } from "../client.js";
+import { emit, info, table } from "../output.js";
+import { register } from "../registry.js";
+import { resolveApp } from "./apps.js";
+export function registerTipCommands() {
+    register({
+        name: "tips submit",
+        summary: "Suggest advice for a deploy failure or warning",
+        usage: 'tips submit <app> --kind <failure|warning> --trigger "<text>" --tip "<advice>"',
+        details: [
+            "Nothing you submit is shown to anyone else until a webadmin reviews it.",
+            "",
+            "--trigger is what identifies the situation to the *next* person: the",
+            "warning category, or the distinctive part of an error line. Leave the",
+            "app-specific parts out — paths, ports, process names and SHAs are",
+            "normalised away so the same problem from five apps is one entry with a",
+            "count, and that count is the thing worth acting on.",
+            "",
+            "--tip is the advice itself: what the line means and what to do. Write it",
+            "for somebody who has not just spent an hour on it.",
+            "",
+            "Never put credentials, tokens or connection strings in either field.",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const app = await resolveApp(c, args.arg(0, "app"));
+            const kind = args.flag("kind");
+            if (kind !== "failure" && kind !== "warning") {
+                throw new CliError("--kind must be failure or warning.", 6);
+            }
+            const trigger = args.flag("trigger");
+            const tip = args.flag("tip");
+            if (!trigger || !tip) {
+                throw new CliError("--trigger and --tip are both required.", 6, 'e.g. coe tips submit myapp --kind warning --trigger "npm warn EBADENGINE" --tip "The app declares an engines range this VM\'s Node does not satisfy; bump the range or the VM\'s Node."');
+            }
+            const result = await c.request("POST", `/registered-apps/${app.id}/deploy-tips`, {
+                kind,
+                trigger,
+                tip,
+                buildId: args.flag("build"),
+                source: args.flag("source"),
+            });
+            emit({ appId: app.id, ...result }, () => {
+                if (result.alreadyReviewed === "rejected") {
+                    info("■ A maintainer has already looked at this trigger and declined advice for it. " +
+                        "Your submission was counted, not queued again — don't keep suggesting it.");
+                    return;
+                }
+                if (result.alreadyReviewed === "accepted") {
+                    info("✓ This trigger already has accepted advice. Counted, not queued again.");
+                    return;
+                }
+                info(result.created
+                    ? `✓ Suggested (${result.id}). It sits in the review queue until a webadmin accepts it.`
+                    : `✓ Folded into an existing suggestion — now reported ${result.occurrences} times.`);
+            });
+        },
+    }, {
+        name: "tips list",
+        summary: "The suggested-advice review queue (webadmin)",
+        usage: "tips list [--status new|accepted|rejected]",
+        details: [
+            "Sorted by most recent activity. `seen` is how many times a trigger has",
+            "been reported — the column to sort your attention by, since one report",
+            "is an anecdote and five from different apps is a gap in the product.",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const status = args.flag("status") ?? "";
+            const query = status ? `?status=${encodeURIComponent(status)}` : "";
+            const { tips, newCount } = await c.request("GET", `/deploy-tips${query}`);
+            emit({ tips, newCount }, () => {
+                if (tips.length === 0) {
+                    info(status ? `No ${status} suggestions.` : "No suggestions yet.");
+                    return;
+                }
+                table(tips.map((t) => ({
+                    id: t.id,
+                    status: t.status,
+                    kind: t.kind,
+                    seen: String(t.occurrences),
+                    apps: t.appIds.join(", "),
+                    trigger: t.trigger.slice(0, 48),
+                    tip: t.tip.slice(0, 60),
+                })), ["id", "status", "kind", "seen", "apps", "trigger", "tip"]);
+                if (!status && newCount > 0)
+                    info(`\n${newCount} awaiting review.`);
+            });
+        },
+    }, {
+        name: "tips review",
+        summary: "Accept or reject a suggestion (webadmin)",
+        usage: 'tips review <id> <accepted|rejected> [--note "<why>"]',
+        details: [
+            "Rejecting is not a delete: the entry is kept so the same suggestion is",
+            "recognised and counted rather than re-queued, and whoever submitted it",
+            "is told it has already been declined.",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const id = args.arg(0, "id");
+            const status = args.arg(1, "status");
+            if (status !== "accepted" && status !== "rejected") {
+                throw new CliError("Status must be accepted or rejected.", 6);
+            }
+            const { tip } = await c.request("POST", `/deploy-tips/${id}/review`, {
+                status,
+                note: args.flag("note"),
+            });
+            emit({ tip }, () => info(`✓ ${tip.id} marked ${tip.status}.`));
+        },
+    });
+}

package/dist/index.js

@@ -12,6 +12,7 @@ import { registerLogCommands } from "./commands/logs.js";
 import { registerPipelineCommands } from "./commands/pipelines.js";
 import { registerReportCommands } from "./commands/reports.js";
 import { registerResourceCommands } from "./commands/resources.js";
+import { registerTipCommands } from "./commands/tips.js";
 import { registerVmCommands } from "./commands/vms.js";
 import { info, setJsonMode } from "./output.js";
 import { allCommands, findCommand, register } from "./registry.js";
@@ -28,6 +29,7 @@ registerLogCommands();
 registerVmCommands();
 registerReportCommands();
 registerDirectoryCommands();
+registerTipCommands();
 function parseArgs(argv) {
     const positional = [];
     const flags = {};

package/dist/types.d.ts

@@ -4,6 +4,7 @@
  * on its own against a deployed server, so it must not depend on the API's
  * build output.
  */
+export type CleanTarget = "node_modules" | "dist" | "build" | ".next" | ".nuxt" | ".cache" | "target" | "vendor";
 export type DeployStep = {
     type: "pull";
 } | {
@@ -28,6 +29,42 @@ export type DeployStep = {
     type: "pm2";
     action: string;
     process?: string;
+}
+/** Checks the rest of the pipeline can run before any of it does. */
+ | {
+    type: "preflight";
+    minFreeMb?: number;
+}
+/** Removes build artefacts, from a fixed allowlist of directory names. */
+ | {
+    type: "clean";
+    subdir?: string;
+    targets?: CleanTarget[];
+}
+/** Records the rollback point, and optionally dumps the app's database. */
+ | {
+    type: "backup";
+    subdir?: string;
+    db?: boolean;
+    keepDays?: number;
+}
+/** Asks the app over HTTP whether it works — what pm2 can't tell you. */
+ | {
+    type: "health";
+    path?: string;
+    status?: number;
+    retries?: number;
+}
+/** apachectl configtest, then a graceful reload. */
+ | {
+    type: "apache";
+}
+/** Runs an executable committed to the app's own repo. */
+ | {
+    type: "script";
+    subdir?: string;
+    file: string;
+    args?: string[];
 };
 export interface DeployConfig {
     steps: DeployStep[];
@@ -90,6 +127,14 @@ export interface RegisteredApp {
     createdAt: string;
     updatedAt: string;
 }
+/** A category of warning a build produced, with how many times it occurred. */
+export interface BuildWarning {
+    code: string;
+    label: string;
+    count: number;
+    samples: string[];
+    hint?: string;
+}
 export interface Build {
     id: string;
     appId: string;
@@ -97,9 +142,25 @@ export interface Build {
     pipelineName?: string;
     source: string;
     by?: string;
-    status: "running" | "ok" | "failed";
+    /** `cancelled` is its own outcome — somebody stopped it, it didn't break. */
+    status: "running" | "ok" | "failed" | "cancelled";
     startedAt: string;
     finishedAt?: string;
     commit?: string;
     commitSubject?: string;
+    /** What was live before this build — what rolling it back would deploy. */
+    previousCommit?: string;
+    previousCommitSubject?: string;
+    warnings?: BuildWarning[];
+    /** Whether this build's console is still stored (only the recent ones are). */
+    hasLog?: boolean;
+    cancelledBy?: string;
+    error?: string;
+}
+/** One commit on a branch, as `coe commits` lists them. */
+export interface CommitSummary {
+    sha: string;
+    subject: string;
+    author: string;
+    date: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uic-coe-connect/cli",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "The coe CLI \u2014 manage COEConnect apps (pipelines, deploys, access, env) from a terminal, with browser-approved auth. Designed to be driven by an AI agent.",
   "type": "module",
   "bin": {