@azure-id/orc 0.55.0

package/bin/webui/js/99-boot.js

@@ -0,0 +1,118 @@
+"use strict";
+/* 99-boot.js — orc ui client
+   MUST LOAD LAST. `boot()` is the one load-time call in the panel, and it reads
+   bindings from every file above — a classic-script `const` is in TDZ until its
+   own file has been evaluated.
+
+   Loaded by app.html in the order its numeric prefix names. Classic
+   script, no import/export: an ES module import carries no query string,
+   and every static request here needs the per-launch session token. */
+
+
+/* ================================================================= startup == */
+
+async function boot() {
+  // Language first, and English is loaded UNCONDITIONALLY: it is the fallback
+  // table every other language falls back to, so it must exist before the first
+  // t() call regardless of which language is selected. If even English cannot be
+  // fetched, t() returns the key and the page is ugly but functional — never
+  // blank, and never blocked on a file.
+  try {
+    DICT_EN = await loadLang("en");
+  } catch (_) {
+    DICT_EN = {};
+  }
+  let savedLang = "en";
+  try {
+    savedLang = localStorage.getItem(LANG_KEY) || "en";
+  } catch (_) {}
+  // No rerender: nothing has been routed yet, and route() is called below.
+  await setLang(savedLang, { rerender: false });
+
+  // Meta next: it names the project in the rail and tells us whether we are
+  // looking at fixtures, which must never be mistaken for a real install.
+  try {
+    const meta = await api("/api/meta");
+    metaInfo = meta;
+    const proj = $("#rail-project");
+    proj.textContent = meta.fixtures ? t("rail.fixtures") : meta.project_root || "";
+    proj.title = meta.project_root || "";
+    $("#rail-version").textContent = (meta.fixtures ? "fixtures · " : "") + "v" + (meta.version || "?");
+
+    // A newer release is worth ONE quiet dot in the rail, on every panel — not a
+    // banner, not a modal. It links to the panel that can actually install it;
+    // it never installs anything itself.
+    versionInfo()
+      .then((v) => {
+        if (!v || !v.update_available) return;
+        const link = el("a", "rail-update", "");
+        link.href = "#/maintenance";
+        link.append(el("span", "dot dot-warn"), document.createTextNode(`v${v.latest} available`));
+        link.title = `You have ${v.version}. Maintenance → upgrade installs ${v.latest}.`;
+        $("#rail-version").after(link);
+      })
+      .catch(() => {});
+    if (meta.fixtures) {
+      const b = el("div", "banner");
+      b.append(el("div", null, t("banner.fixtures")));
+      $("#banners").append(b);
+    }
+  } catch (_) {
+    document.body.replaceChildren(
+      (() => {
+        const e2 = el("div", "empty", t("banner.noToken"));
+        e2.append(el("div", "note", t("banner.noTokenHint")));
+        return e2;
+      })()
+    );
+    return;
+  }
+
+  // Theme: dark-first, remembered, and both painted explicitly.
+  const saved = localStorage.getItem("orc-ui-theme");
+  if (saved) document.documentElement.setAttribute("data-theme", saved);
+  const tt = $("#theme-toggle");
+  const syncTheme = () => (tt.textContent = document.documentElement.getAttribute("data-theme") === "light" ? t("rail.dark") : t("rail.light"));
+  syncTheme();
+  tt.addEventListener("click", () => {
+    const next = document.documentElement.getAttribute("data-theme") === "light" ? "dark" : "light";
+    document.documentElement.setAttribute("data-theme", next);
+    localStorage.setItem("orc-ui-theme", next);
+    syncTheme();
+  });
+
+  // Language, right below it in the rail: the same class of control (a
+  // per-browser display preference), so it lives in the same place and is
+  // remembered the same way. It never touches project config.
+  const lb = $("#lang-toggle");
+  if (lb) lb.addEventListener("click", cycleLang);
+  applyStaticText();
+
+  installShortcuts();
+  const help = $("#shortcut-hint");
+  if (help) help.addEventListener("click", showShortcuts);
+
+  window.addEventListener("hashchange", route);
+  route();
+
+  // First run for THIS project → the tour. Fixture mode is excluded: a tour of
+  // canned data would teach the panel using numbers that are not real.
+  if (!metaInfo.fixtures && !tourSeen(metaInfo.project_root)) {
+    // Let the first panel finish its fetch, so step one has something to point
+    // at rather than a skeleton.
+    setTimeout(() => startFirstRunTour(metaInfo.project_root), 600);
+  }
+
+  // Heartbeat: no ping from any client for 60s and the server exits, so closing
+  // this tab shuts down a write surface instead of leaving it holding a token.
+  const ping = () => api("/api/ping").catch(() => {});
+  ping();
+  setInterval(ping, 15000);
+  window.addEventListener("beforeunload", () => {
+    try {
+      navigator.sendBeacon("/api/bye?t=" + encodeURIComponent(TOKEN));
+    } catch (_) {}
+  });
+}
+
+boot();

package/bin/webui/js/panels/boundary.js

@@ -0,0 +1,104 @@
+"use strict";
+/* panels/boundary.js — orc ui client
+   EXECUTE/ESCALATE/REFUSE. A REFUSE always renders the checklist that would
+   make it a yes.
+
+   Loaded by app.html in the order its numeric prefix names. Classic
+   script, no import/export: an ES module import carries no query string,
+   and every static request here needs the per-launch session token. */
+
+
+/* ------------------------------------------------------------------ BOUNDARY */
+
+const VERDICT_KIND = { EXECUTE: "ok", ESCALATE: "warn", REFUSE: "bad" };
+
+PANELS.boundary = function (host) {
+  head(host, t("boundary.title"), t("boundary.sub"));
+  section(
+    host,
+    () => read("/api/boundary").then((r) => r.data),
+    (d) => {
+      const out = frag();
+      if (!d || !d.cards || !d.cards.length) {
+        const c = card(t("boundary.title"));
+        c.append(empty(t("boundary.none"), t("boundary.noneHint")));
+        c.append(laneCommand("/orc-boundary", t("boundary.cmdWhy")));
+        out.append(c);
+        return out;
+      }
+
+      const sum = card(t("boundary.summary"));
+      const chips = el("div", "row-actions");
+      for (const v of ["EXECUTE", "ESCALATE", "REFUSE"])
+        chips.append(chip(`${(d.counts || {})[v] || 0} ${v}`, VERDICT_KIND[v], v === "REFUSE" && d.counts.REFUSE));
+      if (d.stale) chips.append(chip(tn(d.stale, "boundary.staleChip"), "warn"));
+      sum.append(chips);
+      sum.append(el("div", "note", t("boundary.gatesOrc")));
+      out.append(sum);
+
+      for (const c of d.cards) {
+        const cc = card(null);
+        const headRow = el("div", "row-actions");
+        // The CLI's exact word, never a friendlier synonym.
+        headRow.append(chip(c.verdict || "MALFORMED", c.verdict ? VERDICT_KIND[c.verdict] : "bad"));
+        headRow.append(el("span", "mono", c.area));
+        if (c.stale) headRow.append(chip(t("boundary.stale"), "warn"));
+        cc.append(headRow);
+
+        for (const r of c.reasons || []) cc.append(el("div", "note", r));
+
+        // THE CHECKLIST IS THE PRODUCT. A REFUSE with none is malformed in the
+        // lane, so this renders an ERROR — never an empty card that reads as a
+        // flat no.
+        if (c.verdict === "REFUSE") {
+          if (!c.checklist || !c.checklist.length) {
+            cc.append(el("div", "note bad", t("boundary.malformedNoChecklist")));
+          } else {
+            const box = el("div", "checklist");
+            box.append(el("div", "checklist-head", t("boundary.wouldMakeYes")));
+            for (const item of c.checklist) {
+              const row = el("div", "checklist-row");
+              row.append(el("span", "checklist-box", "□"));
+              row.append(el("span", null, item));
+              // A caution routes to the panel that can CLEAR it — the v0.43.6
+              // FINDING_ROUTE idea, applied to a checklist item.
+              const route = checklistRoute(item);
+              if (route) {
+                const b = el("button", "btn btn-ghost btn-sm", route.label);
+                b.type = "button";
+                b.addEventListener("click", () => (location.hash = "#/" + route.panel));
+                row.append(b);
+              }
+              box.append(row);
+            }
+            cc.append(box);
+          }
+        }
+        if (c.verdict === "ESCALATE")
+          cc.append(
+            c.escalate_to
+              ? el("div", "note", t("boundary.escalateTo", { who: c.escalate_to }))
+              : el("div", "note bad", t("boundary.malformedNoWho"))
+          );
+        for (const m of c.malformed || []) cc.append(el("div", "note bad", m));
+
+        // A STALE card shows the refresh COMMAND, not a button: refreshing it
+        // re-runs the four questions, which costs model tokens.
+        if (c.stale) cc.append(laneCommand("/orc-boundary " + c.area, tn(c.distance, "boundary.staleWhy")));
+        out.append(cc);
+      }
+      return out;
+    }
+  );
+};
+
+// Only the routes that genuinely clear the item. Everything else gets no button
+// at all — a button that lands on a page with no control for the thing is the
+// exact defect FINDING_ROUTE was introduced to fix.
+function checklistRoute(item) {
+  const s = String(item).toLowerCase();
+  if (s.includes("pact.md") || s.includes("invariant") || s.includes("promise")) return { panel: "pact", label: t("boundary.route.pact") };
+  if (s.includes("pattern") || s.includes("convention")) return { panel: "knowledge", label: t("boundary.route.knowledge") };
+  if (s.includes("wiki") || s.includes("document")) return { panel: "knowledge", label: t("boundary.route.knowledge") };
+  return null;
+}