@sendora/mcp 1.4.1 → 1.5.1

package/dist/generated/screens/domain-records.html

@@ -0,0 +1,662 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<title>DNS records</title>
+<style>
+/*
+ * The screens' look (docs/design/oauth.md §9). Each colour, font, size and
+ * radius is the host's style variable where the host gives one, and the
+ * value Claude documents for it otherwise, in light and in dark. The host
+ * draws the border and the background, so the page paints neither. Status
+ * tints sit behind the primary text, which passes WCAG AA on each of them.
+ */
+
+:root {
+  --own-text-primary: #141413;
+  --own-text-secondary: #3d3d3a;
+  --own-text-inverse: #ffffff;
+  --own-background-secondary: #f5f4ed;
+  --own-background-inverse: #141413;
+  --own-background-info: #d6e4f6;
+  --own-background-success: #e9f1dc;
+  --own-background-warning: #f6eedf;
+  --own-background-danger: #f7ecec;
+  --own-border-primary: rgb(31 30 29 / 40%);
+  --own-border-tertiary: rgb(31 30 29 / 15%);
+  --own-ring-primary: rgb(20 20 19 / 70%);
+}
+
+:root[data-theme='dark'] {
+  --own-text-primary: #faf9f5;
+  --own-text-secondary: #c2c0b6;
+  --own-text-inverse: #141413;
+  --own-background-secondary: #262624;
+  --own-background-inverse: #faf9f5;
+  --own-background-info: #253e5f;
+  --own-background-success: #1b4614;
+  --own-background-warning: #483a0f;
+  --own-background-danger: #602a28;
+  --own-border-primary: rgb(222 220 209 / 40%);
+  --own-border-tertiary: rgb(222 220 209 / 15%);
+  --own-ring-primary: rgb(250 249 245 / 70%);
+}
+
+html,
+body {
+  margin: 0;
+  background: transparent;
+}
+
+body {
+  padding: calc(12px + var(--inset-top, 0px)) calc(12px + var(--inset-right, 0px))
+    calc(12px + var(--inset-bottom, 0px)) calc(12px + var(--inset-left, 0px));
+  color: var(--color-text-primary, var(--own-text-primary));
+  font-family: var(--font-sans, system-ui, sans-serif);
+  font-size: var(--font-text-sm-size, 14px);
+  line-height: var(--font-text-sm-line-height, 1.4);
+}
+
+h1 {
+  margin: 0 0 8px;
+  font-size: var(--font-heading-md-size, 16px);
+  line-height: var(--font-heading-md-line-height, 1.4);
+  font-weight: var(--font-weight-semibold, 600);
+}
+
+h2 {
+  margin: 0;
+  font-size: var(--font-heading-sm-size, 14px);
+  line-height: var(--font-heading-sm-line-height, 1.4);
+  font-weight: var(--font-weight-semibold, 600);
+}
+
+p {
+  margin: 0 0 8px;
+}
+
+ul,
+ol {
+  margin: 0 0 12px;
+  padding: 0;
+  list-style: none;
+}
+
+.aside,
+dt,
+.reason,
+time {
+  color: var(--color-text-secondary, var(--own-text-secondary));
+}
+
+.aside,
+.reason {
+  font-size: var(--font-text-xs-size, 12px);
+  line-height: var(--font-text-xs-line-height, 1.4);
+}
+
+.badge {
+  display: inline-block;
+  padding: 1px 8px;
+  border-radius: var(--border-radius-full, 9999px);
+  font-size: var(--font-text-xs-size, 12px);
+  line-height: var(--font-text-xs-line-height, 1.4);
+  font-weight: var(--font-weight-medium, 500);
+  color: var(--color-text-primary, var(--own-text-primary));
+  background: var(--color-background-secondary, var(--own-background-secondary));
+  white-space: nowrap;
+}
+
+.badge[data-tone='info'],
+.note {
+  background: var(--color-background-info, var(--own-background-info));
+}
+
+.badge[data-tone='success'] {
+  background: var(--color-background-success, var(--own-background-success));
+}
+
+.badge[data-tone='warning'] {
+  background: var(--color-background-warning, var(--own-background-warning));
+}
+
+.badge[data-tone='danger'],
+.refusal {
+  background: var(--color-background-danger, var(--own-background-danger));
+}
+
+.note,
+.refusal {
+  padding: 8px 12px;
+  border-radius: var(--border-radius-md, 8px);
+}
+
+.address {
+  overflow-wrap: anywhere;
+}
+
+.value {
+  font-family: var(--font-mono, ui-monospace, monospace);
+  font-size: var(--font-text-xs-size, 12px);
+  overflow-wrap: anywhere;
+  -webkit-user-select: all;
+  user-select: all;
+}
+
+.facts {
+  display: grid;
+  grid-template-columns: max-content minmax(0, 1fr);
+  gap: 4px 12px;
+  margin: 0 0 12px;
+}
+
+.facts dd {
+  margin: 0;
+  min-width: 0;
+}
+
+.recipients li {
+  margin: 0 0 4px;
+}
+
+.events li {
+  padding: 8px 0;
+  border-top: 1px solid var(--color-border-tertiary, var(--own-border-tertiary));
+}
+
+.events li time {
+  display: block;
+  font-size: var(--font-text-xs-size, 12px);
+}
+
+.events p {
+  margin: 0;
+}
+
+.events:focus {
+  outline: none;
+}
+
+.standing .badge,
+.recipients .badge {
+  margin-right: 4px;
+}
+
+.record {
+  margin: 0 0 12px;
+  padding: 12px 0 0;
+  border-top: 1px solid var(--color-border-tertiary, var(--own-border-tertiary));
+}
+
+.record-head {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  margin: 0 0 8px;
+}
+
+.actions {
+  margin: 4px 0 8px;
+}
+
+button {
+  min-height: 44px;
+  padding: 0 16px;
+  border-radius: var(--border-radius-md, 8px);
+  font: inherit;
+  font-weight: var(--font-weight-semibold, 600);
+  cursor: pointer;
+}
+
+button.primary {
+  border: 0;
+  color: var(--color-text-inverse, var(--own-text-inverse));
+  background: var(--color-background-inverse, var(--own-background-inverse));
+}
+
+button.secondary {
+  border: 1px solid var(--color-border-primary, var(--own-border-primary));
+  color: var(--color-text-primary, var(--own-text-primary));
+  background: var(--color-background-secondary, var(--own-background-secondary));
+}
+
+button[aria-disabled='true'] {
+  cursor: progress;
+}
+
+button:focus-visible {
+  outline: 2px solid var(--color-ring-primary, var(--own-ring-primary));
+  outline-offset: 2px;
+}
+
+.said {
+  margin: 0;
+  font-size: var(--font-text-xs-size, 12px);
+  color: var(--color-text-secondary, var(--own-text-secondary));
+}
+
+.skeleton span {
+  display: block;
+  height: 12px;
+  margin: 0 0 10px;
+  border-radius: var(--border-radius-xs, 4px);
+  background: var(--color-background-secondary, var(--own-background-secondary));
+}
+
+.skeleton span:nth-child(1) {
+  width: 40%;
+}
+
+.skeleton span:nth-child(2) {
+  width: 75%;
+}
+
+.skeleton span:nth-child(3) {
+  width: 60%;
+}
+
+.visually-hidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+</style>
+</head>
+<body>
+<main>
+<div id="screen" aria-busy="true"></div>
+<p id="said" class="said" role="status"></p>
+</main>
+<script>
+"use strict";
+(() => {
+  // screens/dom.ts
+  function element(tag, className, ...children) {
+    const made = document.createElement(tag);
+    if (className !== "") {
+      made.className = className;
+    }
+    made.append(...children);
+    return made;
+  }
+  function badge(words, tone) {
+    const pill = element("span", "badge", words);
+    pill.dataset.tone = tone;
+    return pill;
+  }
+  function value(text) {
+    return element("code", "value", text);
+  }
+  function knownZone(zone) {
+    if (typeof zone !== "string") {
+      return void 0;
+    }
+    try {
+      new Intl.DateTimeFormat("sv-SE", { timeZone: zone });
+    } catch (error) {
+      if (error instanceof RangeError) {
+        return void 0;
+      }
+      throw error;
+    }
+    return zone;
+  }
+  function timeOf(iso, zone) {
+    const at = new Date(iso);
+    const clock = new Intl.DateTimeFormat("sv-SE", {
+      dateStyle: "short",
+      timeStyle: "medium",
+      ...zone === void 0 ? {} : { timeZone: zone }
+    });
+    const time = element("time", "", Number.isNaN(at.getTime()) ? iso : clock.format(at));
+    time.dateTime = iso;
+    return time;
+  }
+  function part(id) {
+    const found = document.getElementById(id);
+    if (found === null) {
+      throw new Error(`the document has no #${id}`);
+    }
+    return found;
+  }
+  function say(words) {
+    part("said").textContent = words;
+  }
+  function waiting() {
+    const lines = element(
+      "div",
+      "skeleton",
+      element("span", ""),
+      element("span", ""),
+      element("span", "")
+    );
+    lines.setAttribute("aria-hidden", "true");
+    const screen = part("screen");
+    screen.setAttribute("aria-busy", "true");
+    screen.replaceChildren(element("p", "visually-hidden", "Waiting for the answer."), lines);
+  }
+  function show(...children) {
+    const screen = part("screen");
+    screen.setAttribute("aria-busy", "false");
+    screen.replaceChildren(...children);
+  }
+  function failed(text) {
+    const said = element("p", "refusal", text === "" ? "The tool gave no reason." : text);
+    said.setAttribute("role", "alert");
+    return [element("h1", "", "The call failed"), said];
+  }
+
+  // src/version.ts
+  var MCP_VERSION = "1.5.1";
+
+  // screens/host.ts
+  var PROTOCOL_VERSION = "2026-01-26";
+  function isFields(value2) {
+    return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+  }
+  function itemsOf(value2) {
+    return Array.isArray(value2) ? value2 : [];
+  }
+  function toolResultOf(value2) {
+    const result = isFields(value2) ? value2 : {};
+    const text = itemsOf(result.content).map(
+      (block) => isFields(block) && block.type === "text" && typeof block.text === "string" ? block.text : ""
+    ).join("");
+    return { text, structuredContent: result.structuredContent, isError: result.isError === true };
+  }
+  var root = document.documentElement;
+  function post(message) {
+    window.parent.postMessage({ jsonrpc: "2.0", ...message }, "*");
+  }
+  var pending = /* @__PURE__ */ new Map();
+  var nextId = 1;
+  function request(method, params) {
+    const id = nextId;
+    nextId += 1;
+    const answered = new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+    });
+    post({ id, method, params });
+    return answered;
+  }
+  function settle(message) {
+    if (typeof message.id !== "number") {
+      return;
+    }
+    const waiting2 = pending.get(message.id);
+    if (waiting2 === void 0) {
+      return;
+    }
+    pending.delete(message.id);
+    if (isFields(message.error)) {
+      const said = message.error.message;
+      waiting2.reject(new Error(typeof said === "string" ? said : "The host refused the request."));
+    } else {
+      waiting2.resolve(message.result);
+    }
+  }
+  function answer(id, method) {
+    if (method === "ping" || method === "ui/resource-teardown") {
+      post({ id, result: {} });
+    } else {
+      post({ id, error: { code: -32601, message: "Method not found" } });
+    }
+  }
+  function theme(chosen) {
+    root.dataset.theme = chosen;
+    root.style.colorScheme = chosen;
+  }
+  function follow(context, host) {
+    if (context.theme === "light" || context.theme === "dark") {
+      theme(context.theme);
+    }
+    const variables = isFields(context.styles) ? context.styles.variables : void 0;
+    if (isFields(variables)) {
+      for (const [name, setting] of Object.entries(variables)) {
+        if (name.startsWith("--") && typeof setting === "string") {
+          root.style.setProperty(name, setting);
+        }
+      }
+    }
+    const insets = context.safeAreaInsets;
+    if (isFields(insets)) {
+      for (const side of ["top", "right", "bottom", "left"]) {
+        const inset = insets[side];
+        if (typeof inset === "number") {
+          root.style.setProperty(`--inset-${side}`, `${String(inset)}px`);
+        }
+      }
+    }
+    if ("timeZone" in context) {
+      host.zone = knownZone(context.timeZone);
+    }
+  }
+  function reportSize() {
+    let last = "";
+    const report = () => {
+      const width = Math.ceil(window.innerWidth);
+      const height = Math.ceil(root.getBoundingClientRect().height);
+      const size = `${String(width)} ${String(height)}`;
+      if (size !== last) {
+        last = size;
+        post({ method: "ui/notifications/size-changed", params: { width, height } });
+      }
+    };
+    new ResizeObserver(report).observe(root);
+    report();
+  }
+  async function initialize(view, host) {
+    const answered = await request("ui/initialize", {
+      appInfo: { name: view.name, version: MCP_VERSION },
+      appCapabilities: { availableDisplayModes: ["inline"] },
+      protocolVersion: PROTOCOL_VERSION
+    });
+    const result = isFields(answered) ? answered : {};
+    host.callsTools = isFields(result.hostCapabilities) && isFields(result.hostCapabilities.serverTools);
+    follow(isFields(result.hostContext) ? result.hostContext : {}, host);
+    post({ method: "ui/notifications/initialized", params: {} });
+    reportSize();
+  }
+  function connect(view) {
+    const host = {
+      callsTools: false,
+      zone: void 0,
+      callTool: async (name, args) => toolResultOf(await request("tools/call", { name, arguments: args }))
+    };
+    const notifications = /* @__PURE__ */ new Map([
+      [
+        "ui/notifications/tool-result",
+        (params) => {
+          view.render(toolResultOf(params), host);
+        }
+      ],
+      [
+        "ui/notifications/tool-cancelled",
+        () => {
+          view.stopped("The call was cancelled.");
+        }
+      ],
+      [
+        "ui/notifications/host-context-changed",
+        (params) => {
+          follow(params, host);
+        }
+      ]
+    ]);
+    window.addEventListener("message", (event) => {
+      const message = event.data;
+      if (event.source !== window.parent || !isFields(message) || message.jsonrpc !== "2.0") {
+        return;
+      }
+      if (typeof message.method !== "string") {
+        settle(message);
+      } else if ("id" in message) {
+        answer(message.id, message.method);
+      } else {
+        notifications.get(message.method)?.(isFields(message.params) ? message.params : {});
+      }
+    });
+    theme(matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light");
+    initialize(view, host).catch((error) => {
+      const reason = error instanceof Error ? `: ${error.message}` : "";
+      view.stopped(`The host did not connect this screen${reason}.`);
+    });
+  }
+
+  // screens/domain-records.ts
+  var checkWords = {
+    ok: "Found",
+    missing: "Missing",
+    mismatch: "Wrong value",
+    dns_error: "Lookup failed"
+  };
+  var checkTones = {
+    ok: "success",
+    missing: "danger",
+    mismatch: "danger",
+    dns_error: "warning"
+  };
+  function isDomain(content) {
+    return isFields(content) && typeof content.domainId === "string" && isFields(content.returnPath) && isFields(content.dkim);
+  }
+  function recordBadge(record, check) {
+    if (check !== void 0) {
+      return badge(checkWords[check], checkTones[check]);
+    }
+    return record.verified ? badge("Found", "success") : badge("Not found yet", "neutral");
+  }
+  function standing(domain, host) {
+    if (!domain.verified) {
+      return element(
+        "p",
+        "standing",
+        badge("Not verified", "neutral"),
+        " Add both records to the domain's DNS, then check them."
+      );
+    }
+    if (domain.failingSince !== null) {
+      return element(
+        "p",
+        "standing",
+        badge("Records failing", "warning"),
+        " Since ",
+        timeOf(domain.failingSince, host.zone),
+        ". Mail stops if a record is still wrong 24 hours after that."
+      );
+    }
+    return element("p", "standing", badge("Verified", "success"), " Mail goes out from this domain.");
+  }
+  function recordSection(name, record, check) {
+    return element(
+      "section",
+      "record",
+      element(
+        "div",
+        "record-head",
+        element("h2", "", `${name}, ${record.type}`),
+        recordBadge(record, check)
+      ),
+      element(
+        "dl",
+        "facts",
+        element("dt", "", "Name"),
+        element("dd", "", value(record.host)),
+        element("dt", "", "Value"),
+        element("dd", "", value(record.value))
+      )
+    );
+  }
+  function outcome(domain) {
+    const { returnPath, dkim } = domain.check;
+    if (returnPath === "ok" && dkim === "ok") {
+      return "Both records were found.";
+    }
+    return `The CNAME record: ${checkWords[returnPath].toLowerCase()}. The TXT record: ${checkWords[dkim].toLowerCase()}.`;
+  }
+  async function checkAgain(domain, host, button) {
+    if (button.getAttribute("aria-disabled") === "true") {
+      return;
+    }
+    const label = button.textContent;
+    button.setAttribute("aria-disabled", "true");
+    button.textContent = "Checking\u2026";
+    say("Checking the records.");
+    let result;
+    try {
+      result = await host.callTool("check_domain", { domainId: domain.domainId });
+    } catch (error) {
+      result = {
+        text: error instanceof Error ? error.message : "",
+        structuredContent: void 0,
+        isError: true
+      };
+    }
+    const content = result.structuredContent;
+    if (result.isError || !isDomain(content) || !("check" in content)) {
+      button.removeAttribute("aria-disabled");
+      button.textContent = label;
+      say(result.text === "" ? "The check failed." : `The check failed. ${result.text}`);
+      return;
+    }
+    const focused = document.activeElement === button;
+    show(...domainScreen(content, host));
+    say(outcome(content));
+    if (focused) {
+      document.querySelector(".actions button")?.focus();
+    }
+  }
+  function domainScreen(domain, host) {
+    const check = "check" in domain ? domain.check : void 0;
+    const checked = domain.lastCheckedAt === null ? element("p", "aside", "Not checked yet.") : element("p", "aside", "Last checked ", timeOf(domain.lastCheckedAt, host.zone), ".");
+    const parts = [
+      element("h1", "", domain.domain),
+      standing(domain, host),
+      recordSection("Return path", domain.returnPath, check?.returnPath),
+      recordSection("DKIM key", domain.dkim, check?.dkim),
+      checked
+    ];
+    if (host.callsTools) {
+      const button = element(
+        "button",
+        "primary",
+        domain.lastCheckedAt === null ? "Check now" : "Check again"
+      );
+      button.type = "button";
+      button.addEventListener("click", () => {
+        void checkAgain(domain, host, button);
+      });
+      parts.push(element("div", "actions", button));
+    }
+    return parts;
+  }
+  function render(result, host) {
+    const content = result.structuredContent;
+    if (result.isError) {
+      show(...failed(result.text));
+    } else if (isDomain(content)) {
+      show(...domainScreen(content, host));
+    } else {
+      show(element("p", "", "This answer cannot be shown here. The conversation has it as text."));
+    }
+  }
+  waiting();
+  connect({
+    name: "sendora-domain-records",
+    render,
+    stopped: (words) => {
+      show(element("p", "", words));
+    }
+  });
+})();
+</script>
+</body>
+</html>