@ixo/decision-oracle 0.0.0-stage → 0.2.1

package/dist/routes/v1/mcp/ui.js

@@ -0,0 +1,454 @@
+/**
+ * MCP Apps (the `io.modelcontextprotocol/ui` extension, stable 2026-01-26): the `ui://` views a
+ * host that supports the extension (claude.ai, Claude desktop, ChatGPT, VS Code) renders in a
+ * sandboxed iframe in place of a tool's raw JSON — the decision card (`submit_claim`,
+ * `get_decision`), the receipt badge (`verify_receipt`), the protocols (`list_protocols`) and the
+ * upload card (`upload_file`). A tool names its view in
+ * `_meta.ui.resourceUri`; the host reads the HTML with `resources/read` and hands the view the
+ * tool's result over its postMessage bridge.
+ *
+ * Nothing about a tool's answer changes: the view renders the SAME `structuredContent` every client
+ * gets, and a client without the extension ignores `_meta` (opaque by MCP's own rules) and reads the
+ * text as before. The spec asks a server to check the client's `extensions` capability before
+ * linking a view; this server is stateless (`index.ts`), so a `tools/list` never sees the
+ * `initialize` that carried it — linking always is the one answer that holds on every isolate.
+ *
+ * The views are self-contained: inline CSS and JS, no network (`csp` declares no domain, so the
+ * host's restrictive default holds), the DOM built with `textContent` only. The upload card is the
+ * one exception, and only to this oracle's own origin: it PUTs the file the user chose to the
+ * one-shot link `upload_file` returned — the bytes never pass through the model or the host. They show what the tool
+ * already returned and never the claim's answers (no tool returns them) or the record's `metadata`.
+ * The card's two buttons go through the host: "Verify receipt" is a `tools/call` of
+ * `verify_receipt`, and "Approve on IXO" a `ui/open-link` of the `approveUrl` AuthHub issued — the
+ * card never approves or pays anything itself; that stays on AuthHub, with the user.
+ */
+import { MAX_UPLOAD_BYTES } from "../../../contracts/index.js";
+import { UPAY_PER_CENT } from "../../../lib/payments/price.js";
+export const MCP_APP_MIME = "text/html;profile=mcp-app";
+export const DECISION_CARD_URI = "ui://eval-oracle/decision-card";
+export const RECEIPT_URI = "ui://eval-oracle/receipt";
+export const PROTOCOLS_URI = "ui://eval-oracle/protocols";
+export const UPLOAD_CARD_URI = "ui://eval-oracle/upload";
+/** A tool's link to its view. The flat key is the pre-GA spelling some hosts still read (the
+ *  extension's own `registerAppTool` sets both). */
+export const uiMeta = (resourceUri) => ({
+    ui: { resourceUri },
+    "ui/resourceUri": resourceUri,
+});
+/** No domain of any kind — the view needs nothing past its own document — save the oracle's own
+ *  for the upload card's PUT. It draws the console's own panel, so no host border. */
+const resourceUi = (connectDomains) => ({
+    csp: { connectDomains, resourceDomains: [] },
+    prefersBorder: false,
+});
+/**
+ * Register the views as resources (`resources/list`, `resources/read`). `authHubOrigin` is the one
+ * origin an approve link may open: a refusal's `approveUrl` pointing anywhere else gets no button.
+ * `oracleOrigin` is the one origin the upload card may send a file to.
+ */
+export function registerUi(server, authHubOrigin, oracleOrigin) {
+    for (const [name, uri, title, description, view] of [
+        [
+            "decision-card",
+            DECISION_CARD_URI,
+            "Decision card",
+            "A claim's verdict, checks, payment and receipt check — or the approval it waits for.",
+            "card",
+        ],
+        [
+            "receipt",
+            RECEIPT_URI,
+            "Receipt badge",
+            "Whether a decision receipt was signed by this oracle's decision engine.",
+            "receipt",
+        ],
+        [
+            "protocols",
+            PROTOCOLS_URI,
+            "Protocols",
+            "The protocols a claim can be submitted under, or one protocol's work order.",
+            "protocols",
+        ],
+        [
+            "upload",
+            UPLOAD_CARD_URI,
+            "Upload card",
+            "Choose a file for a claim; it is uploaded straight to this oracle through a one-shot link.",
+            "upload",
+        ],
+    ]) {
+        const html = page(title, view, authHubOrigin, oracleOrigin);
+        const ui = resourceUi(view === "upload" ? [oracleOrigin] : []);
+        server.registerResource(name, uri, { title, description, mimeType: MCP_APP_MIME, _meta: { ui } }, async () => ({
+            contents: [{ uri, mimeType: MCP_APP_MIME, text: html, _meta: { ui } }],
+        }));
+    }
+}
+const page = (title, view, authHubOrigin, oracleOrigin) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>${CSS}</style>
+</head>
+<body>
+<main id="root"><div class="panel"><p class="muted">Waiting for the result…</p></div></main>
+<script>const VIEW = "${view}"; const UPAY_PER_CENT = ${UPAY_PER_CENT}; const AUTH_HUB_ORIGIN = ${JSON.stringify(authHubOrigin)};
+${SCRIPT}${view === "upload" ? `const ORACLE_ORIGIN = ${JSON.stringify(oracleOrigin)}; const MAX_UPLOAD_BYTES = ${MAX_UPLOAD_BYTES};\n${UPLOAD_SCRIPT}` : ""}</script>
+</body>
+</html>`;
+// The Decision Console's look (ixoworld/eval-engine-dashboard `packages/ui/src/styles/`): the
+// Portal's `--ixo-*` defaults from `ixo-tokens.css` and the contrast-checked inks of
+// `app-tokens.css`, as values — a view loads nothing, so there is no token file to import. Light
+// and dark follow the host's `theme`, else the OS, as the console's `data-portal-theme` does.
+const CSS = `
+:root {
+  color-scheme: light dark;
+  --ixo-color-body: #fafafa; --ixo-color-surface: #f1f1f1; --ixo-color-surface-raised: #e4e4e4;
+  --ixo-color-border: #d7d7d7; --ixo-color-text: #222222;
+  --app-ink-2: rgba(34, 34, 34, .70); --ixo-tint-5: rgba(34, 34, 34, .05);
+  --ixo-tint-10: rgba(34, 34, 34, .10); --ixo-tint-82: rgba(34, 34, 34, .82);
+  --app-ink-success: #3e642d; --app-ink-warning: #7d5624; --app-ink-danger: #9f2232;
+  --app-ink-accent: #196676;
+  --app-tint-success: rgba(97, 180, 58, .12); --app-tint-warning: rgba(237, 149, 38, .12);
+  --app-tint-danger: rgba(226, 34, 59, .12);
+  --app-font: 'Inter Variable', Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  --app-font-mono: ui-monospace, 'SF Mono', SFMono-Regular, Menlo, Consolas, monospace;
+  --ixo-radius-md: 8px; --ixo-motion-fast: 120ms;
+}
+:root[data-theme="dark"] { color-scheme: dark; DARK }
+:root[data-theme="light"] { color-scheme: light; }
+@media (prefers-color-scheme: dark) { :root:not([data-theme]) { color-scheme: dark; DARK } }
+@media (prefers-reduced-motion: reduce) { * { transition-duration: .01ms !important; } }
+* { box-sizing: border-box; }
+body { margin: 0; padding: 0; background: transparent; color: var(--ixo-color-text);
+  font: 400 14px/1.5 var(--app-font); font-feature-settings: 'tnum', 'lnum'; }
+.panel { background: var(--ixo-color-surface); border: 1px solid var(--ixo-color-border);
+  border-radius: var(--ixo-radius-md); padding: 20px; }
+.head { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 10px 12px; margin-bottom: 16px; }
+h1 { margin: 0; font-size: 16px; font-weight: 500; line-height: 1.35; }
+.chip { display: inline-flex; align-items: center; gap: 4px; padding: 3px 10px; border-radius: 9999px;
+  font-size: 12px; font-weight: 500; letter-spacing: 0; white-space: nowrap; flex-shrink: 0;
+  background: var(--ixo-tint-10); color: var(--ixo-color-text); }
+.chip svg { width: 12px; height: 12px; }
+.green { background: var(--app-tint-success); color: var(--app-ink-success); }
+.red { background: var(--app-tint-danger); color: var(--app-ink-danger); }
+.muted { color: var(--app-ink-2); }
+.mono { font-family: var(--app-font-mono); font-size: 12px; overflow-wrap: anywhere; }
+.kv { display: flex; justify-content: space-between; align-items: baseline; gap: 12px; padding: 10px 0;
+  border-top: 1px solid var(--ixo-color-border); }
+.kv > :first-child { color: var(--app-ink-2); flex-shrink: 0; }
+.kv > .grow { flex-shrink: 1; min-width: 0; overflow-wrap: anywhere; text-align: left; }
+.kv > .grow + span { flex-shrink: 0; }
+.name { color: var(--ixo-color-text); }
+.kv > :last-child { min-width: 0; text-align: right; overflow-wrap: anywhere; }
+p { margin: 12px 0 0; }
+.notice { margin-top: 12px; padding: 12px 16px; border-radius: var(--ixo-radius-md); background: var(--app-tint-warning); }
+.notice b { font-weight: 500; color: var(--app-ink-warning); }
+.actions { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; margin-top: 16px; }
+button { font: 500 14px/1.5 var(--app-font); letter-spacing: .01em; padding: 6px 14px; border: 0; cursor: pointer;
+  border-radius: var(--ixo-radius-md); background: var(--ixo-tint-5); color: var(--ixo-color-text);
+  transition: background var(--ixo-motion-fast) ease-out; }
+button:hover { background: var(--ixo-tint-10); }
+button.primary { background: var(--ixo-color-text); color: var(--ixo-color-body); }
+button.primary:hover { background: var(--ixo-tint-82); }
+button:focus-visible { outline: 2px solid var(--app-ink-accent); outline-offset: 2px; }
+button:disabled { opacity: .6; cursor: default; }
+details { margin-top: 12px; }
+summary { cursor: pointer; color: var(--app-ink-2); }
+pre { margin: 6px 0 0; white-space: pre-wrap; }
+`.replace(/DARK/g, `--ixo-color-body: #050505; --ixo-color-surface: #171818; --ixo-color-surface-raised: #202020;
+  --ixo-color-border: #282828; --ixo-color-text: #dddddd;
+  --app-ink-2: rgba(221, 221, 221, .70); --ixo-tint-5: rgba(221, 221, 221, .05);
+  --ixo-tint-10: rgba(221, 221, 221, .10); --ixo-tint-82: rgba(221, 221, 221, .82);
+  --app-ink-success: #a5cb94; --app-ink-warning: #e4bd8b; --app-ink-danger: #e06374;
+  --app-ink-accent: #80ccdd;`);
+// The bridge is the spec's own "no SDK needed" JSON-RPC over postMessage: `ui/initialize`, then
+// `ui/notifications/initialized`, then the host's `ui/notifications/tool-result`. The words and
+// tones are the console's: `outcomeOf` (`packages/ui/src/lib/claim-status.ts`), `PaymentBadge`
+// (`apps/console/src/pages/claims/claimBadges.tsx`), `VerifyBadge` (`…/claims/ReceiptSection.tsx`).
+const SCRIPT = `
+const root = document.getElementById("root");
+let nextId = 0;
+const waiting = new Map();
+let caps = {};
+const send = (m) => window.parent.postMessage({ jsonrpc: "2.0", ...m }, "*");
+const request = (method, params) => new Promise((resolve, reject) => {
+  const id = ++nextId;
+  waiting.set(id, { resolve, reject });
+  send({ id, method, params });
+});
+
+window.addEventListener("message", (e) => {
+  const m = e.data;
+  if (e.source !== window.parent || !m || m.jsonrpc !== "2.0") return;
+  if (m.method === undefined && waiting.has(m.id)) {
+    const w = waiting.get(m.id);
+    waiting.delete(m.id);
+    if (m.error) w.reject(new Error(m.error.message || "refused")); else w.resolve(m.result);
+  } else if (m.method === "ui/notifications/tool-result") show(m.params);
+  else if (m.method === "ui/notifications/host-context-changed") theme(m.params);
+  else if (m.id !== undefined && (m.method === "ping" || m.method === "ui/resource-teardown")) send({ id: m.id, result: {} });
+  else if (m.id !== undefined && m.method) send({ id: m.id, error: { code: -32601, message: "Method not found" } });
+});
+
+function theme(ctx) {
+  if (ctx && (ctx.theme === "light" || ctx.theme === "dark")) document.documentElement.dataset.theme = ctx.theme;
+}
+
+let lastH = 0;
+new ResizeObserver(() => {
+  const html = document.documentElement;
+  const was = html.style.height;
+  html.style.height = "max-content";
+  const height = Math.ceil(html.getBoundingClientRect().height);
+  html.style.height = was;
+  if (height !== lastH) { lastH = height; send({ method: "ui/notifications/size-changed", params: { width: Math.ceil(window.innerWidth), height } }); }
+}).observe(document.body);
+
+request("ui/initialize", {
+  appInfo: { name: "ixo-" + VIEW, version: "1" },
+  appCapabilities: {},
+  protocolVersion: "2026-01-26",
+}).then((r) => {
+  caps = (r && r.hostCapabilities) || {};
+  theme(r && r.hostContext);
+  send({ method: "ui/notifications/initialized", params: {} });
+}, () => {});
+
+function h(tag, attrs, ...kids) {
+  const el = document.createElement(tag);
+  for (const [k, v] of Object.entries(attrs || {})) {
+    if (k === "onclick") el.onclick = v; else el.setAttribute(k, v);
+  }
+  for (const kid of kids.flat(Infinity)) if (kid !== null && kid !== undefined && kid !== false) el.append(kid);
+  return el;
+}
+const chip = (tone, label, icon) => h("span", { class: "chip " + tone }, icon ? shield(icon) : null, label);
+const head = (title, pill) => h("div", { class: "head" }, h("h1", {}, title), pill);
+const kv = (label, value, mono) => value === null || value === undefined || value === ""
+  ? null : h("div", { class: "kv" }, h("span", {}, label), h("span", mono ? { class: "mono" } : {}, value));
+const panel = (...kids) => h("div", { class: "panel" }, ...kids);
+const when = (iso) => (iso ? new Date(iso).toLocaleString() : null);
+const VERDICT = { approve: "Approved", partial: "Approved (partial)", reject: "Rejected", review: "Pending" };
+const https = (u) => { try { return new URL(u).protocol === "https:"; } catch { return false; } };
+const fromAuthHub = (u) => { try { return new URL(u).origin === AUTH_HUB_ORIGIN; } catch { return false; } };
+// A link only the host opens (ui/open-link); a host that cannot shows the URL to copy instead.
+const opener = (label, url, primary) => caps.openLinks
+  ? h("div", { class: "actions" }, h("button", primary ? { class: "primary", onclick: () => request("ui/open-link", { url }).catch(() => {}) }
+      : { onclick: () => request("ui/open-link", { url }).catch(() => {}) }, label))
+  : h("p", { class: "mono" }, url);
+
+// Tabler's outline shields (stroke 1.75), as the console's VerifyBadge draws them.
+const SHIELDS = {
+  check: ["M11.46 20.846a12 12 0 0 1 -7.96 -14.846a12 12 0 0 0 8.5 -3a12 12 0 0 0 8.5 3a12 12 0 0 1 -.09 7.06", "M15 19l2 2l4 -4"],
+  x: ["M13.252 20.601c-.408 .155 -.826 .288 -1.252 .399a12 12 0 0 1 -8.5 -15a12 12 0 0 0 8.5 -3a12 12 0 0 0 8.5 3a12 12 0 0 1 -.19 7.357", "M22 22l-5 -5", "M17 22l5 -5"],
+  question: ["M15.065 19.732c-.95 .557 -1.98 .986 -3.065 1.268a12 12 0 0 1 -8.5 -15a12 12 0 0 0 8.5 -3a12 12 0 0 0 8.5 3c.51 1.738 .617 3.55 .333 5.303", "M19 22v.01", "M19 19a2.003 2.003 0 0 0 .914 -3.782a1.98 1.98 0 0 0 -2.414 .483"],
+};
+function shield(kind) {
+  const ns = "http://www.w3.org/2000/svg";
+  const svg = document.createElementNS(ns, "svg");
+  for (const [k, v] of Object.entries({ viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "1.75",
+    "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" })) svg.setAttribute(k, v);
+  for (const d of SHIELDS[kind]) { const p = document.createElementNS(ns, "path"); p.setAttribute("d", d); svg.append(p); }
+  return svg;
+}
+
+// A refusal is the result's \`isError\`, never \`data.error\` alone: a failed claim's RECORD has its own \`error\`.
+function show(result) {
+  const data = (result && result.structuredContent) || {};
+  const refused = Boolean(result && result.isError);
+  root.replaceChildren(VIEW === "receipt" ? receipt(data, refused) : VIEW === "protocols" ? protocols(data, refused)
+    : VIEW === "upload" ? upload(data, refused) : card(data, refused));
+}
+
+function refusal(title, err) {
+  return panel(head(title, chip("red", err.code || "Error")), h("p", {}, err.message || ""),
+    // A card that wants 3-D Secure: the bank's page, which the person confirms on.
+    https(err.confirmUrl) ? opener("Confirm with your bank", err.confirmUrl, true) : null);
+}
+
+// --- the receipt badge ----------------------------------------------------------------------
+function verifyBadge(data) {
+  return data.valid ? chip("green", "Signature verified", "check") : chip("red", "Signature not verified", "x");
+}
+function receipt(data, refused) {
+  if (refused) return refusal("The signed receipt", data.error);
+  return panel(
+    head("The signed receipt", verifyBadge(data)),
+    data.valid
+      ? [kv("Signed by", data.issuer, true), kv("Claim", data.claimId, true), kv("Verdict", VERDICT[data.verdict] || data.verdict), kv("Evaluated", when(data.evaluatedAt))]
+      : h("p", {}, data.message || data.reason || "The signature did not verify."),
+    h("details", {}, h("summary", {}, "Raw details"), h("pre", { class: "mono" }, JSON.stringify(data, null, 2))),
+  );
+}
+
+// --- the decision card ----------------------------------------------------------------------
+function verdictChip(rec) {
+  const d = rec.decision;
+  if (rec.status === "failed") return chip("red", "Failed");
+  if (!d) return chip("", "Not decided");
+  if (d.status === "unusable" || d.status === "invalid_facts") return chip("", "Invalid");
+  if (d.status === "pending_review") return chip("", "Pending");
+  return { approve: chip("green", "Approved"), partial: chip("green", "Approved (partial)"), reject: chip("red", "Rejected"),
+    review: chip("", "Pending") }[d.verdict] || chip("", "Decided");
+}
+const PAID = { reserved: "Reserved", settled: "Settled", paid: "Paid", released: "Released", failed: "Payment failed",
+  refunded: "Refunded", partially_refunded: "Partially refunded" };
+function price(p) {
+  const cents = p.asset === "usd" ? Number(p.amount) : Math.floor(Number(p.amount) / UPAY_PER_CENT);
+  return "$" + (cents / 100).toFixed(2) + " · " + (p.scheme === "stripe-manual-capture" ? "card" : "PAY") + " · " + (PAID[p.status] || p.status);
+}
+const OUTCOME = { passed: ["green", "Passed"], failed: ["red", "Failed"], skipped: ["", "Skipped"],
+  unevaluated: ["", "Not evaluated"], not_reached: ["", "Not reached"] };
+
+function card(data, refused) {
+  // Waiting on the user is a normal result (\`tools.ts\` \`approvalAsk\`); the refusal shape before 1.4.8 still renders.
+  if (data.status === "approval_required" && data.error) return approval(data.error);
+  if (refused) { const err = data.error || {}; return err.approveUrl ? approval(err) : refusal("Not submitted", err); }
+  const engine = (data.decision && data.decision.decision) || {};
+  const checks = [
+    ...(engine.gates || []).map((g) => { const [t, w] = OUTCOME[g.outcome] || ["", g.outcome];
+      return h("div", { class: "kv" }, h("span", { class: "mono" }, g.code), chip(t, w)); }),
+    ...(engine.criteria || []).map((c) => kv(c.code, c.pending ? "Pending" : c.scoreBps === null ? "—" : (c.scoreBps / 100).toFixed(0) + "%")),
+  ];
+  const out = h("div", {});
+  const verify = data.decision && data.decision.receipt && caps.serverTools
+    ? h("div", { class: "actions" }, h("button", { onclick: (e) => {
+        const btn = e.currentTarget;
+        btn.disabled = true;
+        out.replaceChildren(h("div", { class: "actions" }, chip("", "Checking signature…", "question")));
+        request("tools/call", { name: "verify_receipt", arguments: { claimId: data.claimId } }).then(
+          (r) => { const v = (r && r.structuredContent) || {};
+            out.replaceChildren(h("div", { class: "actions" }, r && r.isError ? chip("", "Not checked", "question") : verifyBadge(v),
+              v.valid ? null : h("span", { class: "muted" }, (v.error || v).message || ""))); },
+          () => out.replaceChildren(h("div", { class: "actions" }, chip("", "Not checked", "question"))),
+        ).finally(() => { btn.disabled = false; });
+      } }, "Verify receipt"))
+    : null;
+  return panel(
+    head("Claim decision", verdictChip(data)),
+    kv("Claim", data.claimId, true),
+    data.payment ? kv("Price", price(data.payment)) : null,
+    data.autoApproved ? kv("Auto-approve left", data.autoApproveRemaining) : null,
+    checks,
+    (engine.reasons || []).map((r) => h("p", { class: "muted" }, r.reason)),
+    data.error ? h("p", {}, data.error.message) : null,
+    data.note ? h("p", { class: "muted" }, data.note) : null,
+    data.decision || data.status === "failed" ? null : h("p", { class: "muted" }, "The decision is not ready yet. Ask for it again in a moment."),
+    verify, out,
+  );
+}
+
+// Waiting for the user's approval: the price and AuthHub's link, opened by the host — never acted on here.
+function approval(err) {
+  const lead = { APPROVAL_PENDING: "Still waiting for your approval.", APPROVAL_STALE: "The price changed, so approve it again." }[err.code]
+    || "This claim needs your approval.";
+  const link = fromAuthHub(err.approveUrl) ? err.approveUrl : null;
+  return panel(
+    head("Claim decision", chip("", "Not submitted")),
+    kv("Price", err.price),
+    kv("Link expires", when(err.expiresAt)),
+    h("div", { class: "notice" }, h("b", {}, lead), " Nothing is submitted or charged until you approve it on IXO. Then ask to submit it again."),
+    link ? opener("Approve on IXO", link, true) : null,
+  );
+}
+
+// --- the protocols (list_protocols) ---------------------------------------------------------
+const dollars = (p) => (p ? "$" + (p.amountCents / 100).toFixed(2) : "No charge");
+const short = (t) => (t && t.length > 90 ? t.slice(0, 89) + "…" : t);
+function protocols(data, refused) {
+  if (refused) return refusal("Protocols", data.error || {});
+  if (Array.isArray(data.items)) {
+    return panel(
+      head("Protocols", chip("", data.items.length + (data.items.length === 1 ? " protocol" : " protocols"))),
+      data.items.length ? null : h("p", { class: "muted" }, "No protocol is open to this source."),
+      data.items.map((p) => h("div", { class: "kv" },
+        h("span", { class: "grow" }, h("div", { class: "name" }, p.name || "Unnamed protocol"), h("div", { class: "mono" }, p.protocolDid)),
+        h("span", {}, dollars(p.price)))),
+    );
+  }
+  // One protocol's work order: what a claim must carry. Never the facts' endpoints (the route serves names only).
+  const schema = data.answers || {};
+  const required = new Set(schema.required || []);
+  const fields = Object.entries(schema.properties || {}).map(([key, f]) => {
+    const type = Array.isArray(f.type) ? f.type.join(" | ") : f.type || (f.enum ? "one of " + f.enum.join(", ") : "value");
+    return h("div", { class: "kv" },
+      h("span", { class: "grow" }, h("div", { class: "name" }, f.title || key), short(f.description) ? h("div", {}, short(f.description)) : null),
+      h("span", {}, type + " · ", required.has(key) ? chip("", "Required") : h("span", { class: "muted" }, "optional")));
+  });
+  const files = (data.files || []).map((q) => {
+    const kinds = q.mediaTypes && q.mediaTypes.length ? q.mediaTypes.join(", ") : "any file";
+    return h("div", { class: "kv" },
+      h("span", { class: "grow" }, h("div", { class: "name" }, q.question), h("div", {}, "Link to " + kinds + ", up to " + Math.round(q.maxBytes / 1048576) + " MB")),
+      h("span", {}, q.required ? chip("", "Required") : h("span", { class: "muted" }, "optional")));
+  });
+  return panel(
+    head(data.name || "Protocol", chip("", dollars(data.price))),
+    h("div", { class: "mono muted" }, data.protocolDid || ""),
+    fields.length ? [h("p", { class: "muted" }, "Answers"), fields] : null,
+    files.length ? [h("p", { class: "muted" }, "Files (an https link each)"), files] : null,
+    data.facts && data.facts.frequency ? h("p", { class: "muted" }, "Needs a submitter: your stable id for the person the claim is about.") : null,
+  );
+}
+`;
+// The upload card (upload_file) — the one view with a network call, and only for its own page: the
+// file the user chose goes straight to the one-shot link on this oracle's origin (the csp's one
+// connect domain), never through the host or the model. It tells the user what happened in plain
+// words; the model already holds the uploadId, so nothing is sent back to it.
+const UPLOAD_SCRIPT = `
+const size = (n) => n < 1024 ? n + " B" : n < 1048576 ? (n / 1024).toFixed(0) + " KB" : (n / 1048576).toFixed(1) + " MB";
+const shortCid = (c) => (c && c.length > 20 ? c.slice(0, 10) + "…" + c.slice(-6) : c);
+const fromOracle = (u) => { try { return new URL(u).origin === ORACLE_ORIGIN; } catch { return false; } };
+const UPLOAD_REFUSED = { 403: "This link expired — ask the assistant for a new one.", 409: "Already uploaded.",
+  413: "Larger than 25 MB. Choose a smaller file." };
+function upload(data, refused) {
+  if (refused) return refusal("Upload a file", data.error || {});
+  const pill = h("span", {}, chip("", "Waiting for a file"));
+  const status = h("div", {});
+  const input = h("input", { type: "file", hidden: "" });
+  const pick = h("button", { class: "primary", onclick: () => input.click() }, "Choose file");
+  const say = (tone, label, ...kids) => { pill.replaceChildren(chip(tone, label)); status.replaceChildren(...kids); };
+  const done = () => pick.remove();
+  const expired = () => data.expiresAt && Date.now() > new Date(data.expiresAt).getTime();
+  input.onchange = async () => {
+    const file = input.files && input.files[0];
+    input.value = "";
+    if (!file) return;
+    if (file.size > MAX_UPLOAD_BYTES) return say("red", "Too large", h("p", {}, UPLOAD_REFUSED[413]));
+    if (expired()) { done(); return say("red", "Expired", h("p", {}, UPLOAD_REFUSED[403])); }
+    pick.disabled = true;
+    say("", "Uploading…", h("p", { class: "muted" }, "Uploading " + file.name + " (" + size(file.size) + ")…"));
+    try {
+      const res = await fetch(data.uploadUrl, { method: "PUT", body: file,
+        headers: { "content-type": file.type || "application/octet-stream" } });
+      if (res.ok) {
+        const up = await res.json().catch(() => ({}));
+        done();
+        return say("green", "Uploaded",
+          kv("File", file.name), kv("Size", size(up.size || file.size)), kv("Type", up.mediaType || file.type || null),
+          up.cid ? h("div", { class: "kv" }, h("span", {}, "CID"), h("span", { class: "mono", title: up.cid }, shortCid(up.cid))) : null,
+          h("p", { class: "muted" }, "Uploaded. Tell the assistant, and it can submit the claim."));
+      }
+      if (res.status === 403 || res.status === 409) done();
+      say("red", res.status === 409 ? "Already uploaded" : "Not uploaded",
+        h("p", {}, UPLOAD_REFUSED[res.status] || "The upload failed (HTTP " + res.status + "). Try again, or ask the assistant for a new link."));
+    } catch {
+      say("red", "Not uploaded", h("p", {}, "The upload could not reach the oracle. Check the connection and try again."));
+    } finally {
+      pick.disabled = false;
+    }
+  };
+  const usable = fromOracle(data.uploadUrl);
+  return panel(
+    head("Upload a file", pill),
+    usable ? null : h("p", {}, "This upload link is not this oracle's, so the card will not send a file to it."),
+    kv("Expires", when(data.expiresAt)),
+    h("p", { class: "muted" }, "One file, up to 25 MB. It is sent straight to the oracle; the link works once."),
+    status,
+    usable ? h("div", { class: "actions" }, pick, input) : null,
+  );
+}
+`;
+//# sourceMappingURL=ui.js.map

package/dist/routes/v1/mcp/ui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.js","sourceRoot":"","sources":["../../../../src/routes/v1/mcp/ui.ts"],"names":[],"mappings":"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"}

package/dist/routes/v1/oauth.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The approvals back-channel (MCP over OAuth, spec 2026-10-06; AuthHub plan Task 9; S3 review §3,
+ * §6) — AuthHub's approve page reads an approval from HERE and posts the user's answer back:
+ *
+ *   GET  /v1/oauth/approvals/:approvalId   `oauth/approval/read`     what the page shows
+ *   POST /v1/oauth/approvals/:approvalId   `oauth/approval/approve`  approve (+ delegation) | decline
+ *   GET | PUT | DELETE /v1/oauth/standing/:grantId   `oauth/standing/read | set | revoke`
+ *                                          a grant's auto-approve (standing.ts) — set only where
+ *                                          `policies.allowStandingApprovals` (D8), else 403
+ *
+ * The invoker must BE AuthHub's `did:web` (`AUTH_HUB_URL`): a UCAN from anyone else is 403 even
+ * with the right action, and the legacy `*` is never accepted here (`middleware/capability.ts`
+ * `STRICT_ACTIONS`). Anything but a known, pending, unexpired approval is 404 — AuthHub binds the
+ * row's `did` and `grantId` to its signed-in user; the oracle binds the delegation to the row.
+ *
+ * The delegation is a bearer credential: it is validated, stored, and never logged or returned —
+ * the GET has no field that could carry it.
+ *
+ * Accepted risk (S3 review L2): the chain lane keeps no replay store, so a leaked
+ * `oauth/approval/approve` invocation can be replayed within its life (≤ 600 s; AuthHub signs 120 s).
+ * All it can do is DECLINE a pending approval it already knows the id of — approving needs a payment
+ * delegation the user's own key signed, for exactly this approval's price, this oracle and our
+ * facilitator, which the token does not carry. A wrongly declined approval costs the user one
+ * re-approval, never money.
+ */
+import { Hono } from "hono";
+import type { AppEnv } from "../../context.js";
+export declare const oauth: Hono<AppEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=oauth.d.ts.map

package/dist/routes/v1/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/oauth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAgB,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AA6B5C,eAAO,MAAM,KAAK,qDAAqB,CAAC"}