@lazyingart/agent-web 0.1.40

package/src/web/vision-image-sanitizer.js

@@ -0,0 +1,168 @@
+const PNG_SIGNATURE = Object.freeze([137, 80, 78, 71, 13, 10, 26, 10]);
+const PNG_METADATA_CHUNKS = new Set(["caBX", "eXIf", "iCCP", "iTXt", "tEXt", "zTXt"]);
+const JPEG_METADATA_MARKERS = new Set([
+  0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8,
+  0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfe,
+]);
+const SANITIZER_BYTE_LIMIT = 8 * 1024 * 1024;
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < table.length; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value >>> 1) ^ (0xedb88320 & -(value & 1));
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function fail(message) {
+  throw new TypeError(message);
+}
+
+function joinedBytes(parts, byteLength) {
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.byteLength;
+  }
+  return result;
+}
+
+function pngChunkType(bytes, offset) {
+  let result = "";
+  for (let index = offset; index < offset + 4; index += 1) {
+    const value = bytes[index];
+    if (!((value >= 65 && value <= 90) || (value >= 97 && value <= 122))) {
+      fail("canonical PNG chunk type is invalid");
+    }
+    result += String.fromCharCode(value);
+  }
+  return result;
+}
+
+function crc32(bytes, start, end) {
+  let crc = 0xffffffff;
+  for (let index = start; index < end; index += 1) {
+    crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ bytes[index]) & 0xff];
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function stripPngMetadata(bytes) {
+  if (bytes.byteLength < 45 || PNG_SIGNATURE.some((value, index) => bytes[index] !== value)) {
+    fail("canonical PNG framing is invalid");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const parts = [bytes.subarray(0, PNG_SIGNATURE.length)];
+  let byteLength = PNG_SIGNATURE.length;
+  let offset = PNG_SIGNATURE.length;
+  let chunks = 0;
+  let stripped = false;
+  let sawEnd = false;
+  while (offset < bytes.byteLength) {
+    if (bytes.byteLength - offset < 12) fail("canonical PNG framing is truncated");
+    const length = view.getUint32(offset);
+    const end = offset + 12 + length;
+    if (!Number.isSafeInteger(end) || end > bytes.byteLength) fail("canonical PNG chunk is truncated");
+    const type = pngChunkType(bytes, offset + 4);
+    const expectedCrc = view.getUint32(offset + 8 + length);
+    if (crc32(bytes, offset + 4, offset + 8 + length) !== expectedCrc) {
+      fail("canonical PNG checksum is invalid");
+    }
+    chunks += 1;
+    if (chunks > 16_384) fail("canonical PNG contains too many chunks");
+    if (type === "IEND" && (length !== 0 || end !== bytes.byteLength)) {
+      fail("canonical PNG terminator is invalid");
+    }
+    if (PNG_METADATA_CHUNKS.has(type)) stripped = true;
+    else {
+      const part = bytes.subarray(offset, end);
+      parts.push(part);
+      byteLength += part.byteLength;
+    }
+    offset = end;
+    if (type === "IEND") sawEnd = true;
+  }
+  if (!sawEnd) fail("canonical PNG is incomplete");
+  return stripped ? joinedBytes(parts, byteLength) : bytes;
+}
+
+function stripJpegMetadata(bytes) {
+  if (bytes.byteLength < 16 || bytes[0] !== 0xff || bytes[1] !== 0xd8) {
+    fail("canonical JPEG framing is invalid");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const parts = [bytes.subarray(0, 2)];
+  let byteLength = 2;
+  let offset = 2;
+  let markers = 0;
+  let stripped = false;
+  let sawEnd = false;
+  while (offset < bytes.byteLength) {
+    const markerStart = offset;
+    if (bytes[offset] !== 0xff) fail("canonical JPEG marker framing is invalid");
+    while (offset < bytes.byteLength && bytes[offset] === 0xff) offset += 1;
+    if (offset >= bytes.byteLength) fail("canonical JPEG marker is truncated");
+    const marker = bytes[offset];
+    offset += 1;
+    markers += 1;
+    if (markers > 65_536) fail("canonical JPEG contains too many markers");
+    if (marker === 0xd9) {
+      if (offset !== bytes.byteLength) fail("canonical JPEG terminator is invalid");
+      const part = bytes.subarray(markerStart, offset);
+      parts.push(part);
+      byteLength += part.byteLength;
+      sawEnd = true;
+      break;
+    }
+    if (marker === 0xd8 || marker === 0x00 || marker === 0x01
+        || (marker >= 0xd0 && marker <= 0xd7)) {
+      fail("canonical JPEG contains an invalid standalone marker");
+    }
+    if (bytes.byteLength - offset < 2) fail("canonical JPEG segment is truncated");
+    const length = view.getUint16(offset);
+    const end = offset + length;
+    if (length < 2 || end > bytes.byteLength) fail("canonical JPEG segment length is invalid");
+    if (JPEG_METADATA_MARKERS.has(marker)) stripped = true;
+    else {
+      const part = bytes.subarray(markerStart, end);
+      parts.push(part);
+      byteLength += part.byteLength;
+    }
+    offset = end;
+    if (marker === 0xda) {
+      const scanStart = offset;
+      while (offset < bytes.byteLength) {
+        if (bytes[offset] !== 0xff) {
+          offset += 1;
+          continue;
+        }
+        let markerOffset = offset + 1;
+        while (markerOffset < bytes.byteLength && bytes[markerOffset] === 0xff) markerOffset += 1;
+        if (markerOffset >= bytes.byteLength) fail("canonical JPEG scan is truncated");
+        const scanMarker = bytes[markerOffset];
+        if (scanMarker === 0x00 || (scanMarker >= 0xd0 && scanMarker <= 0xd7)) {
+          offset = markerOffset + 1;
+          continue;
+        }
+        break;
+      }
+      const scan = bytes.subarray(scanStart, offset);
+      parts.push(scan);
+      byteLength += scan.byteLength;
+    }
+  }
+  if (!sawEnd) fail("canonical JPEG is incomplete");
+  return stripped ? joinedBytes(parts, byteLength) : bytes;
+}
+
+export function sanitizeVisionImageBytes(bytes, mediaType) {
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength < 1 || bytes.byteLength > SANITIZER_BYTE_LIMIT
+      || !["image/jpeg", "image/png"].includes(mediaType)) {
+    fail("canonical image bytes and media type are required");
+  }
+  return mediaType === "image/png" ? stripPngMetadata(bytes) : stripJpegMetadata(bytes);
+}

package/src/web/web-release.js

@@ -0,0 +1,28 @@
+export const WEB_RELEASE_HEADER_NAME = "x-lazying-agent-release";
+
+const RELEASE_ID = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,95}$/u;
+
+export function optionalWebRelease(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "string" || !RELEASE_ID.test(value)) {
+    throw new TypeError("releaseId must be a portable immutable release identifier");
+  }
+  return value;
+}
+
+export function addWebReleaseHeader(headers, releaseId) {
+  if (releaseId !== null) headers.set(WEB_RELEASE_HEADER_NAME, releaseId);
+  return headers;
+}
+
+export function inspectWebReleaseResponse(response, releaseId) {
+  if (releaseId === null) return Object.freeze({ kind: "unpinned", releaseId: null });
+  const value = response?.headers?.get?.(WEB_RELEASE_HEADER_NAME);
+  if (typeof value !== "string" || !RELEASE_ID.test(value)) {
+    return Object.freeze({ kind: "invalid", releaseId: null });
+  }
+  return Object.freeze({
+    kind: value === releaseId ? "match" : "mismatch",
+    releaseId: value,
+  });
+}