@tokenoftrust/cli 1.4.0-rc.13 → 1.4.0-rc.15

package/src/commands/pr.mjs

@@ -16,12 +16,22 @@
  * checkout's origin remote, exactly as `tot submit` does) and reads over the MCP
  * `candidate_status` / `candidate_close` tools. Dependency-free (global fetch +
  * `git`).
+ *
+ * OPERATOR MODE (unit U17). `tot pr list --tenant <t>` lists a tenant's OPEN
+ * candidate queue WITHOUT a checkout — the read-only companion to `tot ship --pr <N>
+ * --tenant <t>` (U16). It reuses U16's exact transport: the SAME `GET /api/changes`
+ * HTTP endpoint + operator-secret Bearer auth (`resolveOperatorSecret`,
+ * `normalizeChangesQueue` from ship.mjs). `view`/`close` stay developer-only.
  */
 import { execFileSync } from "node:child_process";
 import { createMcpClient } from "../mcp.mjs";
 import { establishSession, AuthUnavailableError } from "../auth.mjs";
 import { fail } from "../errors.mjs";
 import { repoNameFromRemote, currentBranch } from "./submit.mjs";
+// U17 reuses U16's operator-secret transport helpers verbatim (same env precedence,
+// same queue normalisation) so the operator `tot pr list` and `tot ship --pr` speak
+// one wire, not two.
+import { resolveOperatorSecret, normalizeChangesQueue } from "./ship.mjs";
 import {
   defaultCandidateStatePath,
   readActiveChangeId,
@@ -29,29 +39,55 @@ import {
 } from "../candidate-state.mjs";
 
 const DEFAULT_MCP_URL = "https://mcp.tokenoftrust.com";
+const DEFAULT_STOREFRONT_URL = "https://storefront.tokenoftrust.store";
 const SUBCOMMANDS = ["list", "view", "close"];
 
-const USAGE = `tot pr — see and manage your candidate PRs
+const USAGE = `tot pr — see and manage candidate PRs
 
   tot pr [list]              list your open candidate PRs for this store
+  tot pr list --tenant <t>   OPERATOR: list a tenant's open candidate PRs (no checkout)
   tot pr view <N|id>         show one candidate PR (by PR number or changeId)
   tot pr close <N|id>        close (reject) a candidate PR without merging
   tot pr close <N|id> --reason "<why>"   record why it was closed (audit note)
   tot pr --mcp <url>         MCP base URL (default: env MCP_BASE_URL / TOT_MCP_URL)
 
-  A candidate PR is what \`tot submit\` opens for review. A re-submit updates your
-  open one by default; \`tot submit --new\` forks another. Use these to see and
-  manage them.`;
+  DEVELOPER (default) — run inside your OWN store checkout: lists/manages the
+  candidates \`tot submit\` opens. A re-submit updates your open one by default;
+  \`tot submit --new\` forks another.
+
+  OPERATOR — \`tot pr list --tenant <appDomain>\` lists ANY tenant's open candidate
+  queue WITHOUT a checkout (the read-only companion to \`tot ship --pr <N> --tenant\`).
+  It reads \`GET /api/changes\` with an operator secret:
+
+    tot pr list --tenant <t>   list <t>'s open candidate PRs
+    tot pr list --url <origin> storefront origin (default: env TOT_STOREFRONT_URL)
+    tot pr list --secret <s>   operator secret (prefer the env vars below)
+
+  Operator secret (from env, first found): PREVIEW_RECONCILE_SECRET,
+  GRANTS_ADMIN_SECRET, TOT_OPERATOR_SECRET (or pass --secret).`;
 
-/** Parse `tot pr` argv into { sub, target, reason, mcp, identity, help }. Pure. */
+/** Parse `tot pr` argv into { sub, target, reason, mcp, identity, tenant, url, secret, help }. Pure. */
 export function parsePrArgs(argv) {
-  const a = { sub: null, target: null, reason: null, mcp: null, identity: null, help: false };
+  const a = {
+    sub: null,
+    target: null,
+    reason: null,
+    mcp: null,
+    identity: null,
+    tenant: null,
+    url: null,
+    secret: null,
+    help: false,
+  };
   const positional = [];
   for (let i = 0; i < argv.length; i++) {
     const t = argv[i];
     if (t === "--mcp") a.mcp = argv[++i];
     else if (t === "--identity") a.identity = argv[++i];
     else if (t === "--reason") a.reason = argv[++i];
+    else if (t === "--tenant") a.tenant = argv[++i];
+    else if (t === "--url") a.url = argv[++i];
+    else if (t === "--secret") a.secret = argv[++i];
     else if (t === "--help" || t === "-h") a.help = true;
     else positional.push(t);
   }
@@ -98,6 +134,132 @@ export function formatCandidateLine(c, { active = false } = {}) {
   return `  PR ${pr}  ${branch}  ${c.changeId}  [${c.state ?? "?"}]${urlPart}${activePart}`;
 }
 
+// ─── Operator queue listing (unit U17) ──────────────────────────────────────────────
+//
+// The read-only companion to `tot ship --pr <N> --tenant <t>` (U16): list a tenant's
+// OPEN candidate queue WITHOUT a checkout. It reuses U16's exact transport — the SAME
+// `GET /api/changes` endpoint (operator accept queue) + Bearer operator-secret auth
+// (`resolveOperatorSecret` / `normalizeChangesQueue` from ship.mjs) — so a listing and
+// a ship read one wire. NO merge/deploy/side-effect; pure listing.
+
+/**
+ * One-line summary of an OPEN operator-queue candidate for `tot pr list --tenant`.
+ * Two shapes come off `GET /api/changes`:
+ *   - BUILT candidate (`built:true`, has a `changeId`): PR # / status / changeId /
+ *     short head sha / preview URL — the fields an operator needs to pick a PR to ship.
+ *   - NOT-BUILT forge PR (`built:false` / `changeId:null` / `status:"not-built"`): an
+ *     open PR with no preview yet. Render it DISTINCTLY — no changeId (there is none),
+ *     a `[not built]` tag, and a build HINT instead of a preview URL — so an operator
+ *     sees it's listable but must `tot preview build` before it can ship.
+ * Adapts `formatCandidateLine`'s house style to the `GET /api/changes` shape (`status`
+ * not `state`; `previewUrl`; a `headSha` to short-render). Pure — unit-tested.
+ * @param {{prNumber?:number|null, status?:string|null, changeId?:string|null,
+ *   headSha?:string|null, previewUrl?:string|null, built?:boolean}} c
+ * @returns {string}
+ */
+export function formatOperatorCandidateLine(c) {
+  const pr = typeof c.prNumber === "number" ? `#${c.prNumber}` : "#—";
+  const head = c.headSha ? c.headSha.slice(0, 8) : "(no head)";
+  // A not-built PR: no changeId, so route the operator to build it first.
+  const notBuilt = c.built === false || (!c.changeId && c.status === "not-built");
+  if (notBuilt) {
+    const hint =
+      typeof c.prNumber === "number"
+        ? `  → tot preview build --pr ${c.prNumber}`
+        : "  → tot preview build";
+    return `  PR ${pr}  [not built]  ${head}${hint}`;
+  }
+  const status = c.status ?? "?";
+  const urlPart = c.previewUrl ? `  ${c.previewUrl}` : "";
+  return `  PR ${pr}  [${status}]  ${c.changeId}  ${head}${urlPart}`;
+}
+
+/**
+ * Sort an OPEN candidate queue by PR number DESC (newest PR first); candidates
+ * without a PR number sort last, then stably by changeId. Pure — unit-tested.
+ * @param {ReturnType<typeof normalizeChangesQueue>} changes
+ */
+export function sortQueueByPrDesc(changes) {
+  return [...(changes || [])].sort((a, b) => {
+    const ap = typeof a.prNumber === "number" ? a.prNumber : -Infinity;
+    const bp = typeof b.prNumber === "number" ? b.prNumber : -Infinity;
+    if (ap !== bp) return bp - ap;
+    return String(a.changeId).localeCompare(String(b.changeId));
+  });
+}
+
+/**
+ * The OPERATOR `tot pr list --tenant <t>` flow: fetch the tenant's OPEN candidate
+ * queue over `GET /api/changes` (Bearer operator secret + `X-Tot-Owner` +
+ * `x-tot-capability: ship-on-behalf`, mirroring U16) and print each candidate one per
+ * line, sorted by PR number desc. Fail-closed: no secret → honest refusal (exit 2)
+ * BEFORE any network. `fetch` is injected so it's unit-tested with no live network.
+ *
+ * @param {{ tenant:string, secret:string, storefrontUrl?:string|null }} params
+ * @param {{ fetch?:typeof fetch }} [deps]
+ * @returns {Promise<number>} process exit code
+ */
+export async function runPrListOperator({ tenant, secret, storefrontUrl = null }, deps = {}) {
+  const fetchImpl = deps.fetch || globalThis.fetch;
+  const base = (storefrontUrl || DEFAULT_STOREFRONT_URL).trim().replace(/\/+$/, "");
+
+  if (!secret) {
+    console.error(
+      fail(
+        "listing a tenant's queue is an OPERATOR action — it needs an operator secret",
+        "set PREVIEW_RECONCILE_SECRET (or GRANTS_ADMIN_SECRET / TOT_OPERATOR_SECRET), or pass --secret",
+      ),
+    );
+    return 2;
+  }
+
+  const authHeaders = {
+    authorization: `Bearer ${secret}`,
+    "x-tot-owner": tenant,
+    "x-tot-capability": "ship-on-behalf",
+  };
+
+  let res;
+  try {
+    res = await fetchImpl(`${base}/api/changes`, { method: "GET", headers: authHeaders });
+  } catch (e) {
+    console.error(
+      fail(`couldn't reach the candidate queue at ${base}: ${String(e?.message || e)}`, "check --url / your network, then re-run"),
+    );
+    return 1;
+  }
+
+  let data = {};
+  try {
+    data = await res.json();
+  } catch {
+    /* non-JSON / empty body */
+  }
+  if (!res.ok) {
+    const msg = data?.error || `HTTP ${res.status}`;
+    console.error(
+      fail(
+        `the candidate queue refused the request: ${msg}`,
+        res.status === 401 || res.status === 403
+          ? "check the operator secret and that it's authorised for this tenant"
+          : "check --tenant / --url, then re-run",
+      ),
+    );
+    return 1;
+  }
+
+  const changes = sortQueueByPrDesc(normalizeChangesQueue(data));
+  if (!changes.length) {
+    console.log(`No open candidate PRs for ${tenant}.`);
+    return 0;
+  }
+  console.log(`Open PRs for ${tenant}:`);
+  for (const c of changes) {
+    console.log(formatOperatorCandidateLine(c));
+  }
+  return 0;
+}
+
 /** @param {string[]} argv @param {any} ctx */
 export async function run(argv, ctx) {
   const env = process.env;
@@ -110,9 +272,34 @@ export async function run(argv, ctx) {
     console.error(fail(`unknown subcommand: \`tot pr ${args.sub}\``, "tot pr list | view <N> | close <N>"));
     return 2;
   }
+
+  // OPERATOR MODE (U17): `--tenant <t>` lists that tenant's OPEN candidate queue with
+  // NO checkout, over the same HTTP transport `tot ship --pr` uses. Only `list` has an
+  // operator path today — `view`/`close` stay developer-only (checkout-bound).
+  if (args.tenant && `${args.tenant}`.trim()) {
+    if (args.sub !== "list") {
+      console.error(
+        fail(
+          `\`tot pr ${args.sub} --tenant\` isn't wired — only \`tot pr list --tenant\` has an operator path`,
+          "use `tot pr list --tenant <t>` to list, then act from a checkout",
+        ),
+      );
+      return 2;
+    }
+    const storefrontUrl = args.url || env.TOT_STOREFRONT_URL || env.STOREFRONT_BASE_URL || DEFAULT_STOREFRONT_URL;
+    return await runPrListOperator({
+      tenant: `${args.tenant}`.trim(),
+      secret: resolveOperatorSecret(args.secret, env),
+      storefrontUrl,
+    });
+  }
+
   if (ctx.mode !== "checkout") {
     console.error(
-      fail("`tot pr` runs from inside a tenant checkout", "tot clone <tenant> <dir>   (then `cd` in and re-run)"),
+      fail(
+        "`tot pr` runs from inside a tenant checkout",
+        "tot clone <tenant> <dir>   (then `cd` in and re-run), or `tot pr list --tenant <t>` for operator mode",
+      ),
     );
     return 2;
   }