@uic-coe-connect/cli 0.7.1 → 0.9.0

package/dist/commands/reports.d.ts

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

package/dist/commands/reports.js

@@ -0,0 +1,278 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename } from "node:path";
+import { CliError } from "../client.js";
+import { details, emit, info, table } from "../output.js";
+import { register } from "../registry.js";
+/**
+ * Bug reports and feature requests from the terminal.
+ *
+ * The point of this surface: a maintainer (or an AI agent working on their
+ * behalf) fixing a bug is already in a terminal, and the report is the thing
+ * that says what to fix and who is waiting on it. Closing the loop shouldn't
+ * mean going to find a browser tab.
+ *
+ * Permissions are the API's, unchanged: you see reports you filed and reports
+ * on apps you help run, and only the latter lets you set a status.
+ */
+const STATUSES = ["open", "planned", "in-progress", "done", "declined"];
+const CLOSED = ["done", "declined"];
+function humanSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** Every file on the thread, wherever it hangs — the whole list is what you search. */
+function allAttachments(report) {
+    return [...(report.attachments ?? []), ...(report.comments ?? []).flatMap((c) => c.attachments ?? [])];
+}
+/** Match an attachment by id or by filename, the way `files download` matches. */
+function findAttachment(report, ref) {
+    const all = allAttachments(report);
+    const byId = all.find((a) => a.id === ref);
+    if (byId)
+        return byId;
+    const matches = all.filter((a) => a.name.toLowerCase().includes(ref.toLowerCase()));
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1) {
+        throw new CliError(`"${ref}" matches ${matches.length} attachments: ${matches.map((a) => a.name).join(", ")}`, 4, "Use the exact attachment id.");
+    }
+    throw new CliError(`No attachment "${ref}" on that report.`, 4, all.length === 0 ? "It has no attachments." : `It has: ${all.map((a) => a.name).join(", ")}`);
+}
+function assertStatus(value) {
+    if (!STATUSES.includes(value)) {
+        throw new CliError(`Unknown status "${value}".`, 6, `Use one of: ${STATUSES.join(", ")}`);
+    }
+    return value;
+}
+function day(iso) {
+    return iso.slice(0, 10);
+}
+/**
+ * Resolve an app reference for filing.
+ *
+ * Deliberately not apps.ts's resolveApp: that one reads /registered-apps,
+ * which lists only apps you can *manage*. Anyone may file a report about an
+ * app they merely use, so a shared resolver would refuse exactly the people
+ * this command exists for. /reports/targets is the filing-side list, and it's
+ * the same list the server checks the POST against.
+ */
+async function resolveTarget(client, ref) {
+    // The portal itself has no registry entry; its reports carry no appId.
+    if (ref === "coeconnect")
+        return null;
+    const { targets, attributes } = await client.request("GET", "/reports/targets");
+    const exact = targets.find((t) => t.id === ref);
+    if (exact)
+        return exact.id;
+    const needle = ref.toLowerCase();
+    const matches = targets.filter((t) => t.name.toLowerCase().includes(needle));
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length > 1) {
+        throw new CliError(`"${ref}" matches ${matches.length} apps: ${matches.map((t) => t.id).join(", ")}`, 4, "Use the exact app id.");
+    }
+    // A terminal session authenticates by NetID and carries no SAML attributes,
+    // so apps that grant access by attribute rule can't appear in this list.
+    // Saying so beats a flat "no such app" the reporter can't act on.
+    throw new CliError(`No app "${ref}" that you have access to.`, 4, attributes
+        ? "Run `coe reports file coeconnect …` to report a problem with the portal itself."
+        : "This session can't evaluate attribute-based access, so apps granted that way " +
+            "aren't listed — file those from the COEConnect web UI.");
+}
+export function registerReportCommands() {
+    register({
+        name: "reports list",
+        summary: "List bug reports and feature requests",
+        usage: "reports list [app] [--all] [--mine]",
+        details: [
+            "Shows reports on apps you help run, plus any you filed yourself.",
+            "",
+            "  [app]     Limit to one app (id, name or URL)",
+            "  --all     Include closed reports (done / won't do)",
+            "  --mine    Only reports you filed",
+        ],
+        async run({ args, client }) {
+            const { reports } = await client().request("GET", "/reports");
+            // Matched against what came back rather than resolved through
+            // /registered-apps: that endpoint is manage-scoped, and someone who
+            // only files reports manages nothing.
+            const ref = args.positional[0]?.toLowerCase();
+            const shown = reports.filter((r) => {
+                if (ref &&
+                    r.appId !== args.positional[0] &&
+                    !(r.appName ?? "").toLowerCase().includes(ref)) {
+                    return false;
+                }
+                if (args.bool("mine") && r.reason !== "reporter")
+                    return false;
+                if (!args.bool("all") && CLOSED.includes(r.status))
+                    return false;
+                return true;
+            });
+            emit({ reports: shown }, () => {
+                table(shown.map((r) => ({
+                    id: r.id,
+                    status: r.status,
+                    kind: r.kind === "bug" ? "bug" : "request",
+                    app: r.appName ?? r.appId ?? "COEConnect",
+                    title: r.title.length > 60 ? `${r.title.slice(0, 57)}…` : r.title,
+                    from: r.reporterNetid,
+                    filed: day(r.createdAt),
+                })), ["id", "status", "kind", "app", "title", "from", "filed"]);
+                if (shown.length > 0 && !args.bool("all")) {
+                    info("");
+                    info("Closed reports are hidden — pass --all to include them.");
+                }
+            });
+        },
+    }, {
+        name: "reports show",
+        summary: "Show one report and its whole thread",
+        usage: "reports show <id>",
+        async run({ args, client }) {
+            const id = args.arg(0, "id");
+            const data = await client().request("GET", `/reports/${id}`);
+            emit(data, () => {
+                const r = data.report;
+                details([
+                    ["Title", r.title],
+                    ["App", data.appName],
+                    ["Kind", r.kind === "bug" ? "Bug report" : "Feature request"],
+                    ["Status", r.status],
+                    ["From", `${r.reporterName ?? r.reporterNetid} (${r.reporterNetid})`],
+                    ["Filed", r.createdAt],
+                    ...(r.pageUrl ? [["Page", r.pageUrl]] : []),
+                ]);
+                process.stdout.write(`\n${r.body}\n`);
+                for (const a of r.attachments ?? []) {
+                    process.stdout.write(`  [attachment] ${a.name} (${humanSize(a.size)}) ${a.id}\n`);
+                }
+                for (const comment of r.comments ?? []) {
+                    const change = comment.statusTo ? ` [→ ${comment.statusTo}]` : "";
+                    process.stdout.write(`\n--- ${comment.authorName ?? comment.authorNetid} · ${comment.createdAt}${change}\n` +
+                        (comment.body ? `${comment.body}\n` : ""));
+                    for (const a of comment.attachments ?? []) {
+                        process.stdout.write(`  [attachment] ${a.name} (${humanSize(a.size)}) ${a.id}\n`);
+                    }
+                }
+                const files = allAttachments(r);
+                if (files.length > 0) {
+                    info("");
+                    info(`${files.length} attachment(s) — fetch one with: coe reports download ${r.id} <name>`);
+                }
+                if (!data.canRespond) {
+                    info("");
+                    info("You can reply, but only the people who run this app can set its status.");
+                }
+            });
+        },
+    }, {
+        name: "reports reply",
+        summary: "Reply on a report, and optionally set its status",
+        usage: "reports reply <id> <message> [--status <status>]",
+        details: [
+            `  --status  One of: ${STATUSES.join(", ")}`,
+            "",
+            "The reply and the status change land as one entry, so the explanation",
+            "and the change can't be read out of order. The other side is emailed.",
+        ],
+        async run({ args, client }) {
+            const id = args.arg(0, "id");
+            const message = args.arg(1, "message");
+            const status = args.flag("status") ? assertStatus(args.flag("status")) : undefined;
+            const { report } = await client().request("POST", `/reports/${id}/comments`, { body: message, status });
+            emit({ report }, () => info(`✓ Replied on ${report.id}${status ? ` — now ${report.status}` : ""}`));
+        },
+    }, {
+        name: "reports status",
+        summary: "Set a report's status",
+        usage: "reports status <id> <status> [--note <message>]",
+        details: [
+            `  <status>  One of: ${STATUSES.join(", ")}`,
+            "  --note    A message to send with the change (recommended for done / declined)",
+        ],
+        async run({ args, client }) {
+            const id = args.arg(0, "id");
+            const status = assertStatus(args.arg(1, "status"));
+            const { report } = await client().request("POST", `/reports/${id}/comments`, { body: args.flag("note") ?? "", status });
+            emit({ report }, () => info(`✓ ${report.id} is now ${report.status}`));
+        },
+    }, {
+        name: "reports attach",
+        summary: "Attach a file to a report",
+        usage: "reports attach <id> <path>",
+        details: [
+            "Screenshots, logs, spreadsheets — anything that shows the problem.",
+            "Up to 10 MB each, 20 per report. It lands on the report itself; use the",
+            "web UI to attach a file to one particular reply.",
+        ],
+        async run({ args, client }) {
+            const id = args.arg(0, "id");
+            const filePath = args.arg(1, "path");
+            let bytes;
+            try {
+                bytes = readFileSync(filePath);
+            }
+            catch (error) {
+                throw new CliError(`Can't read ${filePath}: ${error instanceof Error ? error.message : String(error)}`, 4);
+            }
+            const file = await client().upload(`/reports/${id}/attachments`, basename(filePath), bytes);
+            emit({ attachment: file }, () => info(`✓ Attached ${file.name} (${humanSize(file.size)}) to ${id}`));
+        },
+    }, {
+        name: "reports download",
+        summary: "Download an attachment from a report",
+        usage: "reports download <id> <name|attachment-id> [--out <path>]",
+        async run({ args, client }) {
+            const c = client();
+            const id = args.arg(0, "id");
+            const { report } = await c.request("GET", `/reports/${id}`);
+            const file = findAttachment(report, args.arg(1, "name"));
+            const bytes = await c.download(`/reports/${id}/attachments/${file.id}`);
+            const out = args.flag("out") ?? file.name;
+            writeFileSync(out, bytes);
+            emit({ reportId: id, attachment: file.name, out, bytes: bytes.length }, () => info(`✓ Wrote ${out} (${humanSize(bytes.length)})`));
+        },
+    }, {
+        name: "reports file",
+        summary: "File a bug report or feature request",
+        usage: "reports file <app> <title> [--details <text>] [--request] [--attach <path>]",
+        details: [
+            "  <app>       The app it's about, or `coeconnect` for the portal itself",
+            "  --details   The body of the report (defaults to the title)",
+            "  --request   File it as a feature request rather than a bug",
+            "  --attach    A file to attach — a screenshot, a log excerpt",
+        ],
+        async run({ args, client }) {
+            const c = client();
+            const target = args.arg(0, "app");
+            const title = args.arg(1, "title");
+            const appId = await resolveTarget(c, target);
+            const { report } = await c.request("POST", "/reports", {
+                appId,
+                kind: args.bool("request") ? "idea" : "bug",
+                title,
+                body: args.flag("details") ?? title,
+            });
+            // Attached after the report exists, because that is what it hangs off.
+            // A failure here must not read as "the report wasn't filed" — it was.
+            const attach = args.flag("attach");
+            let attachment = null;
+            if (attach) {
+                try {
+                    attachment = await c.upload(`/reports/${report.id}/attachments`, basename(attach), readFileSync(attach));
+                }
+                catch (error) {
+                    info(`✓ Filed ${report.id} — ${report.title}`);
+                    throw new CliError(`The report was filed, but ${attach} did not attach: ` +
+                        (error instanceof Error ? error.message : String(error)), 1, `Try again with: coe reports attach ${report.id} ${attach}`);
+                }
+            }
+            emit({ report, attachment }, () => info(`✓ Filed ${report.id} — ${report.title}` +
+                (attachment ? ` (attached ${attachment.name})` : "")));
+        },
+    });
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { registerDeployCommands } from "./commands/deploy.js";
 import { registerEnvCommands } from "./commands/env.js";
 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 { registerVmCommands } from "./commands/vms.js";
 import { info, setJsonMode } from "./output.js";
@@ -20,6 +21,7 @@ registerEnvCommands();
 registerResourceCommands();
 registerLogCommands();
 registerVmCommands();
+registerReportCommands();
 function parseArgs(argv) {
     const positional = [];
     const flags = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uic-coe-connect/cli",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "The coe CLI — 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": {