mixdog 0.9.151 → 0.9.153

package/src/runtime/office/pdf-analysis.mjs

@@ -0,0 +1,372 @@
+import { createRequire } from 'node:module';
+import {
+  access,
+  mkdir,
+  readFile,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import {
+  DOMMatrix,
+  ImageData,
+  Path2D,
+} from '@napi-rs/canvas';
+import fontkit from '@pdf-lib/fontkit';
+import {
+  PDFDocument,
+  StandardFonts,
+  rgb,
+} from 'pdf-lib';
+import sharp from 'sharp';
+import { resolvedPdfJs } from '../attachments/pdfjs-runtime.mjs';
+import { renderPdfPages } from './pdf-render.mjs';
+
+const require = createRequire(import.meta.url);
+const MAX_QUERY_PAGES = 100;
+
+function installPdfGlobals() {
+  globalThis.DOMMatrix ??= DOMMatrix;
+  globalThis.ImageData ??= ImageData;
+  globalThis.Path2D ??= Path2D;
+}
+
+function selectedPages(total, pages) {
+  const values = Array.isArray(pages) && pages.length
+    ? [...new Set(pages.map(Number))]
+    : Array.from({ length: total }, (_, index) => index + 1);
+  if (values.length > MAX_QUERY_PAGES) throw new Error(`PDF analysis accepts at most ${MAX_QUERY_PAGES} pages per call`);
+  for (const page of values) {
+    if (!Number.isInteger(page) || page < 1 || page > total) throw new Error(`PDF page out of range: ${page}`);
+  }
+  return values;
+}
+
+async function openPdfJs(path) {
+  installPdfGlobals();
+  const pdfjs = await resolvedPdfJs();
+  const loading = pdfjs.getDocument({
+    data: new Uint8Array(await readFile(path)),
+    disableWorker: true,
+    useSystemFonts: true,
+    isEvalSupported: false,
+    verbosity: pdfjs.VerbosityLevel.ERRORS,
+  });
+  return { pdfjs, document: await loading.promise };
+}
+
+export async function extractPdfTextLayout(path, {
+  pages = null,
+  maxItems = 20_000,
+  signal = null,
+} = {}) {
+  const { pdfjs, document } = await openPdfJs(path);
+  try {
+    const output = [];
+    let truncated = false;
+    for (const pageNumber of selectedPages(document.numPages, pages)) {
+      if (signal?.aborted) throw new Error('PDF layout extraction was cancelled');
+      const page = await document.getPage(pageNumber);
+      try {
+        const viewport = page.getViewport({ scale: 1 });
+        const content = await page.getTextContent();
+        const items = [];
+        for (const item of content.items || []) {
+          if (!item?.str) continue;
+          if (output.reduce((sum, entry) => sum + entry.items.length, 0) + items.length >= maxItems) {
+            truncated = true;
+            break;
+          }
+          const transform = pdfjs.Util.transform(viewport.transform, item.transform);
+          const height = Math.max(1, Math.hypot(transform[2], transform[3]));
+          items.push({
+            text: item.str,
+            x: Number(transform[4].toFixed(2)),
+            top: Number((transform[5] - height).toFixed(2)),
+            width: Number(Number(item.width || 0).toFixed(2)),
+            height: Number(height.toFixed(2)),
+            direction: item.dir || '',
+            font: item.fontName || '',
+          });
+        }
+        output.push({
+          page: pageNumber,
+          width: Number(viewport.width.toFixed(2)),
+          height: Number(viewport.height.toFixed(2)),
+          items,
+        });
+        if (truncated) break;
+      } finally {
+        try { page.cleanup?.(); } catch {}
+      }
+    }
+    return { pageCount: document.numPages, pages: output, truncated };
+  } finally {
+    try { await document.destroy?.(); } catch {}
+  }
+}
+
+function clusterRows(items, tolerance = 3) {
+  const rows = [];
+  for (const item of [...items].sort((left, right) => left.top - right.top || left.x - right.x)) {
+    if (!String(item.text || '').trim()) continue;
+    let row = rows.find((entry) => Math.abs(entry.top - item.top) <= tolerance);
+    if (!row) {
+      row = { top: item.top, cells: [] };
+      rows.push(row);
+    }
+    row.cells.push(item);
+    row.top = (row.top * (row.cells.length - 1) + item.top) / row.cells.length;
+  }
+  return rows.map((row) => ({
+    top: Number(row.top.toFixed(2)),
+    cells: row.cells.sort((left, right) => left.x - right.x).map((item) => ({
+      text: item.text,
+      x: item.x,
+      width: item.width,
+    })),
+  }));
+}
+
+export function inferPdfTables(layout) {
+  const tables = [];
+  for (const page of layout.pages || []) {
+    const rows = clusterRows(page.items || []).filter((row) => row.cells.length >= 2);
+    if (rows.length < 2) continue;
+    const counts = new Map();
+    for (const row of rows) counts.set(row.cells.length, (counts.get(row.cells.length) || 0) + 1);
+    const [columns, repeated] = [...counts.entries()].sort((left, right) => right[1] - left[1])[0] || [0, 0];
+    const selected = rows.filter((row) => Math.abs(row.cells.length - columns) <= 1);
+    if (columns < 2 || selected.length < 2) continue;
+    tables.push({
+      page: page.page,
+      columns,
+      confidence: Number((repeated / rows.length).toFixed(3)),
+      rows: selected.map((row) => row.cells.map((cell) => cell.text)),
+      geometry: selected,
+    });
+  }
+  return {
+    pageCount: layout.pageCount,
+    tableCount: tables.length,
+    tables,
+    truncated: layout.truncated === true,
+  };
+}
+
+async function pdfImageBuffer(image) {
+  if (!image?.data || !image.width || !image.height) return null;
+  const channels = Math.round(image.data.length / (image.width * image.height));
+  if (![1, 2, 3, 4].includes(channels)) return null;
+  return await sharp(Buffer.from(image.data), {
+    raw: { width: image.width, height: image.height, channels },
+  }).png().toBuffer();
+}
+
+function resolvedPdfObject(objects, name) {
+  return new Promise((resolve, reject) => {
+    try {
+      objects.get(name, (value) => resolve(value));
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+export async function extractPdfImages(path, {
+  pages = null,
+  signal = null,
+} = {}) {
+  const { pdfjs, document } = await openPdfJs(path);
+  const images = [];
+  try {
+    for (const pageNumber of selectedPages(document.numPages, pages)) {
+      if (signal?.aborted) throw new Error('PDF image extraction was cancelled');
+      const page = await document.getPage(pageNumber);
+      try {
+        const operators = await page.getOperatorList();
+        const seen = new Set();
+        for (let index = 0; index < operators.fnArray.length; index += 1) {
+          const fn = operators.fnArray[index];
+          if (![pdfjs.OPS.paintImageXObject, pdfjs.OPS.paintInlineImageXObject].includes(fn)) continue;
+          const args = operators.argsArray[index] || [];
+          const key = fn === pdfjs.OPS.paintInlineImageXObject ? `inline-${index}` : String(args[0]);
+          if (seen.has(key)) continue;
+          seen.add(key);
+          const image = fn === pdfjs.OPS.paintInlineImageXObject
+            ? args[0]
+            : await resolvedPdfObject(page.objs, args[0]);
+          const data = await pdfImageBuffer(image);
+          if (!data) continue;
+          images.push({
+            page: pageNumber,
+            index: images.length + 1,
+            width: image.width,
+            height: image.height,
+            mimeType: 'image/png',
+            data: data.toString('base64'),
+          });
+        }
+      } finally {
+        try { page.cleanup?.(); } catch {}
+      }
+    }
+    return {
+      pageCount: document.numPages,
+      imageCount: images.length,
+      images: images.map(({ data, ...image }) => image),
+      _images: images,
+    };
+  } finally {
+    try { await document.destroy?.(); } catch {}
+  }
+}
+
+export function parseOcrTsv(value) {
+  const rows = String(value || '').split(/\r?\n/);
+  if (!rows.length) return [];
+  const header = rows.shift().split('\t');
+  const position = Object.fromEntries(header.map((name, index) => [name, index]));
+  return rows.map((line) => line.split('\t')).filter((columns) => columns.length >= header.length).map((columns) => ({
+    text: columns[position.text] || '',
+    confidence: Number(columns[position.conf] || -1),
+    left: Number(columns[position.left] || 0),
+    top: Number(columns[position.top] || 0),
+    width: Number(columns[position.width] || 0),
+    height: Number(columns[position.height] || 0),
+  })).filter((word) => word.text.trim() && word.width > 0 && word.height > 0);
+}
+
+export function parseOcrBlocks(blocks) {
+  const words = [];
+  for (const block of blocks || []) {
+    for (const paragraph of block?.paragraphs || []) {
+      for (const line of paragraph?.lines || []) {
+        for (const word of line?.words || []) {
+          const bbox = word?.bbox || {};
+          const left = Number(bbox.x0 || 0);
+          const top = Number(bbox.y0 || 0);
+          const width = Number(bbox.x1 || 0) - left;
+          const height = Number(bbox.y1 || 0) - top;
+          if (String(word?.text || '').trim() && width > 0 && height > 0) {
+            words.push({
+              text: String(word.text),
+              confidence: Number(word.confidence || 0),
+              left,
+              top,
+              width,
+              height,
+            });
+          }
+        }
+      }
+    }
+  }
+  return words;
+}
+
+async function existingPath(candidates) {
+  for (const candidate of candidates.filter(Boolean)) {
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {}
+  }
+  return '';
+}
+
+async function ocrFontPath(explicit = '') {
+  return await existingPath([
+    explicit,
+    process.env.MIXDOG_OCR_FONT,
+    process.platform === 'win32' ? 'C:\\Windows\\Fonts\\malgun.ttf' : '',
+    process.platform === 'darwin' ? '/System/Library/Fonts/AppleSDGothicNeo.ttc' : '',
+    '/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc',
+    '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',
+  ]);
+}
+
+export async function ocrPdf(path, operation, {
+  dataDir,
+  signal = null,
+} = {}) {
+  const source = await readFile(path);
+  const document = await PDFDocument.load(source, {
+    ignoreEncryption: false,
+    updateMetadata: false,
+  });
+  const pages = selectedPages(document.getPageCount(), operation.pages || (operation.page ? [operation.page] : null));
+  const languages = Array.isArray(operation.languages)
+    ? operation.languages.map(String).join('+')
+    : String(operation.languages || 'eng+kor');
+  const cachePath = join(dataDir, 'office', 'ocr', 'languages');
+  await mkdir(cachePath, { recursive: true });
+  const tesseract = require('tesseract.js');
+  const worker = await tesseract.createWorker(languages, tesseract.OEM.LSTM_ONLY, {
+    cachePath,
+    gzip: true,
+  });
+  document.registerFontkit(fontkit);
+  const fontPath = await ocrFontPath(operation.fontPath);
+  const font = fontPath
+    ? await document.embedFont(await readFile(fontPath), { subset: true })
+    : await document.embedFont(StandardFonts.Helvetica);
+  let wordCount = 0;
+  let totalConfidence = 0;
+  let text = '';
+  const temporaryImages = [];
+  try {
+    for (const pageNumber of pages) {
+      if (signal?.aborted) throw new Error('PDF OCR was cancelled');
+      const rendered = await renderPdfPages(path, {
+        pages: [pageNumber],
+        maxWidth: Math.max(1200, Math.min(3200, Number(operation.maxWidth) || 2400)),
+        signal,
+      });
+      const image = rendered.images[0];
+      temporaryImages.push(image.path);
+      const recognized = await worker.recognize(image.path, {}, { text: true, tsv: true, blocks: true });
+      const positionedWords = parseOcrTsv(recognized.data.tsv);
+      const words = (positionedWords.length ? positionedWords : parseOcrBlocks(recognized.data.blocks))
+        .filter((word) => word.confidence >= Number(operation.minConfidence ?? 40));
+      const page = document.getPage(pageNumber - 1);
+      const scaleX = page.getWidth() / image.width;
+      const scaleY = page.getHeight() / image.height;
+      for (const word of words) {
+        try {
+          page.drawText(word.text, {
+            x: word.left * scaleX,
+            y: page.getHeight() - (word.top + word.height) * scaleY,
+            size: Math.max(4, word.height * scaleY * 0.8),
+            font,
+            color: rgb(0, 0, 0),
+            opacity: 0,
+          });
+          wordCount += 1;
+          totalConfidence += word.confidence;
+        } catch (error) {
+          if (!fontPath && /encode|WinAnsi/i.test(String(error?.message || ''))) {
+            throw new Error('OCR detected non-Latin text but no Unicode OCR font is available; add fontPath or MIXDOG_OCR_FONT');
+          }
+          throw error;
+        }
+      }
+      text += `${text ? '\n\n' : ''}--- Page ${pageNumber} ---\n${recognized.data.text || ''}`;
+    }
+    if (wordCount > 0) await writeFile(path, await document.save({ useObjectStreams: true, addDefaultPage: false }));
+    return {
+      op: operation.op,
+      changed: wordCount > 0,
+      pages,
+      languages,
+      wordCount,
+      averageConfidence: wordCount ? Number((totalConfidence / wordCount).toFixed(2)) : 0,
+      text,
+      searchableTextLayer: wordCount > 0,
+      fontEmbedded: Boolean(fontPath),
+    };
+  } finally {
+    await worker.terminate().catch(() => {});
+    for (const image of temporaryImages) await rm(image, { force: true }).catch(() => {});
+  }
+}

package/src/runtime/office/pdf-render.mjs

@@ -0,0 +1,167 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import {
+  DOMMatrix,
+  ImageData,
+  Path2D,
+  createCanvas,
+} from '@napi-rs/canvas';
+import { resolvedPdfJs } from '../attachments/pdfjs-runtime.mjs';
+
+function installPdfJsCanvasGlobals() {
+  globalThis.DOMMatrix ??= DOMMatrix;
+  globalThis.ImageData ??= ImageData;
+  globalThis.Path2D ??= Path2D;
+}
+
+function requestedPages(pageCount, pages) {
+  const selected = Array.isArray(pages) && pages.length
+    ? pages
+    : Array.from({ length: pageCount }, (_, index) => index + 1);
+  const unique = [...new Set(selected.map(Number))];
+  if (Array.isArray(pages) && pages.length && unique.length > 12) {
+    throw new Error('render accepts at most 12 explicit pages per call');
+  }
+  for (const page of unique) {
+    if (!Number.isInteger(page) || page < 1 || page > pageCount) {
+      throw new Error(`render page out of range: ${page} (document has ${pageCount})`);
+    }
+  }
+  return unique;
+}
+
+export async function renderPdfPages(path, {
+  pages = null,
+  maxWidth = 1400,
+  signal = null,
+} = {}) {
+  if (signal?.aborted) throw new Error('PDF rendering was cancelled');
+  installPdfJsCanvasGlobals();
+  const { getDocument, VerbosityLevel } = await resolvedPdfJs();
+  const loading = getDocument({
+    data: new Uint8Array(await readFile(path)),
+    disableWorker: true,
+    useSystemFonts: true,
+    isEvalSupported: false,
+    verbosity: VerbosityLevel.ERRORS,
+  });
+  const document = await loading.promise;
+  try {
+    const selected = requestedPages(document.numPages, pages);
+    const stem = basename(path, extname(path));
+    const output = [];
+    const renderPage = async (pageNumber, targetWidth, minimumScale = 0.25) => {
+      if (signal?.aborted) throw new Error('PDF rendering was cancelled');
+      const page = await document.getPage(pageNumber);
+      try {
+        const base = page.getViewport({ scale: 1 });
+        const scale = Math.min(2, Math.max(minimumScale, Number(targetWidth || 1400) / base.width));
+        const viewport = page.getViewport({ scale });
+        const canvas = createCanvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+        const context = canvas.getContext('2d');
+        await page.render({
+          canvas,
+          canvasContext: context,
+          viewport,
+          background: 'rgb(255,255,255)',
+        }).promise;
+        if (signal?.aborted) throw new Error('PDF rendering was cancelled');
+        return canvas;
+      } finally {
+        try { page.cleanup?.(); } catch {}
+      }
+    };
+    if (selected.length <= 12) {
+      for (const pageNumber of selected) {
+        const canvas = await renderPage(pageNumber, maxWidth);
+        const data = canvas.toBuffer('image/png');
+        const imagePath = join(dirname(path), `${stem}-page-${pageNumber}.png`);
+        await writeFile(imagePath, data);
+        output.push({
+          page: pageNumber,
+          path: imagePath,
+          width: canvas.width,
+          height: canvas.height,
+          mimeType: 'image/png',
+          data: data.toString('base64'),
+        });
+      }
+    } else {
+      const width = Math.max(256, Number(maxWidth) || 1400);
+      const pagesPerSheet = Math.ceil(selected.length / 12);
+      for (let offset = 0; offset < selected.length; offset += pagesPerSheet) {
+        const group = selected.slice(offset, offset + pagesPerSheet);
+        const columns = group.length <= 2
+          ? 1
+          : Math.max(2, Math.ceil(Math.sqrt(group.length * 0.75)));
+        const rows = Math.ceil(group.length / columns);
+        const gap = 12;
+        const labelHeight = 24;
+        const cellWidth = Math.max(64, Math.floor((width - (columns + 1) * gap) / columns));
+        const thumbnails = [];
+        for (const pageNumber of group) {
+          thumbnails.push({
+            page: pageNumber,
+            canvas: await renderPage(pageNumber, cellWidth, 0.05),
+          });
+        }
+        const cellHeight = Math.max(...thumbnails.map(({ canvas }) => canvas.height));
+        const sheet = createCanvas(
+          width,
+          gap + rows * (labelHeight + cellHeight + gap),
+        );
+        const context = sheet.getContext('2d');
+        context.fillStyle = 'rgb(238,240,244)';
+        context.fillRect(0, 0, sheet.width, sheet.height);
+        context.font = '16px sans-serif';
+        context.textBaseline = 'middle';
+        for (let index = 0; index < thumbnails.length; index += 1) {
+          const { page: pageNumber, canvas } = thumbnails[index];
+          const column = index % columns;
+          const row = Math.floor(index / columns);
+          const x = gap + column * (cellWidth + gap);
+          const y = gap + row * (labelHeight + cellHeight + gap);
+          context.fillStyle = 'rgb(45,50,60)';
+          context.fillText(`Page ${pageNumber}`, x, y + labelHeight / 2);
+          context.fillStyle = 'rgb(255,255,255)';
+          context.fillRect(x, y + labelHeight, cellWidth, cellHeight);
+          context.drawImage(canvas, x, y + labelHeight);
+          context.strokeStyle = 'rgb(180,185,195)';
+          context.strokeRect(x, y + labelHeight, canvas.width, canvas.height);
+        }
+        const data = sheet.toBuffer('image/png');
+        const first = group[0];
+        const last = group.at(-1);
+        const imagePath = join(dirname(path), `${stem}-pages-${first}-${last}.png`);
+        await writeFile(imagePath, data);
+        output.push({
+          page: first,
+          pages: group,
+          path: imagePath,
+          width: sheet.width,
+          height: sheet.height,
+          mimeType: 'image/png',
+          data: data.toString('base64'),
+        });
+      }
+    }
+    const reviewedPages = output.flatMap((image) => image.pages || [image.page]);
+    const reviewedPageSet = new Set(reviewedPages);
+    return {
+      pageCount: document.numPages,
+      images: output,
+      visualCoverage: {
+        reviewedPages,
+        reviewed: reviewedPages.length,
+        total: document.numPages,
+        complete: reviewedPages.length === document.numPages,
+        remainingPages: Array.from(
+          { length: document.numPages },
+          (_, index) => index + 1,
+        ).filter((page) => !reviewedPageSet.has(page)),
+      },
+    };
+  } finally {
+    try { await document.destroy?.(); } catch {}
+  }
+}

package/src/runtime/office/pdf-security.mjs

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { writeFile, rm, rename } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+function run(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('close', (code) => {
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(stderr.trim() || stdout.trim() || `qpdf exited with code ${code}`));
+    });
+  });
+}
+
+export async function qpdfAvailable() {
+  try {
+    await run('qpdf', ['--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function securePdf({
+  input,
+  output,
+  mode,
+  password = '',
+  ownerPassword = '',
+}) {
+  if (!await qpdfAvailable()) {
+    throw new Error('PDF encryption/decryption requires qpdf; it is not installed in this environment');
+  }
+  const samePath = input.toLowerCase() === output.toLowerCase();
+  const target = samePath
+    ? join(dirname(output), `.mixdog-qpdf-${randomUUID()}.pdf`)
+    : output;
+  const responsePath = join(dirname(target), `.mixdog-qpdf-${randomUUID()}.args`);
+  const quote = (value) => `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+  const args = mode === 'encrypt'
+    ? ['--encrypt', password, ownerPassword || password, '256', '--', input, target]
+    : [`--password=${password}`, '--decrypt', input, target];
+  await writeFile(responsePath, `${args.map(quote).join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+  try {
+    await run('qpdf', [`@${responsePath}`]);
+    if (samePath) await rename(target, output);
+    return { ok: true, mode, input, output };
+  } finally {
+    await rm(responsePath, { force: true }).catch(() => {});
+    if (samePath) await rm(target, { force: true }).catch(() => {});
+  }
+}