relic-mcp 0.1.0

package/dist/relic-mcp.js

@@ -0,0 +1,1088 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+
+// src/files.ts
+import { lstat, readFile } from "node:fs/promises";
+import { basename as pathBasename, resolve as pathResolve } from "node:path";
+var nodeFiles = {
+  resolve(path) {
+    return pathResolve(process.cwd(), path);
+  },
+  basename(path) {
+    return pathBasename(path);
+  },
+  async stat(path) {
+    const info = await lstat(path).catch(() => {
+      return;
+    });
+    if (info === undefined)
+      return { kind: "other" };
+    if (info.isDirectory())
+      return { kind: "directory" };
+    if (!info.isFile())
+      return { kind: "other" };
+    return { kind: "file", size: info.size };
+  },
+  async read(path) {
+    return new Uint8Array(await readFile(path));
+  }
+};
+
+// src/protocol.ts
+var PROTOCOL_VERSION = "2026-07-28";
+var LEGACY_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26"
+];
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  PROTOCOL_VERSION,
+  ...LEGACY_PROTOCOL_VERSIONS
+];
+var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
+var ERROR_CODES = {
+  headerMismatch: -32020,
+  unsupportedProtocolVersion: -32022,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  parseError: -32700
+};
+function errorResponse(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: data === undefined ? { code, message } : { code, message, data }
+  };
+}
+function requestedProtocolVersion(message) {
+  const meta = message.params?.["_meta"];
+  if (typeof meta !== "object" || meta === null)
+    return;
+  const version = meta[PROTOCOL_VERSION_META_KEY];
+  return typeof version === "string" ? version : undefined;
+}
+function isSupportedVersion(version) {
+  return SUPPORTED_PROTOCOL_VERSIONS.includes(version);
+}
+function unsupportedVersionError(id, requested) {
+  return errorResponse(id, ERROR_CODES.unsupportedProtocolVersion, "Unsupported protocol version", { supported: [...SUPPORTED_PROTOCOL_VERSIONS], requested });
+}
+function decodeHeaderValue(raw) {
+  if (!raw.startsWith("=?base64?") || !raw.endsWith("?="))
+    return raw;
+  const encoded = raw.slice("=?base64?".length, -"?=".length);
+  try {
+    return new TextDecoder().decode(Uint8Array.from(atob(encoded), (ch) => ch.charCodeAt(0)));
+  } catch {
+    return raw;
+  }
+}
+function expectedMcpName(message) {
+  if (message.method === "tools/call" || message.method === "prompts/get") {
+    const name = message.params?.["name"];
+    return typeof name === "string" ? name : undefined;
+  }
+  if (message.method === "resources/read") {
+    const uri = message.params?.["uri"];
+    return typeof uri === "string" ? uri : undefined;
+  }
+  return;
+}
+
+// ../relic-format/src/errors.ts
+class RelicFormatError extends Error {
+  name = "RelicFormatError";
+}
+class MalformedFragmentError extends RelicFormatError {
+  name = "MalformedFragmentError";
+}
+
+class MalformedContainerError extends RelicFormatError {
+  name = "MalformedContainerError";
+}
+class StrictParseError extends MalformedContainerError {
+  name = "StrictParseError";
+}
+class ContentTooLargeError extends RelicFormatError {
+  declaredBytes;
+  limitBytes;
+  name = "ContentTooLargeError";
+  constructor(declaredBytes, limitBytes) {
+    super(`content is ${declaredBytes} bytes, over the ${limitBytes} cap`);
+    this.declaredBytes = declaredBytes;
+    this.limitBytes = limitBytes;
+  }
+}
+
+// ../relic-format/src/envelope.ts
+var MAX_FILENAME_BYTES = 1024;
+var MAX_MIMETYPE_BYTES = 255;
+var ENTRY_COUNT_V1 = 1;
+var MAX_HEADER_BYTES = 2 + (2 + MAX_FILENAME_BYTES + 2 + MAX_MIMETYPE_BYTES + 8 + 8);
+var encoder = new TextEncoder;
+var decoder = new TextDecoder("utf-8", { fatal: false });
+function encodeEnvelope(envelope) {
+  if (envelope.entries.length !== ENTRY_COUNT_V1) {
+    throw new StrictParseError(`version 1 carries exactly ${ENTRY_COUNT_V1} entry, got ` + `${envelope.entries.length}`);
+  }
+  const parts = [];
+  const prelude = new Uint8Array(2);
+  prelude[0] = envelope.version;
+  prelude[1] = envelope.entries.length;
+  parts.push(prelude);
+  for (const entry of envelope.entries) {
+    const filename = encoder.encode(entry.filename);
+    const mimetype = encoder.encode(entry.mimetype);
+    if (filename.length > MAX_FILENAME_BYTES) {
+      throw new StrictParseError(`filename is ${filename.length} bytes, over ${MAX_FILENAME_BYTES}`);
+    }
+    if (mimetype.length > MAX_MIMETYPE_BYTES) {
+      throw new StrictParseError(`mimetype is ${mimetype.length} bytes, over ${MAX_MIMETYPE_BYTES}`);
+    }
+    const fixed = new Uint8Array(2 + filename.length + 2 + mimetype.length + 16);
+    const view = new DataView(fixed.buffer);
+    let cursor = 0;
+    view.setUint16(cursor, filename.length, false);
+    cursor += 2;
+    fixed.set(filename, cursor);
+    cursor += filename.length;
+    view.setUint16(cursor, mimetype.length, false);
+    cursor += 2;
+    fixed.set(mimetype, cursor);
+    cursor += mimetype.length;
+    view.setBigUint64(cursor, BigInt(entry.offset), false);
+    cursor += 8;
+    view.setBigUint64(cursor, BigInt(entry.length), false);
+    parts.push(fixed);
+  }
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+// ../relic-format/src/fragment.ts
+var FORMAT_VERSION = 1;
+var VERSION_MARKER = "r1";
+var KEY_BYTES = 16;
+var B64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function encodeKey(key) {
+  let out = "";
+  let accumulator = 0;
+  let bitsHeld = 0;
+  for (const byte of key) {
+    accumulator = accumulator << 8 | byte;
+    bitsHeld += 8;
+    while (bitsHeld >= 6) {
+      bitsHeld -= 6;
+      out += B64URL[accumulator >>> bitsHeld & 63];
+    }
+  }
+  if (bitsHeld > 0) {
+    out += B64URL[accumulator << 6 - bitsHeld & 63];
+  }
+  return out;
+}
+function generateKey() {
+  const key = new Uint8Array(KEY_BYTES);
+  crypto.getRandomValues(key);
+  return key;
+}
+function encodeFragment(key) {
+  if (key.length !== KEY_BYTES) {
+    throw new MalformedFragmentError(`key must be ${KEY_BYTES} bytes`);
+  }
+  return VERSION_MARKER + encodeKey(key);
+}
+function relicUrl(origin, relicId, key) {
+  const base = origin.endsWith("/") ? origin.slice(0, -1) : origin;
+  return `${base}/${relicId}#${encodeFragment(key)}`;
+}
+
+// ../relic-format/src/rfc8188.ts
+var HEADER_BYTES = 21;
+var TAG_BYTES = 16;
+var DELIMITER_BYTES = 1;
+var RECORD_OVERHEAD = TAG_BYTES + DELIMITER_BYTES;
+var SALT_BYTES = 16;
+var RECORD_SIZE = 65536;
+function recordCapacity(rs) {
+  return rs - RECORD_OVERHEAD;
+}
+var CEK_INFO = new TextEncoder().encode("Content-Encoding: aes128gcm\x00");
+var NONCE_INFO = new TextEncoder().encode("Content-Encoding: nonce\x00");
+async function deriveKeys(ikm, salt) {
+  const material = await crypto.subtle.importKey("raw", toBufferSource(ikm), "HKDF", false, ["deriveBits"]);
+  const cekBits = await crypto.subtle.deriveBits({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: toBufferSource(salt),
+    info: CEK_INFO
+  }, material, 128);
+  const nonceBits = await crypto.subtle.deriveBits({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: toBufferSource(salt),
+    info: NONCE_INFO
+  }, material, 96);
+  const cek = await crypto.subtle.importKey("raw", cekBits, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  return { cek, nonceBase: new Uint8Array(nonceBits) };
+}
+function recordNonce(nonceBase, seq) {
+  if (!Number.isSafeInteger(seq) || seq < 0) {
+    throw new MalformedContainerError(`record sequence ${seq} is not valid`);
+  }
+  const nonce = new Uint8Array(nonceBase);
+  let remaining = seq;
+  for (let offset = nonce.length - 1;offset >= 0 && remaining > 0; offset--) {
+    nonce[offset] = nonce[offset] ^ remaining & 255;
+    remaining = Math.floor(remaining / 256);
+  }
+  return nonce;
+}
+function encodeHeader(salt, rs) {
+  if (salt.length !== SALT_BYTES) {
+    throw new MalformedContainerError(`salt must be ${SALT_BYTES} bytes`);
+  }
+  const header = new Uint8Array(HEADER_BYTES);
+  header.set(salt, 0);
+  new DataView(header.buffer).setUint32(SALT_BYTES, rs, false);
+  header[SALT_BYTES + 4] = 0;
+  return header;
+}
+async function encryptRecord(keys, seq, data, isLast, targetDataBytes = data.length) {
+  if (targetDataBytes < data.length) {
+    throw new MalformedContainerError("pad target is smaller than the data");
+  }
+  const plaintext = new Uint8Array(targetDataBytes + DELIMITER_BYTES);
+  plaintext.set(data, 0);
+  plaintext[data.length] = isLast ? 2 : 1;
+  const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv: toBufferSource(recordNonce(keys.nonceBase, seq)) }, keys.cek, toBufferSource(plaintext));
+  return new Uint8Array(sealed);
+}
+function toBufferSource(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+// ../relic-format/src/container.ts
+var PLAINTEXT_CAP_BYTES = 100 * 1024 * 1024;
+async function encryptRelic(input) {
+  const rs = input.rs ?? RECORD_SIZE;
+  const capacity = recordCapacity(rs);
+  if (input.content.length > PLAINTEXT_CAP_BYTES) {
+    throw new ContentTooLargeError(input.content.length, PLAINTEXT_CAP_BYTES);
+  }
+  const salt = input.salt ?? randomSalt();
+  const keys = await deriveKeys(input.key, salt);
+  const envelope = {
+    version: FORMAT_VERSION,
+    entries: [
+      {
+        filename: input.filename,
+        mimetype: input.mimetype,
+        offset: 0,
+        length: input.content.length
+      }
+    ]
+  };
+  const envelopeBytes = encodeEnvelope(envelope);
+  if (envelopeBytes.length > capacity) {
+    throw new MalformedContainerError(`envelope header is ${envelopeBytes.length} bytes, over the ` + `${capacity} a record can carry`);
+  }
+  const parts = [encodeHeader(salt, rs)];
+  if (input.content.length === 0) {
+    parts.push(await encryptRecord(keys, 0, envelopeBytes, true));
+    return concat(parts);
+  }
+  parts.push(await encryptRecord(keys, 0, envelopeBytes, false, capacity));
+  const recordCount = Math.ceil(input.content.length / capacity);
+  for (let index = 0;index < recordCount; index++) {
+    const start = index * capacity;
+    const chunk = input.content.slice(start, start + capacity);
+    const isLast = index === recordCount - 1;
+    parts.push(await encryptRecord(keys, index + 1, chunk, isLast));
+  }
+  return concat(parts);
+}
+function randomSalt() {
+  const salt = new Uint8Array(SALT_BYTES);
+  crypto.getRandomValues(salt);
+  return salt;
+}
+function concat(parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+// ../relic-format/src/id.ts
+var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+var ID_ENTROPY_BYTES = 16;
+var RESERVED_SEGMENTS = [
+  "abuse",
+  "policy",
+  "robots.txt",
+  "favicon.ico",
+  "sitemap.xml",
+  "manifest.webmanifest",
+  "sw.js",
+  "assets",
+  "api",
+  "health",
+  ".well-known",
+  "sandbox.html"
+];
+var RESERVED_NORMALIZED = new Set(RESERVED_SEGMENTS.map((word) => foldAliases(word.toLowerCase())));
+
+class InvalidRelicIdError extends Error {
+  failure;
+  name = "InvalidRelicIdError";
+  constructor(failure, message) {
+    super(message);
+    this.failure = failure;
+  }
+}
+function foldAliases(lowered) {
+  let out = "";
+  for (const ch of lowered) {
+    if (ch === "i" || ch === "l")
+      out += "1";
+    else if (ch === "o")
+      out += "0";
+    else
+      out += ch;
+  }
+  return out;
+}
+function encodeRelicId(entropy) {
+  if (entropy.length !== ID_ENTROPY_BYTES) {
+    throw new InvalidRelicIdError("length", `relic id entropy must be ${ID_ENTROPY_BYTES} bytes`);
+  }
+  let out = "";
+  let accumulator = 0;
+  let bitsHeld = 0;
+  for (const byte of entropy) {
+    accumulator = accumulator << 8 | byte;
+    bitsHeld += 8;
+    while (bitsHeld >= 5) {
+      bitsHeld -= 5;
+      const index = accumulator >>> bitsHeld & 31;
+      out += ALPHABET[index];
+    }
+  }
+  if (bitsHeld > 0) {
+    const index = accumulator << 5 - bitsHeld & 31;
+    out += ALPHABET[index];
+  }
+  return out;
+}
+function generateRelicId() {
+  const entropy = new Uint8Array(ID_ENTROPY_BYTES);
+  crypto.getRandomValues(entropy);
+  return encodeRelicId(entropy);
+}
+// ../relic-format/src/renderer-class.ts
+var MAGIC = [
+  { bytes: [137, 80, 78, 71], offset: 0, cls: "image" },
+  { bytes: [255, 216, 255], offset: 0, cls: "image" },
+  { bytes: [71, 73, 70, 56], offset: 0, cls: "image" },
+  { bytes: [66, 77], offset: 0, cls: "image" },
+  { bytes: [80, 75, 3, 4], offset: 0, cls: "archive" },
+  { bytes: [80, 75, 5, 6], offset: 0, cls: "archive" },
+  { bytes: [31, 139], offset: 0, cls: "archive" },
+  { bytes: [66, 90, 104], offset: 0, cls: "archive" },
+  { bytes: [253, 55, 122, 88, 90], offset: 0, cls: "archive" },
+  { bytes: [40, 181, 47, 253], offset: 0, cls: "archive" },
+  { bytes: [117, 115, 116, 97, 114], offset: 257, cls: "archive" },
+  { bytes: [37, 80, 68, 70], offset: 0, cls: "binary" },
+  { bytes: [73, 68, 51], offset: 0, cls: "media" },
+  { bytes: [79, 103, 103, 83], offset: 0, cls: "media" },
+  { bytes: [102, 116, 121, 112], offset: 4, cls: "media" }
+];
+var EXTENSIONS = {
+  md: "markdown",
+  markdown: "markdown",
+  mdown: "markdown",
+  mkd: "markdown",
+  html: "html",
+  htm: "html",
+  xhtml: "html",
+  svg: "image",
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  gif: "image",
+  webp: "image",
+  avif: "image",
+  bmp: "image",
+  ico: "image",
+  mp4: "media",
+  webm: "media",
+  mov: "media",
+  mkv: "media",
+  mp3: "media",
+  wav: "media",
+  ogg: "media",
+  flac: "media",
+  m4a: "media",
+  zip: "archive",
+  tar: "archive",
+  gz: "archive",
+  tgz: "archive",
+  bz2: "archive",
+  xz: "archive",
+  zst: "archive",
+  "7z": "archive",
+  rar: "archive",
+  ts: "code",
+  tsx: "code",
+  js: "code",
+  jsx: "code",
+  mjs: "code",
+  cjs: "code",
+  json: "code",
+  jsonc: "code",
+  yaml: "code",
+  yml: "code",
+  toml: "code",
+  ini: "code",
+  xml: "code",
+  py: "code",
+  rb: "code",
+  go: "code",
+  rs: "code",
+  java: "code",
+  kt: "code",
+  swift: "code",
+  c: "code",
+  h: "code",
+  cc: "code",
+  cpp: "code",
+  hpp: "code",
+  cs: "code",
+  php: "code",
+  ex: "code",
+  exs: "code",
+  erl: "code",
+  scala: "code",
+  clj: "code",
+  hs: "code",
+  lua: "code",
+  pl: "code",
+  r: "code",
+  sql: "code",
+  sh: "code",
+  bash: "code",
+  zsh: "code",
+  fish: "code",
+  ps1: "code",
+  dockerfile: "code",
+  tf: "code",
+  hcl: "code",
+  proto: "code",
+  graphql: "code",
+  gql: "code",
+  css: "code",
+  scss: "code",
+  sass: "code",
+  less: "code",
+  diff: "code",
+  patch: "code",
+  csv: "code",
+  tsv: "code",
+  txt: "code",
+  log: "code",
+  text: "code"
+};
+function extensionOf(filename) {
+  const base = filename.slice(filename.lastIndexOf("/") + 1).toLowerCase();
+  if (base === "dockerfile")
+    return "dockerfile";
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0 || dot === base.length - 1)
+    return;
+  return base.slice(dot + 1);
+}
+function matchesMagic(content, signature) {
+  const end = signature.offset + signature.bytes.length;
+  if (content.length < end)
+    return false;
+  for (let index = 0;index < signature.bytes.length; index++) {
+    if (content[signature.offset + index] !== signature.bytes[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function looksTextual(content) {
+  const limit = Math.min(content.length, 8192);
+  if (limit === 0)
+    return false;
+  let suspicious = 0;
+  for (let index = 0;index < limit; index++) {
+    const byte = content[index];
+    if (byte === 0)
+      return false;
+    const isPlainControl = byte < 9 || byte > 13 && byte < 32 || byte === 127;
+    if (isPlainControl)
+      suspicious++;
+  }
+  return suspicious / limit < 0.01;
+}
+var HTML_PREFIXES = ["<!doctype html", "<html", "<!-- ", "<svg"];
+function deriveRendererClass(content, filename) {
+  if (content.length === 0)
+    return "binary";
+  for (const signature of MAGIC) {
+    if (matchesMagic(content, signature))
+      return signature.cls;
+  }
+  const extension = extensionOf(filename);
+  if (extension !== undefined) {
+    const fromExtension = EXTENSIONS[extension];
+    if (fromExtension !== undefined)
+      return fromExtension;
+  }
+  if (looksTextual(content)) {
+    const head = new TextDecoder("utf-8", { fatal: false }).decode(content.slice(0, 256)).trimStart().toLowerCase();
+    if (HTML_PREFIXES.some((prefix) => head.startsWith(prefix)))
+      return "html";
+    return "code";
+  }
+  return "binary";
+}
+// src/publish.ts
+class PublishError extends Error {
+  code;
+  details;
+  name = "PublishError";
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+}
+
+class ServerRefusal extends Error {
+  code;
+  status;
+  problem;
+  name = "ServerRefusal";
+  constructor(code, status, problem) {
+    super(String(problem["detail"] ?? code));
+    this.code = code;
+    this.status = status;
+    this.problem = problem;
+  }
+}
+async function publish(input, deps) {
+  const source = await readSource(input.path, deps.files);
+  const challenge = await postJson(deps, `${deps.serviceOrigin}/api/challenge`, {});
+  const sizeLimit = Number(challenge["size_limit_bytes"]);
+  const sizeBasis = String(challenge["size_basis"]);
+  if (source.bytes.length > sizeLimit) {
+    throw new PublishError("local_size_precheck_failed", `${source.basename} is ${source.bytes.length} bytes, over the ` + `${sizeLimit}-byte cap`, {
+      size_limit_bytes: sizeLimit,
+      declared_size_bytes: source.bytes.length,
+      size_basis: sizeBasis
+    });
+  }
+  const filename = input.filename ?? source.basename;
+  const rendererClass = deriveRendererClass(source.bytes, filename);
+  const retries = deps.maxCollisionRetries ?? 3;
+  let lastCollision;
+  for (let attempt = 0;attempt <= retries; attempt++) {
+    const relicId = generateRelicId();
+    const key = generateKey();
+    const container2 = await encryptRelic({
+      content: source.bytes,
+      filename,
+      mimetype: guessMimetype(filename, rendererClass),
+      key
+    });
+    let grant;
+    try {
+      grant = await postJson(deps, `${deps.serviceOrigin}/api/grant`, {
+        challenge_nonce: challenge["challenge_nonce"],
+        relic_id: relicId,
+        renderer_class: rendererClass,
+        publishing_client: deps.clientName,
+        declared_size_bytes: source.bytes.length,
+        declared_ciphertext_bytes: container2.length
+      });
+    } catch (error) {
+      if (error instanceof ServerRefusal && error.code === "relic_id_collision") {
+        lastCollision = error;
+        continue;
+      }
+      throw error;
+    }
+    const upload = await deps.fetch(String(grant["upload_url"]), {
+      method: "PUT",
+      headers: { "content-length": String(container2.length) },
+      body: container2
+    });
+    if (!upload.ok) {
+      throw new PublishError("upload_failed", `upload returned ${upload.status}`, { relic_id: relicId, status: upload.status });
+    }
+    try {
+      await postJson(deps, `${deps.serviceOrigin}/api/relics/${relicId}/complete`, {});
+    } catch {}
+    return {
+      url: relicUrl(deps.relicOrigin, relicId, key),
+      relic_id: relicId,
+      relic_expires_at: String(grant["relic_expires_at"]),
+      renderer_class: rendererClass,
+      filename,
+      resolved_path: source.resolvedPath,
+      report_url: String(grant["report_url"]),
+      disclosure_url: String(grant["disclosure_url"])
+    };
+  }
+  throw lastCollision ?? new PublishError("service_unreachable", "could not obtain a grant");
+}
+async function readSource(path, files) {
+  const resolvedPath = files.resolve(path);
+  const stat = await files.stat(resolvedPath);
+  if (stat.kind === "directory") {
+    throw new PublishError("source_is_directory", `${resolvedPath} is a directory. Create an archive yourself and ` + "publish that, so the download-only outcome is yours to choose.");
+  }
+  if (stat.kind === "other") {
+    throw new PublishError("source_not_regular_file", `${resolvedPath} is not a regular file`);
+  }
+  let bytes;
+  try {
+    bytes = await files.read(resolvedPath);
+  } catch (error) {
+    throw new PublishError("source_unreadable", `could not read ${resolvedPath}: ${error.message}`);
+  }
+  return { bytes, basename: files.basename(resolvedPath), resolvedPath };
+}
+async function postJson(deps, url, body) {
+  let response;
+  try {
+    response = await deps.fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (error) {
+    throw new PublishError("service_unreachable", `could not reach ${url}: ${error.message}`);
+  }
+  const parsed = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new ServerRefusal(String(parsed["code"] ?? "unknown"), response.status, parsed);
+  }
+  return parsed;
+}
+var MIMETYPES = {
+  md: "text/markdown",
+  markdown: "text/markdown",
+  html: "text/html",
+  htm: "text/html",
+  txt: "text/plain",
+  json: "application/json",
+  csv: "text/csv",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  zip: "application/zip",
+  gz: "application/gzip",
+  pdf: "application/pdf"
+};
+var CLASS_FALLBACK = {
+  markdown: "text/markdown",
+  code: "text/plain",
+  html: "text/html",
+  image: "application/octet-stream",
+  media: "application/octet-stream",
+  archive: "application/octet-stream",
+  binary: "application/octet-stream"
+};
+function guessMimetype(filename, rendererClass) {
+  const base = filename.slice(filename.lastIndexOf("/") + 1).toLowerCase();
+  const dot = base.lastIndexOf(".");
+  if (dot > 0 && dot < base.length - 1) {
+    const found = MIMETYPES[base.slice(dot + 1)];
+    if (found !== undefined)
+      return found;
+  }
+  return CLASS_FALLBACK[rendererClass];
+}
+
+// src/server.ts
+var TOOL_NAME = "relic_publish";
+var DESCRIBE_TOOL_NAME = "relic_describe_client";
+var TOOL_DEFINITION = {
+  name: TOOL_NAME,
+  title: "Publish a relic",
+  description: "Encrypt a file on this machine and publish it as a relic, returning a " + "shareable URL. The encryption key is generated locally and never sent " + "to the service. Takes a filesystem path, never inline content.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Filesystem path to the file to publish."
+      },
+      filename: {
+        type: "string",
+        description: "Optional. Overrides the name written into the encrypted envelope " + "header. Defaults to the basename of `path`."
+      }
+    },
+    required: ["path"],
+    additionalProperties: false
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string" },
+      relic_id: { type: "string" },
+      relic_expires_at: { type: "string" },
+      renderer_class: { type: "string" },
+      filename: { type: "string" },
+      resolved_path: { type: "string" },
+      report_url: { type: "string" },
+      disclosure_url: { type: "string" }
+    },
+    required: [
+      "url",
+      "relic_id",
+      "relic_expires_at",
+      "renderer_class",
+      "filename",
+      "resolved_path",
+      "report_url",
+      "disclosure_url"
+    ],
+    additionalProperties: false
+  }
+};
+var DESCRIBE_TOOL_DEFINITION = {
+  name: DESCRIBE_TOOL_NAME,
+  title: "Describe the Relic client",
+  description: "Return exactly what this client does with your file: the encryption " + "path, what leaves the machine, and what the service can see. Reads " + "nothing and sends nothing.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  }
+};
+var SERVER_INFO = {
+  name: "relic",
+  title: "Relic",
+  version: "0.1.0"
+};
+var CAPABILITIES = { tools: {} };
+async function handleMessage(message, deps) {
+  if (message.id === undefined)
+    return;
+  const id2 = message.id ?? null;
+  const isProbe = message.method === "server/discover" || message.method === "initialize";
+  const requested = requestedProtocolVersion(message);
+  if (!isProbe && requested !== undefined && !isSupportedVersion(requested)) {
+    return unsupportedVersionError(id2, requested);
+  }
+  switch (message.method) {
+    case "server/discover":
+      return {
+        jsonrpc: "2.0",
+        id: id2,
+        result: {
+          protocolVersions: [...SUPPORTED_PROTOCOL_VERSIONS],
+          capabilities: CAPABILITIES,
+          serverInfo: SERVER_INFO
+        }
+      };
+    case "initialize": {
+      const asked = message.params?.["protocolVersion"] ?? PROTOCOL_VERSION;
+      return {
+        jsonrpc: "2.0",
+        id: id2,
+        result: {
+          protocolVersion: isSupportedVersion(asked) ? asked : PROTOCOL_VERSION,
+          capabilities: CAPABILITIES,
+          serverInfo: SERVER_INFO
+        }
+      };
+    }
+    case "ping":
+      return { jsonrpc: "2.0", id: id2, result: {} };
+    case "tools/list":
+      return {
+        jsonrpc: "2.0",
+        id: id2,
+        result: { tools: [TOOL_DEFINITION, DESCRIBE_TOOL_DEFINITION] }
+      };
+    case "tools/call":
+      return callTool(id2, message.params ?? {}, deps);
+    default:
+      return errorResponse(id2, ERROR_CODES.methodNotFound, `unknown method: ${message.method}`);
+  }
+}
+async function callTool(id2, params, deps) {
+  if (params["name"] === DESCRIBE_TOOL_NAME) {
+    return {
+      jsonrpc: "2.0",
+      id: id2,
+      result: {
+        content: [{ type: "text", text: describeClient(deps) }],
+        structuredContent: {
+          encryption: "AES-128-GCM, RFC 8188 aes128gcm framing",
+          key_origin: "crypto.getRandomValues on this machine",
+          key_transmitted_to_service: false,
+          plaintext_transmitted_to_service: false,
+          ciphertext_destination: "object storage, via a signed URL",
+          service_origin: deps.serviceOrigin
+        },
+        isError: false
+      }
+    };
+  }
+  if (params["name"] !== TOOL_NAME) {
+    return errorResponse(id2, ERROR_CODES.invalidParams, `unknown tool: ${String(params["name"])}`);
+  }
+  const args = params["arguments"] ?? {};
+  const path = args["path"];
+  if (typeof path !== "string" || path.length === 0) {
+    return errorResponse(id2, ERROR_CODES.invalidParams, "`path` is required and must be a string");
+  }
+  const filename = typeof args["filename"] === "string" ? args["filename"] : undefined;
+  try {
+    const result = await publish({ path, filename }, deps);
+    return {
+      jsonrpc: "2.0",
+      id: id2,
+      result: {
+        content: [
+          {
+            type: "text",
+            text: `Published ${result.filename} as a relic.
+
+${result.url}
+
+` + `Expires ${result.relic_expires_at}. Anyone with this link, ` + "including its fragment, can read the file. The key is in the " + `fragment and it is now in this transcript.
+` + `What Relic knows: ${result.disclosure_url}`
+          }
+        ],
+        structuredContent: result,
+        isError: false
+      }
+    };
+  } catch (error) {
+    return { jsonrpc: "2.0", id: id2, result: toolError(error) };
+  }
+}
+function toolError(error) {
+  if (error instanceof PublishError) {
+    return {
+      content: [{ type: "text", text: `${error.code}: ${error.message}` }],
+      structuredContent: { code: error.code, ...error.details },
+      isError: true
+    };
+  }
+  if (error instanceof ServerRefusal) {
+    return {
+      content: [{ type: "text", text: `${error.code}: ${error.message}` }],
+      structuredContent: { code: error.code, ...error.problem },
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: `publish failed: ${String(error)}` }],
+    structuredContent: { code: "unknown" },
+    isError: true
+  };
+}
+function describeClient(deps) {
+  return `Relic publishing client, running locally on this machine.
+
+What happens when you publish a file:
+
+1. The file is read from disk by this process. It is never sent anywhere in
+   plaintext.
+2. A 128-bit key and a 26-character relic id are drawn independently from this
+   machine's CSPRNG (crypto.getRandomValues). Neither derives from the other.
+3. The file is encrypted here, in this process, with AES-128-GCM under RFC 8188
+   aes128gcm framing: an HKDF-derived content key, counter-derived per-record
+   nonces, and a per-record authentication tag.
+4. Only ciphertext is uploaded, straight to object storage under a signed URL.
+   It does not pass through ${deps.serviceOrigin}.
+5. The service is told three things and nothing more: a coarse renderer class
+   from a seven-value list, the name of this client, and the exact byte length
+   of the ciphertext. Not your filename, not the mimetype, not the contents.
+6. You get back a URL whose fragment carries the key. Fragments are never sent
+   to a server by a browser.
+
+What the service operator can see: that a relic exists, roughly how big it is,
+what coarse class it was declared as, the publishing IP, and when it was
+fetched. Never the contents, and never the key.
+
+What this does NOT protect against: the key is returned to your agent in the
+URL, so it enters the model's context and your session transcript. That is
+structural, not a defect. Anyone who can read this conversation can open the
+relic.
+
+The code doing all of this is on disk in this package and can be read. Nothing
+is fetched from the network and executed.`;
+}
+async function serveStdio(deps, input, write) {
+  const decoder2 = new TextDecoder;
+  const reader = input.getReader();
+  let buffer = "";
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder2.decode(value, { stream: true });
+    let newline = buffer.indexOf(`
+`);
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf(`
+`);
+      if (line.length === 0)
+        continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        write(JSON.stringify(errorResponse(null, ERROR_CODES.parseError, "parse error")));
+        continue;
+      }
+      const response = await handleMessage(message, deps);
+      if (response !== undefined)
+        write(JSON.stringify(response));
+    }
+  }
+}
+
+// src/http.ts
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function createHttpHandler(deps, options = {}) {
+  const allowed = new Set(options.allowedOrigins ?? []);
+  return async (request) => {
+    const origin = request.headers.get("origin");
+    if (origin !== null && !allowed.has(origin)) {
+      return jsonResponse(errorResponse(null, ERROR_CODES.headerMismatch, "origin not allowed"), 403);
+    }
+    if (request.method !== "POST") {
+      return new Response("Method not allowed", {
+        status: 405,
+        headers: { allow: "POST" }
+      });
+    }
+    let message;
+    try {
+      message = await request.json();
+    } catch {
+      return jsonResponse(errorResponse(null, ERROR_CODES.parseError, "parse error"), 400);
+    }
+    const id2 = message.id ?? null;
+    const headerVersion = request.headers.get("mcp-protocol-version");
+    const bodyVersion = requestedProtocolVersion(message);
+    if (headerVersion === null) {
+      return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, "MCP-Protocol-Version header is required"), 400);
+    }
+    if (bodyVersion !== undefined && headerVersion !== bodyVersion) {
+      return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, `Header mismatch: MCP-Protocol-Version header value ` + `'${headerVersion}' does not match body value '${bodyVersion}'`), 400);
+    }
+    if (!isSupportedVersion(headerVersion)) {
+      return jsonResponse(unsupportedVersionError(id2, headerVersion), 400);
+    }
+    const headerMethod = request.headers.get("mcp-method");
+    if (headerMethod === null) {
+      return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, "Mcp-Method header is required"), 400);
+    }
+    if (headerMethod !== message.method) {
+      return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, `Header mismatch: Mcp-Method header value '${headerMethod}' does ` + `not match body value '${message.method}'`), 400);
+    }
+    const wantsName = expectedMcpName(message);
+    if (wantsName !== undefined) {
+      const rawName = request.headers.get("mcp-name");
+      if (rawName === null) {
+        return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, "Mcp-Name header is required for this method"), 400);
+      }
+      if (decodeHeaderValue(rawName) !== wantsName) {
+        return jsonResponse(errorResponse(id2, ERROR_CODES.headerMismatch, "Header mismatch: Mcp-Name header value does not match body value"), 400);
+      }
+    }
+    const response = await handleMessage(message, deps);
+    if (response === undefined)
+      return new Response(null, { status: 202 });
+    if (response.error?.code === ERROR_CODES.methodNotFound) {
+      return jsonResponse(response, 404);
+    }
+    return jsonResponse(response);
+  };
+}
+
+// src/index.ts
+var deps = {
+  serviceOrigin: process.env["RELIC_SERVICE_ORIGIN"] ?? "https://relic.example",
+  relicOrigin: process.env["RELIC_ORIGIN"] ?? process.env["RELIC_SERVICE_ORIGIN"] ?? "https://relic.example",
+  files: nodeFiles,
+  fetch: globalThis.fetch,
+  clientName: process.env["RELIC_CLIENT_NAME"] ?? "relic-mcp/0.1.0"
+};
+if (process.env["RELIC_MCP_HTTP"] === "1") {
+  const port = Number(process.env["RELIC_MCP_PORT"] ?? 7333);
+  const hostname = process.env["RELIC_MCP_HOST"] ?? "127.0.0.1";
+  const allowedOrigins = (process.env["RELIC_MCP_ALLOWED_ORIGINS"] ?? "").split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  const handler = createHttpHandler(deps, { allowedOrigins });
+  createServer((incoming, outgoing) => {
+    const chunks = [];
+    incoming.on("data", (chunk) => chunks.push(chunk));
+    incoming.on("end", () => {
+      (async () => {
+        const url = new URL(incoming.url ?? "/", `http://${incoming.headers.host ?? `${hostname}:${port}`}`);
+        if (url.pathname !== "/mcp") {
+          outgoing.writeHead(404).end("Not found");
+          return;
+        }
+        const method = incoming.method ?? "GET";
+        const request = new Request(url, {
+          method,
+          headers: incoming.headers,
+          ...method === "GET" || method === "HEAD" ? {} : { body: Buffer.concat(chunks) }
+        });
+        const response = await handler(request);
+        outgoing.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+        const body = await response.arrayBuffer();
+        outgoing.end(Buffer.from(body));
+      })();
+    });
+  }).listen(port, hostname, () => {
+    console.error(`relic-mcp listening on http://${hostname}:${port}/mcp`);
+  });
+} else {
+  await serveStdio(deps, Readable.toWeb(process.stdin), (line) => {
+    process.stdout.write(`${line}
+`);
+  });
+}