dsh-doc-assistant 0.1.14 → 0.1.18

package/src/host/officeImages.js

@@ -0,0 +1,269 @@
+/**
+ * Read an existing PPTX cover without starting Office. Image-only slide decks
+ * often keep the complete first slide as one JPEG; converting the whole deck
+ * just to display that image is unnecessary. This narrow reader never extracts
+ * files, follows external relationships, or tries to compose complex slides.
+ */
+import { open } from 'node:fs/promises';
+import { posix } from 'node:path';
+import { inflateRawSync } from 'node:zlib';
+
+export const PPTX_COVER_VERSION = 'pptx-embedded-cover-v1';
+const MAX_IMAGE_BYTES = 16 * 1024 * 1024;
+const MAX_XML_BYTES = 512 * 1024;
+const crcTable = Uint32Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let bit = 0; bit < 8; bit += 1) c = (c & 1) ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (const b of bytes) c = crcTable[(c ^ b) & 255] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+async function readAt(handle, length, offset) {
+  const bytes = Buffer.alloc(length);
+  let read = 0;
+  while (read < length) {
+    const out = await handle.read(bytes, read, length - read, offset + read);
+    if (!out.bytesRead) throw new Error('Incomplete ZIP entry');
+    read += out.bytesRead;
+  }
+  return bytes;
+}
+
+/** Only the directory and requested entries are read, not all embedded images. */
+async function zipReader(handle) {
+  const { size } = await handle.stat();
+  if (size < 22 || size > 512 * 1024 * 1024) throw new Error('Unsupported ZIP size');
+  const tail = await readAt(handle, Math.min(size, 65557), Math.max(0, size - 65557));
+  let eocd = -1;
+  for (let at = tail.length - 22; at >= 0; at -= 1) {
+    if (tail.readUInt32LE(at) === 0x06054b50 && at + 22 + tail.readUInt16LE(at + 20) === tail.length) {
+      eocd = at;
+      break;
+    }
+  }
+  if (eocd < 0 || tail.readUInt16LE(eocd + 4) || tail.readUInt16LE(eocd + 6)) throw new Error('Unsupported ZIP directory');
+  const count = tail.readUInt16LE(eocd + 10);
+  const directorySize = tail.readUInt32LE(eocd + 12);
+  const directoryOffset = tail.readUInt32LE(eocd + 16);
+  if (count !== tail.readUInt16LE(eocd + 8) || count > 10000 || directorySize > 8 * 1024 * 1024
+    || directoryOffset + directorySize > size - tail.length + eocd) throw new Error('Invalid ZIP directory');
+  const directory = await readAt(handle, directorySize, directoryOffset);
+  const entries = new Map();
+  let at = 0;
+  for (let n = 0; n < count; n += 1) {
+    if (at + 46 > directory.length || directory.readUInt32LE(at) !== 0x02014b50) throw new Error('Invalid ZIP entry');
+    const nameLength = directory.readUInt16LE(at + 28);
+    const next = at + 46 + nameLength + directory.readUInt16LE(at + 30) + directory.readUInt16LE(at + 32);
+    if (next > directory.length) throw new Error('Invalid ZIP entry length');
+    const name = directory.subarray(at + 46, at + 46 + nameLength).toString('utf8');
+    if (entries.has(name) || name.includes('\0')) throw new Error('Ambiguous ZIP entry');
+    entries.set(name, {
+      flags: directory.readUInt16LE(at + 8), method: directory.readUInt16LE(at + 10),
+      crc: directory.readUInt32LE(at + 16), compressed: directory.readUInt32LE(at + 20),
+      size: directory.readUInt32LE(at + 24), offset: directory.readUInt32LE(at + 42),
+    });
+    at = next;
+  }
+  if (at !== directory.length) throw new Error('Invalid ZIP directory length');
+  async function read(name, limit) {
+    const entry = entries.get(name);
+    if (!entry) return null;
+    if ((entry.flags & 1) || ![0, 8].includes(entry.method) || entry.size > limit || entry.compressed > limit
+      || entry.offset + 30 > directoryOffset) throw new Error('Unsupported ZIP entry');
+    const head = await readAt(handle, 30, entry.offset);
+    if (head.readUInt32LE(0) !== 0x04034b50 || head.readUInt16LE(8) !== entry.method
+      || head.readUInt16LE(6) !== entry.flags) throw new Error('Invalid ZIP local entry');
+    const nameLength = head.readUInt16LE(26);
+    const start = entry.offset + 30 + nameLength + head.readUInt16LE(28);
+    if (start + entry.compressed > directoryOffset) throw new Error('Invalid ZIP data bounds');
+    const localName = await readAt(handle, nameLength, entry.offset + 30);
+    if (localName.toString('utf8') !== name) throw new Error('Conflicting ZIP names');
+    const compressed = await readAt(handle, entry.compressed, start);
+    const bytes = entry.method === 8 ? inflateRawSync(compressed, { maxOutputLength: limit }) : compressed;
+    if (bytes.length !== entry.size || crc32(bytes) !== entry.crc) throw new Error('Invalid ZIP entry checksum');
+    return bytes;
+  }
+  return { entries, read };
+}
+
+function xmlDecode(value) {
+  return value.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (_all, key) => {
+    if (key[0] === '#') {
+      const n = Number.parseInt(key.slice(key[1].toLowerCase() === 'x' ? 2 : 1), key[1].toLowerCase() === 'x' ? 16 : 10);
+      return n > 0 && n <= 0x10ffff && !(n >= 0xd800 && n <= 0xdfff) ? String.fromCodePoint(n) : '';
+    }
+    return { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" }[key.toLowerCase()];
+  });
+}
+function attrs(text) {
+  const out = {};
+  for (const m of text.matchAll(/([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) out[m[1]] = xmlDecode(m[2] ?? m[3]);
+  return out;
+}
+function tags(xml, name) {
+  return [...xml.matchAll(new RegExp(`<(?:[\\w.-]+:)?${name}\\b([^>]*)>`, 'g'))].map(m => attrs(m[1]));
+}
+function blocks(xml, name) {
+  return [...xml.matchAll(new RegExp(`<(?:[\\w.-]+:)?${name}\\b[^>]*>[\\s\\S]*?<\\/(?:[\\w.-]+:)?${name}\\s*>`, 'g'))].map(m => m[0]);
+}
+function qualifiedAttribute(obj, name) {
+  return Object.entries(obj ?? {}).find(([key]) => key.includes(':') && key.split(':').at(-1) === name)?.[1];
+}
+function relationship(xml, id, type) {
+  return tags(xml, 'Relationship').find(r => r.Id === id && r.Type?.endsWith(`/${type}`) && r.TargetMode !== 'External');
+}
+function packageTarget(from, target) {
+  if (!target || /[\\\0?#]/.test(target) || /^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith('//')) return null;
+  const name = posix.normalize(target.startsWith('/') ? target.slice(1) : posix.join(posix.dirname(from), target));
+  return name.startsWith('../') || name === '..' || name.startsWith('/') ? null : name;
+}
+async function readXml(zip, name) {
+  const bytes = await zip.read(name, MAX_XML_BYTES);
+  if (!bytes) return null;
+  const xml = bytes.toString('utf8');
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml)) throw new Error('Unsupported XML declaration');
+  return xml;
+}
+
+/** Header validation avoids serving arbitrary ZIP contents with an image MIME. */
+export function coverImageInfo(bytes) {
+  let width = 0; let height = 0; let mime = '';
+  if (bytes.length >= 33 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
+    && bytes.toString('ascii', 12, 16) === 'IHDR') {
+    width = bytes.readUInt32BE(16); height = bytes.readUInt32BE(20); mime = 'image/png';
+  } else if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216) {
+    for (let at = 2; at + 4 < bytes.length && at < 256 * 1024;) {
+      if (bytes[at] !== 255) return null;
+      while (bytes[at] === 255) at += 1;
+      const marker = bytes[at++];
+      if (marker === 217 || marker === 218) break;
+      if (marker === 1 || marker >= 208 && marker <= 215) continue;
+      const length = bytes.readUInt16BE(at);
+      if (length < 2 || at + length > bytes.length) return null;
+      if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker) && length >= 7) {
+        height = bytes.readUInt16BE(at + 3); width = bytes.readUInt16BE(at + 5); mime = 'image/jpeg'; break;
+      }
+      at += length;
+    }
+  }
+  return width > 1 && height > 1 && width <= 20000 && height <= 20000 && width * height <= 32_000_000
+    ? { width, height, mime } : null;
+}
+
+async function presentationInfo(zip) {
+  const presentation = await readXml(zip, 'ppt/presentation.xml');
+  const rels = await readXml(zip, 'ppt/_rels/presentation.xml.rels');
+  if (!presentation || !rels) return null;
+  const size = tags(presentation, 'sldSz')[0];
+  const width = Number(size?.cx); const height = Number(size?.cy);
+  if (!(width > 0 && height > 0 && width < 1e9 && height < 1e9)) return null;
+  const slidePaths = tags(presentation, 'sldId').map(slide => packageTarget('ppt/presentation.xml',
+    relationship(rels, qualifiedAttribute(slide, 'id'), 'slide')?.Target));
+  if (!slidePaths.length || slidePaths.length > 1000 || slidePaths.some(p => !p)) return null;
+  return { width, height, slidePaths };
+}
+
+async function fullSlideImage(zip, presentation, page) {
+  if (!presentation) return null;
+  const { width, height, slidePaths } = presentation;
+  const slidePath = slidePaths[page - 1];
+  if (!slidePath) return null;
+  const slide = await readXml(zip, slidePath);
+  const slideRels = await readXml(zip, `${posix.dirname(slidePath)}/_rels/${posix.basename(slidePath)}.rels`);
+  if (!slide || !slideRels || blocks(slide, 't').some(t => xmlDecode(t.replace(/<[^>]*>/g, '')).trim())
+    || /<(?:[\w.-]+:)?(?:graphicFrame|grpSp|AlternateContent|oleObj)\b/.test(slide)) return null;
+  const pictures = blocks(slide, 'pic');
+  if (pictures.length !== 1) return null;
+  const picture = pictures[0];
+  const transform = tags(picture, 'xfrm')[0];
+  if (!transform || Number(transform.rot ?? 0) !== 0 || ['flipH', 'flipV'].some(k => transform[k] && !['0', 'false'].includes(transform[k]))) return null;
+  const offset = tags(picture, 'off')[0]; const extent = tags(picture, 'ext')[0];
+  const near = (a, b, base) => Number.isFinite(Number(a)) && Math.abs(Number(a) - b) <= base * 0.002;
+  if (!near(offset?.x, 0, width) || !near(offset?.y, 0, height)
+    || !near(extent?.cx, width, width) || !near(extent?.cy, height, height)
+    || tags(picture, 'srcRect').some(a => Object.values(a).some(v => Number(v) !== 0))
+    || tags(picture, 'prstGeom').some(a => a.prst !== 'rect')) return null;
+  // A zero-width border at the slide edge is harmless. Any actual overlay
+  // needs Office composition, so do not silently discard titles or logos.
+  for (const shape of blocks(slide, 'sp')) {
+    const off = tags(shape, 'off')[0]; const ext = tags(shape, 'ext')[0];
+    const border = Number(ext?.cx) === 0 && (near(off?.x, 0, width) || near(off?.x, width, width))
+      || Number(ext?.cy) === 0 && (near(off?.y, 0, height) || near(off?.y, height, height));
+    if (!border) return null;
+  }
+  const blips = [...picture.matchAll(/<(?:[\w.-]+:)?blip\b([^>]*)(?:\/>|>([\s\S]*?)<\/(?:[\w.-]+:)?blip\s*>)/g)];
+  if (blips.length !== 1 || blips[0][2]?.trim()) return null;
+  const blip = attrs(blips[0][1]);
+  if (qualifiedAttribute(blip, 'link')) return null;
+  const imagePath = packageTarget(slidePath, relationship(slideRels, qualifiedAttribute(blip, 'embed'), 'image')?.Target);
+  if (!imagePath) return null;
+  const bytes = await zip.read(imagePath, MAX_IMAGE_BYTES);
+  const info = bytes && coverImageInfo(bytes);
+  if (!info || Math.abs((info.width / info.height) / (width / height) - 1) > 0.015) return null;
+  return { page, bytes, ...info, source: 'embedded-slide' };
+}
+
+/**
+ * Ordered full-slide images for OCR/vision as well as covers. Page numbers are
+ * one-based and follow presentation order. Complex slides are omitted rather
+ * than returning one misleading component of the page. All reads are bounded.
+ */
+export async function getPptxSlideImages(abs, options = {}) {
+  let handle;
+  try {
+    handle = await open(abs, 'r');
+    const zip = await zipReader(handle);
+    const presentation = await presentationInfo(zip);
+    if (!presentation) return { totalPages: 0, images: [] };
+    const totalPages = presentation.slidePaths.length;
+    const wanted = Array.isArray(options.pages) ? options.pages : Array.from({ length: totalPages }, (_, n) => n + 1);
+    const pages = [...new Set(wanted)].filter(page => Number.isInteger(page) && page > 0 && page <= totalPages).sort((a, b) => a - b);
+    const maxBytes = Math.min(128 * 1024 * 1024, Math.max(0, options.maxBytes ?? 64 * 1024 * 1024));
+    let used = 0;
+    const images = [];
+    for (const page of pages) {
+      const image = await fullSlideImage(zip, presentation, page);
+      if (!image) continue;
+      if (used + image.bytes.length > maxBytes) break;
+      used += image.bytes.length;
+      images.push(image);
+    }
+    return { totalPages, images };
+  } catch {
+    return { totalPages: 0, images: [] };
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+export async function readSlideImage(abs, page) {
+  return (await getPptxSlideImages(abs, { pages: [page] })).images[0] ?? null;
+}
+
+/** Null means use the existing renderer; malformed archives never fail a shelf. */
+export async function embeddedPptxCover(abs) {
+  let handle;
+  try {
+    handle = await open(abs, 'r');
+    const zip = await zipReader(handle);
+    const first = await fullSlideImage(zip, await presentationInfo(zip), 1);
+    if (first) return first;
+    for (const name of zip.entries.keys()) {
+      if (!/^docProps\/thumbnail\.(?:png|jpe?g)$/i.test(name)) continue;
+      const bytes = await zip.read(name, MAX_IMAGE_BYTES);
+      const info = bytes && coverImageInfo(bytes);
+      // Office often stores a 256 px thumbnail. That looks blurred on a 2x
+      // shelf card, so only use thumbnails with enough detail for the card.
+      if (info && info.width >= 480) return { bytes, ...info, source: 'embedded-thumbnail' };
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}