relic-mcp 0.14.3 → 0.15.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "relic",
       "description": "Publish a file from your machine as an encrypted, shareable link. The agent encrypts locally, uploads only ciphertext, and hands back a URL whose fragment holds the key, so the service stores something it cannot read.",
-      "version": "0.14.3",
+      "version": "0.15.0",
       "source": "./",
       "author": {
         "name": "The Bushido Collective",
@@ -21,6 +21,6 @@
     }
   ],
   "metadata": {
-    "version": "0.14.3"
+    "version": "0.15.0"
   }
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "relic",
-  "version": "0.14.3",
+  "version": "0.15.0",
   "description": "Publish a file from your machine as an encrypted, shareable link. The agent encrypts locally, uploads only ciphertext, and hands back a URL whose fragment holds the key, so the service stores something it cannot read.",
   "mcpServers": "./mcp-servers.json",
   "author": {

package/README.md

@@ -32,9 +32,9 @@ For any client that takes a JSON config:
 3. Encrypts locally with AES-128-GCM under RFC 8188 `aes128gcm` framing.
 4. Uploads **only ciphertext**, straight to object storage under a signed URL.
    It does not pass through the Relic service.
-5. Tells the service four things: a coarse renderer class from a ten-value
-   list (`markdown`, `code`, `html`, `jsx`, `image`, `pdf`, `media`, `archive`,
-   `binary`, `otio`), this client's name, the ciphertext's byte length, and the
+5. Tells the service four things: a coarse renderer class from an eleven-value
+   list (`markdown`, `code`, `html`, `jsx`, `image`, `pdf`, `model`, `media`,
+   `archive`, `binary`, `otio`), this client's name, the ciphertext's byte length, and the
    title, which defaults to the filename and is stored in the clear. By default,
    it also renders a 1200x630 cover image of the file's first screen in local
    headless Chrome and uploads it unencrypted via `POST /api/relics/{id}/cover`
@@ -42,6 +42,7 @@ For any client that takes a JSON config:
    timeline relics (`otio`) skip unencrypted first-screen media rendering by
    default, using a generic card carrying the title and format label to protect
    private timeline cuts and media from leaking into unencrypted link previews.
+   STL and OBJ models also use a generic card instead of a geometry preview.
    Not the mimetype, not the contents.
 6. Records the relic's id, key, and publish token locally, in a 0600 file
    under your user config directory, so the relic can be republished from

package/dist/cover/cover.js

@@ -1202,6 +1202,68 @@ var require_build = __commonJS(function(exports) {
   exports.default = LinesAndColumns;
 });
 
+// ../relic-viewer/src/content.ts
+var CONTENT_BATCH_BYTES = 8 * 1024 * 1024;
+var CONTENT_HEAD_BYTES = 65536;
+var CONTENT_TAIL_BYTES = 65557;
+var MAX_CONTENT_READ_BYTES = 16 * 1024 * 1024;
+var DOCUMENT_RENDER_LIMIT_BYTES = 100 * 1024 * 1024;
+
+class ContentStoreError extends Error {
+  constructor(cause) {
+    super("The browser could not hold the decrypted content.", { cause });
+    this.name = "ContentStoreError";
+  }
+}
+function sliceBlob(blob, start, end, type) {
+  try {
+    return blob.slice(start, end, type);
+  } catch (cause) {
+    throw new ContentStoreError(cause);
+  }
+}
+async function readBlob(blob) {
+  try {
+    const bytes = new Uint8Array(await blob.arrayBuffer());
+    if (bytes.length !== blob.size)
+      throw new Error("short Blob read");
+    return bytes;
+  } catch (cause) {
+    throw new ContentStoreError(cause);
+  }
+}
+function contentFromParts(base, head, tail) {
+  return {
+    size: base.size,
+    head,
+    tail,
+    blob(type) {
+      return sliceBlob(base, 0, base.size, type);
+    },
+    async read(start, end) {
+      if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > base.size || end - start > MAX_CONTENT_READ_BYTES) {
+        throw new RangeError("Invalid or oversized content read");
+      }
+      return readBlob(sliceBlob(base, start, end));
+    },
+    async readWhole(limit) {
+      if (!Number.isSafeInteger(limit) || limit < 0 || limit > DOCUMENT_RENDER_LIMIT_BYTES) {
+        throw new RangeError("Invalid whole-content read limit");
+      }
+      if (base.size > limit)
+        return;
+      return readBlob(base);
+    }
+  };
+}
+async function contentFromBlob(blob) {
+  const [head, tail] = await Promise.all([
+    readBlob(sliceBlob(blob, 0, Math.min(blob.size, CONTENT_HEAD_BYTES))),
+    readBlob(sliceBlob(blob, Math.max(0, blob.size - CONTENT_TAIL_BYTES), blob.size))
+  ]);
+  return contentFromParts(blob, head, tail);
+}
+
 // ../relic-viewer/src/markdown.ts
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -1300,8 +1362,15 @@ function renderMarkdown(source) {
       flushParagraph();
       const ordered = /^\s*\d+\./.test(line);
       const items = [];
-      while (index < lines.length && /^\s*([-*+]|\d+\.)\s+/.test(lines[index])) {
-        items.push(lines[index].replace(/^\s*([-*+]|\d+\.)\s+/, ""));
+      while (index < lines.length) {
+        const current = lines[index];
+        if (/^\s*([-*+]|\d+\.)\s+/.test(current)) {
+          items.push(current.replace(/^\s*([-*+]|\d+\.)\s+/, ""));
+        } else if (/^\s+\S/.test(current) && !/^\s*(>|```)/.test(current)) {
+          items[items.length - 1] += ` ${current.trim()}`;
+        } else {
+          break;
+        }
         index++;
       }
       const tag = ordered ? "ol" : "ul";
@@ -44719,6 +44788,81 @@ globalThis.pdfjsLib = {
   XfaLayer
 };
 
+// ../relic-viewer/src/pdf.ts
+var PDF_INITIAL_BYTES = 1024 * 1024;
+var PDF_RANGE_CHUNK_SIZE = 65536;
+
+class RelicPdfRangeTransport extends PDFDataRangeTransport {
+  content;
+  onError;
+  aborted = false;
+  failed = false;
+  constructor(content, initialData, onError) {
+    super(content.size, initialData);
+    this.content = content;
+    this.onError = onError;
+  }
+  requestDataRange(begin, end) {
+    if (this.aborted || this.failed)
+      return;
+    this.readRange(begin, end).then((bytes) => {
+      if (!this.aborted && !this.failed)
+        this.onDataRange(begin, bytes);
+    }).catch((error) => {
+      if (this.aborted || this.failed)
+        return;
+      this.failed = true;
+      this.onError(error);
+    });
+  }
+  abort() {
+    this.aborted = true;
+  }
+  async readRange(begin, end) {
+    if (!Number.isSafeInteger(begin) || !Number.isSafeInteger(end) || begin < 0 || end < begin || end > this.content.size) {
+      throw new RangeError("Invalid PDF range");
+    }
+    const length = end - begin;
+    if (length <= MAX_CONTENT_READ_BYTES) {
+      const bytes = await this.content.read(begin, end);
+      if (bytes.byteLength !== length)
+        throw new Error("Short PDF range read");
+      return bytes;
+    }
+    const bytes = new Uint8Array(length);
+    for (let start = begin;start < end; start += MAX_CONTENT_READ_BYTES) {
+      if (this.aborted)
+        return new Uint8Array(0);
+      const stop = Math.min(start + MAX_CONTENT_READ_BYTES, end);
+      const chunk = await this.content.read(start, stop);
+      if (chunk.byteLength !== stop - start)
+        throw new Error("Short PDF range read");
+      bytes.set(chunk, start - begin);
+    }
+    return bytes;
+  }
+}
+async function createPdfLoadingTask(content, signal) {
+  const initialData = await content.read(0, Math.min(content.size, PDF_INITIAL_BYTES));
+  if (signal?.aborted)
+    throw new Error("PDF loading cancelled");
+  if (initialData.byteLength !== Math.min(content.size, PDF_INITIAL_BYTES))
+    throw new Error("Short PDF initial read");
+  const { promise: failure, reject: rejectFailure } = Promise.withResolvers();
+  failure.catch(() => {
+    return;
+  });
+  const range = new RelicPdfRangeTransport(content, initialData, rejectFailure);
+  const task = getDocument({
+    range,
+    length: content.size,
+    rangeChunkSize: PDF_RANGE_CHUNK_SIZE,
+    disableAutoFetch: true,
+    disableStream: true
+  });
+  return { task, failure };
+}
+
 // ../relic-viewer/src/cover/pdf-trim.ts
 var PDF_GUTTER_PX = 20;
 var PDF_CANVAS_WIDTH = 600;
@@ -44771,21 +44915,21 @@ function trimPdfPage(ink, pageWidth) {
 // ../relic-viewer/src/cover/pdf.ts
 var PDF_CANVAS_HEIGHT = 315;
 var PDF_DEVICE_SCALE = 2;
-var workerInitialized = false;
 function ensurePdfWorker() {
-  if (!workerInitialized) {
-    GlobalWorkerOptions.workerPort = new Worker("/pdf.worker.mjs", {
-      type: "module"
-    });
-    workerInitialized = true;
-  }
+  GlobalWorkerOptions.workerSrc = "/pdf.worker.mjs";
 }
-async function renderPdfCover(bytes, root) {
+async function renderPdfCover(content, root) {
   ensurePdfWorker();
-  let pdfDoc;
   try {
-    const loadingTask = getDocument({ data: bytes });
-    pdfDoc = await loadingTask.promise;
+    const { task, failure } = await createPdfLoadingTask(content);
+    try {
+      const pdfDoc = await Promise.race([task.promise, failure]);
+      return await renderPdfCoverDocument(pdfDoc, root, failure);
+    } finally {
+      await task.destroy().catch(() => {
+        return;
+      });
+    }
   } catch (err) {
     return {
       ok: false,
@@ -44793,9 +44937,11 @@ async function renderPdfCover(bytes, root) {
       detail: err instanceof Error ? err.message : String(err)
     };
   }
+}
+async function renderPdfCoverDocument(pdfDoc, root, failure) {
   let page;
   try {
-    page = await pdfDoc.getPage(1);
+    page = await Promise.race([pdfDoc.getPage(1), failure]);
   } catch (err) {
     return {
       ok: false,
@@ -44820,11 +44966,14 @@ async function renderPdfCover(bytes, root) {
     };
   }
   try {
-    await page.render({
-      canvasContext: measureCtx,
-      viewport: refViewport,
-      canvas: measureCanvas
-    }).promise;
+    await Promise.race([
+      page.render({
+        canvasContext: measureCtx,
+        viewport: refViewport,
+        canvas: measureCanvas
+      }).promise,
+      failure
+    ]);
   } catch (err) {
     return {
       ok: false,
@@ -44857,11 +45006,14 @@ async function renderPdfCover(bytes, root) {
     };
   }
   try {
-    await page.render({
-      canvasContext: renderCtx,
-      viewport: finalViewport,
-      canvas: renderCanvas
-    }).promise;
+    await Promise.race([
+      page.render({
+        canvasContext: renderCtx,
+        viewport: finalViewport,
+        canvas: renderCanvas
+      }).promise,
+      failure
+    ]);
   } catch (err) {
     return {
       ok: false,
@@ -44889,7 +45041,7 @@ async function fetchInputBlob(input) {
     if (!res.ok) {
       throw new Error(`Failed to fetch input part ${i}: ${res.status}`);
     }
-    parts.push(await res.arrayBuffer());
+    parts.push(await res.blob());
   }
   return new Blob(parts, { type: input.mimetype });
 }
@@ -45077,8 +45229,7 @@ async function renderKind(request, root) {
       }
     }
     case "pdf": {
-      const arrayBuffer = await blob.arrayBuffer();
-      return renderPdfCover(new Uint8Array(arrayBuffer), root);
+      return renderPdfCover(await contentFromBlob(blob), root);
     }
   }
 }

package/dist/cover/frame.html

@@ -11390,15 +11390,91 @@ var MAX_HEADER_BYTES = 2 + (2 + MAX_FILENAME_BYTES + 2 + MAX_MIMETYPE_BYTES + 8
 var encoder = new TextEncoder;
 var decoder = new TextDecoder("utf-8", { fatal: false });
 
+// ../relic-format/src/limits.ts
+var PLAINTEXT_CAP_BYTES = 500 * 1024 * 1024;
+
 // ../relic-format/src/rfc8188.ts
 var TAG_BYTES = 16;
 var DELIMITER_BYTES = 1;
 var RECORD_OVERHEAD = TAG_BYTES + DELIMITER_BYTES;
 var CEK_INFO = new TextEncoder().encode("Content-Encoding: aes128gcm\x00");
 var NONCE_INFO = new TextEncoder().encode("Content-Encoding: nonce\x00");
-
-// ../relic-format/src/container.ts
-var PLAINTEXT_CAP_BYTES = 100 * 1024 * 1024;
+// ../relic-format/src/crc32c.ts
+var CRC32C_TABLE = new Uint32Array(256);
+for (let index = 0;index < 256; index++) {
+  let value = index;
+  for (let bit = 0;bit < 8; bit++) {
+    value = value & 1 ? value >>> 1 ^ 2197175160 : value >>> 1;
+  }
+  CRC32C_TABLE[index] = value >>> 0;
+}
+// ../relic-format/src/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
 // ../relic-format/src/id.ts
 var RESERVED_SEGMENTS = [
   "abuse",
@@ -11431,7 +11507,10 @@ function foldAliases(lowered) {
   return out;
 }
 // ../relic-format/src/otio-zip.ts
-var MAX_EXPANDED_ZIP_BYTES = 100 * 1024 * 1024;
+var MAX_INFLATED_ZIP_BYTES = 100 * 1024 * 1024;
+var OTIO_DOCUMENT_MAX_BYTES = 100 * 1024 * 1024;
+var MAX_ZIP_DIRECTORY_BYTES = 16 * 1024 * 1024;
+var ZIP_READ_CHUNK_BYTES = 8 * 1024 * 1024;
 var MAX_OTIO_BUNDLE_MEDIA_ENTRIES = 65535 - 3;
 var CRC_TABLE = new Uint32Array(256);
 for (let i = 0;i < 256; i++) {

package/dist/cover/pdf.worker.mjs

@@ -20,6 +20,11 @@
  * JavaScript code in this page
  */
 
+/**
+ * Modified by The Bushido Collective: stop indirect-object lookahead at endobj
+ * to avoid scanning the following whitespace in range-loaded PDFs.
+ */
+
 /**
  * pdfjsVersion = 5.4.149
  * pdfjsBuild = 9e2e9e209
@@ -11481,6 +11486,71 @@ class Lexer {
     }
   }
 }
+class IndirectObjectLexer extends Lexer {
+  // Stop before lookahead reads beyond an indirect object's top-level endobj.
+  // Dictionary entries alternate between names and values; a closer in value
+  // position is a value, and a mismatched closer never closes a container.
+  #openers = [];
+  #ended = false;
+  #tracking = true;
+  getObj() {
+    if (this.#ended) {
+      return EOF;
+    }
+    const obj = super.getObj();
+    if (!this.#tracking) {
+      return obj;
+    }
+    // Inline images have their own parser and delimiter rules.
+    if (obj instanceof Cmd && obj.cmd === "BI") {
+      this.#openers.length = 0;
+      this.#tracking = false;
+      return obj;
+    }
+    const top = this.#openers.at(-1);
+    if (top === "<<") {
+      if (obj instanceof Name) {
+        this.#openers[this.#openers.length - 1] = "<<value";
+      }
+      if (!(obj instanceof Cmd) || obj.cmd !== ">>") {
+        return obj;
+      }
+    } else if (top === "<<value") {
+      this.#openers[this.#openers.length - 1] = "<<";
+      if (obj instanceof Cmd && (obj.cmd === ">>" || obj.cmd === "]")) {
+        return obj;
+      }
+    }
+    if (obj instanceof Cmd) {
+      switch (obj.cmd) {
+        case "<<":
+        case "[":
+          // Fall back to the original lexer on excessive nesting.
+          if (this.#openers.length === 1024) {
+            this.#openers.length = 0;
+            this.#tracking = false;
+          } else {
+            this.#openers.push(obj.cmd);
+          }
+          break;
+        case ">>":
+          if (top === "<<") {
+            this.#openers.pop();
+          }
+          break;
+        case "]":
+          if (top === "[") {
+            this.#openers.pop();
+          }
+          break;
+        case "endobj":
+          this.#ended = this.#openers.length === 0;
+          break;
+      }
+    }
+    return obj;
+  }
+}
 class Linearization {
   static create(stream) {
     function getInt(linDict, name, allowZeroValue = false) {
@@ -11505,7 +11575,7 @@ class Linearization {
       throw new Error("Hint array in the linearization dictionary is invalid.");
     }
     const parser = new Parser({
-      lexer: new Lexer(stream),
+      lexer: new IndirectObjectLexer(stream),
       xref: null
     });
     const obj1 = parser.getObj();
@@ -54884,7 +54954,7 @@ class XRef {
         startXRefParsedCache.add(startXRef);
         stream.pos = startXRef + stream.start;
         const parser = new Parser({
-          lexer: new Lexer(stream),
+          lexer: new IndirectObjectLexer(stream),
           xref: this,
           allowStreams: true
         });
@@ -55002,7 +55072,7 @@ class XRef {
     }
     const stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
     const parser = new Parser({
-      lexer: new Lexer(stream),
+      lexer: new IndirectObjectLexer(stream),
       xref: this,
       allowStreams: true
     });