@heripo/pdf-parser 0.1.0

package/dist/index.js

@@ -0,0 +1,1295 @@
+import "./chunk-VUNV25KB.js";
+
+// src/core/pdf-parser.ts
+import { Docling } from "docling-sdk";
+import { execSync } from "child_process";
+import { platform } from "os";
+import { join as join5 } from "path";
+
+// src/config/constants.ts
+var PDF_PARSER = {
+  /**
+   * Default timeout for API calls in milliseconds
+   */
+  DEFAULT_TIMEOUT_MS: 1e5,
+  /**
+   * Maximum number of health check attempts before giving up
+   */
+  MAX_HEALTH_CHECK_ATTEMPTS: 60,
+  /**
+   * Interval between health check attempts in milliseconds
+   */
+  HEALTH_CHECK_INTERVAL_MS: 2e3,
+  /**
+   * Interval between log messages during health check in milliseconds
+   */
+  HEALTH_CHECK_LOG_INTERVAL_MS: 5e3,
+  /**
+   * Maximum retry attempts for server recovery on ECONNREFUSED
+   */
+  MAX_SERVER_RECOVERY_ATTEMPTS: 1
+};
+var PDF_CONVERTER = {
+  /**
+   * Interval for progress polling in milliseconds
+   */
+  POLL_INTERVAL_MS: 1e3
+};
+var DOCLING_ENVIRONMENT = {
+  /**
+   * Delay after starting docling-serve to allow startup
+   */
+  STARTUP_DELAY_MS: 2e3
+};
+var IMAGE_PDF_CONVERTER = {
+  /**
+   * ImageMagick density option (DPI) for PDF to image conversion
+   */
+  DENSITY: 300,
+  /**
+   * ImageMagick quality option (1-100)
+   */
+  QUALITY: 100
+};
+
+// ../shared/dist/index.mjs
+import { spawn } from "child_process";
+function spawnAsync(command, args, options = {}) {
+  const {
+    captureStdout = true,
+    captureStderr = true,
+    ...spawnOptions
+  } = options;
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, spawnOptions);
+    let stdout = "";
+    let stderr = "";
+    if (captureStdout && proc.stdout) {
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (captureStderr && proc.stderr) {
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    proc.on("close", (code) => {
+      resolve({ stdout, stderr, code: code ?? 0 });
+    });
+    proc.on("error", reject);
+  });
+}
+
+// src/environment/docling-environment.ts
+import { spawn as spawn2 } from "child_process";
+import { join } from "path";
+
+// src/utils/python-version.ts
+var PYTHON_VERSION_REGEX = /Python (\d+)\.(\d+)/;
+var MIN_PYTHON_VERSION = { major: 3, minor: 9 };
+var PythonVersionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PythonVersionError";
+  }
+};
+function parsePythonVersion(output) {
+  const match = output.match(PYTHON_VERSION_REGEX);
+  if (!match) return null;
+  const major = parseInt(match[1]);
+  const minor = parseInt(match[2]);
+  return {
+    major,
+    minor,
+    versionString: `${major}.${minor}`
+  };
+}
+function validatePythonVersion(version, context = "system") {
+  const { major, minor } = version;
+  const prefix = context === "venv" ? "Venv Python" : "Python";
+  if (major === 3 && minor >= 13) {
+    throw new PythonVersionError(
+      `${prefix} ${major}.${minor} is too new. docling-serve requires Python 3.11 or 3.12.`
+    );
+  }
+  if (major !== 3 || minor < MIN_PYTHON_VERSION.minor) {
+    throw new PythonVersionError("Python 3.9 or higher is required");
+  }
+}
+
+// src/environment/docling-environment.ts
+var DoclingEnvironment = class _DoclingEnvironment {
+  logger;
+  venvPath;
+  port;
+  killExistingProcess;
+  constructor(options) {
+    this.logger = options.logger;
+    this.venvPath = options.venvPath;
+    this.port = options.port;
+    this.killExistingProcess = options.killExistingProcess;
+  }
+  async setup() {
+    this.logger.info("[DoclingEnvironment] Setting up Python environment...");
+    await this.checkPythonVersion();
+    await this.setupPythonEnvironment();
+    await this.upgradePip();
+    await this.installSetuptools();
+    await this.installPyArrow();
+    await this.installDoclingServe();
+    const portInUse = await this.isPortInUse(this.port);
+    if (portInUse && !this.killExistingProcess) {
+      this.logger.info(
+        "[DoclingEnvironment] Reusing existing server on port",
+        this.port
+      );
+    } else {
+      await this.startDoclingServe();
+    }
+    this.logger.info("[DoclingEnvironment] Setup completed");
+  }
+  async checkPythonVersion() {
+    const result = await spawnAsync("python3", ["--version"]);
+    if (result.code !== 0) {
+      throw new Error("Failed to check Python version");
+    }
+    const output = result.stdout + result.stderr;
+    const version = parsePythonVersion(output);
+    if (!version) {
+      throw new Error("Could not parse Python version");
+    }
+    this.logger.info(
+      "[DoclingEnvironment] Python version:",
+      version.versionString
+    );
+    try {
+      validatePythonVersion(version, "system");
+    } catch (error) {
+      if (error instanceof PythonVersionError && version.minor >= 13) {
+        this.logger.error(
+          "[DoclingEnvironment] Python 3.13+ is not compatible. Install 3.11 or 3.12 with: pyenv install 3.12.0 && pyenv global 3.12.0"
+        );
+      }
+      throw error;
+    }
+    return version;
+  }
+  async setupPythonEnvironment() {
+    const result = await spawnAsync("python3", ["-m", "venv", this.venvPath]);
+    if (result.code !== 0) {
+      throw new Error("Failed to create Python virtual environment");
+    }
+    await this.verifyVenvPythonVersion();
+  }
+  async verifyVenvPythonVersion() {
+    const pythonPath = join(this.venvPath, "bin", "python");
+    const result = await spawnAsync(pythonPath, ["--version"]);
+    if (result.code !== 0) {
+      throw new Error("Failed to verify venv Python version");
+    }
+    const output = result.stdout + result.stderr;
+    const version = parsePythonVersion(output);
+    if (!version) {
+      throw new Error("Could not parse venv Python version");
+    }
+    validatePythonVersion(version, "venv");
+  }
+  async upgradePip() {
+    const pipPath = join(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, ["install", "--upgrade", "pip"]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to upgrade pip:",
+        result.stderr
+      );
+      throw new Error(`Failed to upgrade pip. Exit code: ${result.code}`);
+    }
+  }
+  async installSetuptools() {
+    const pipPath = join(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, [
+      "install",
+      "--upgrade",
+      "setuptools",
+      "wheel"
+    ]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to install setuptools:",
+        result.stderr
+      );
+      throw new Error(
+        `Failed to install setuptools. Exit code: ${result.code}`
+      );
+    }
+  }
+  async installPyArrow() {
+    const pipPath = join(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, [
+      "install",
+      "--only-binary",
+      ":all:",
+      "pyarrow"
+    ]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to install pyarrow:",
+        result.stderr
+      );
+      throw new Error(`Failed to install pyarrow. Exit code: ${result.code}`);
+    }
+  }
+  async installDoclingServe() {
+    const pipPath = join(this.venvPath, "bin", "pip");
+    const result = await spawnAsync(pipPath, ["install", "docling-serve"]);
+    if (result.code !== 0) {
+      this.logger.error(
+        "[DoclingEnvironment] Failed to install docling-serve:",
+        result.stderr
+      );
+      throw new Error(
+        `Failed to install docling-serve. Exit code: ${result.code}`
+      );
+    }
+  }
+  async isPortInUse(port) {
+    try {
+      const result = await spawnAsync("lsof", ["-ti", `:${port}`]);
+      return result.code === 0 && !!result.stdout.trim();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Start the docling-serve server without running full setup.
+   * Useful for restarting the server after it has crashed.
+   */
+  async startServer() {
+    await this.startDoclingServe();
+  }
+  // Process-killing logic is provided as a static method to allow reuse without instantiation
+  static async killProcessOnPort(logger, port) {
+    return new Promise((resolve) => {
+      const lsof = spawn2("lsof", ["-ti", `:${port}`]);
+      const pids = [];
+      lsof.stdout?.on("data", (data) => {
+        const txt = data.toString();
+        pids.push(
+          ...txt.split(/\s+/).map((s) => s.trim()).filter(Boolean)
+        );
+      });
+      lsof.on("close", () => {
+        if (pids.length === 0) return resolve();
+        let remaining = pids.length;
+        const done = () => {
+          if (--remaining <= 0) resolve();
+        };
+        logger.info(
+          "[DoclingEnvironment] Killing process",
+          pids.join(", "),
+          "on port",
+          port
+        );
+        for (const pid of pids) {
+          const killProc = spawn2("kill", ["-9", pid]);
+          killProc.on("close", (killCode) => {
+            if (killCode !== 0) {
+              logger.info("[DoclingEnvironment] Failed to kill process", pid);
+            }
+            done();
+          });
+          killProc.on("error", (Error2) => {
+            logger.info("[DoclingEnvironment] Failed to kill process", Error2);
+            done();
+          });
+        }
+      });
+      lsof.on("error", () => resolve());
+    });
+  }
+  async startDoclingServe() {
+    return new Promise(async (resolve, reject) => {
+      if (this.killExistingProcess) {
+        await _DoclingEnvironment.killProcessOnPort(this.logger, this.port);
+      }
+      const venvPath = this.venvPath;
+      const doclingServePath = join(venvPath, "bin", "docling-serve");
+      const args = ["run", "--port", this.port.toString()];
+      this.logger.info(
+        "[DoclingEnvironment] Starting docling-serve on port",
+        this.port
+      );
+      const doclingProcess = spawn2(doclingServePath, args, {
+        detached: true,
+        // Detached from parent process
+        stdio: "ignore"
+        // Remove stdio pipes to prevent event loop from hanging
+      });
+      doclingProcess.unref();
+      doclingProcess.on("error", (error) => {
+        this.logger.error("[DoclingEnvironment] docling-serve error:", error);
+        reject(error);
+      });
+      setTimeout(() => {
+        resolve();
+      }, DOCLING_ENVIRONMENT.STARTUP_DELAY_MS);
+    });
+  }
+};
+
+// src/core/pdf-converter.ts
+import { omit } from "es-toolkit";
+import { createWriteStream as createWriteStream2, existsSync as existsSync3, rmSync as rmSync3 } from "fs";
+import { join as join4 } from "path";
+import { pipeline } from "stream/promises";
+
+// src/errors/image-pdf-fallback-error.ts
+var ImagePdfFallbackError = class extends Error {
+  constructor(originalError, fallbackError) {
+    super(
+      `PDF conversion failed with fallback. Original: ${originalError.message}. Fallback: ${fallbackError.message}`
+    );
+    this.originalError = originalError;
+    this.fallbackError = fallbackError;
+  }
+  name = "ImagePdfFallbackError";
+};
+
+// src/processors/image-extractor.ts
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { extname, join as join2 } from "path";
+import * as yauzl from "yauzl";
+
+// src/utils/jq.ts
+import { spawn as spawn3 } from "child_process";
+function getJqPath() {
+  const p = process.env.JQ_PATH?.trim();
+  return p && p.length > 0 ? p : "jq";
+}
+function runJqFileJson(program, filePath) {
+  return new Promise((resolve, reject) => {
+    const jqPath = getJqPath();
+    const args = [
+      "-c",
+      // compact output (single line when possible)
+      program,
+      filePath
+    ];
+    const child = spawn3(jqPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const error = new Error(
+          `jq exited with code ${code}. ${stderr ? "Stderr: " + stderr : ""}`
+        );
+        return reject(error);
+      }
+      try {
+        const text = stdout.trim();
+        const parsed = JSON.parse(text);
+        resolve(parsed);
+      } catch (e) {
+        reject(
+          new Error(
+            `Failed to parse jq output as JSON. Output length=${stdout.length}. Error: ${e.message}`
+          )
+        );
+      }
+    });
+  });
+}
+function jqExtractBase64PngStrings(filePath) {
+  const program = `
+      [
+        .. |
+        select(type == "string" and startswith("data:image/png;base64"))
+      ]
+    `;
+  return runJqFileJson(program, filePath);
+}
+function jqReplaceBase64WithPaths(filePath, dirName, prefix) {
+  const program = `
+      reduce paths(type == "string" and startswith("data:image/png;base64")) as $p (
+        {data: ., counter: 0};
+        .counter as $idx |
+        .data |= setpath($p; "${dirName}/${prefix}_\\($idx).png") |
+        .counter += 1
+      ) | {data: .data, count: .counter}
+    `;
+  return runJqFileJson(program, filePath);
+}
+
+// src/processors/image-extractor.ts
+var ImageExtractor = class _ImageExtractor {
+  /**
+   * Extract a ZIP file to a target directory
+   */
+  static async extractZip(zipPath, targetDir) {
+    return new Promise((resolve, reject) => {
+      yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+        if (err || !zipfile) {
+          reject(err || new Error("Failed to open zip file"));
+          return;
+        }
+        zipfile.readEntry();
+        zipfile.on("entry", (entry) => {
+          const entryPath = join2(targetDir, entry.fileName);
+          if (/\/$/.test(entry.fileName)) {
+            mkdirSync(entryPath, { recursive: true });
+            zipfile.readEntry();
+          } else {
+            zipfile.openReadStream(entry, (err2, readStream) => {
+              if (err2 || !readStream) {
+                reject(err2 || new Error("Failed to open read stream"));
+                return;
+              }
+              mkdirSync(join2(entryPath, ".."), { recursive: true });
+              const writeStream = createWriteStream(entryPath);
+              readStream.pipe(writeStream);
+              writeStream.on("finish", () => {
+                zipfile.readEntry();
+              });
+              writeStream.on("error", reject);
+            });
+          }
+        });
+        zipfile.on("end", () => {
+          resolve();
+        });
+        zipfile.on("error", reject);
+      });
+    });
+  }
+  /**
+   * Extract base64 images from JSON file using jq (for large files)
+   * Returns array of base64 data strings
+   */
+  static async extractBase64ImagesFromJsonWithJq(jsonPath) {
+    return jqExtractBase64PngStrings(jsonPath);
+  }
+  /**
+   * Replace base64 images with file paths in JSON using jq (for large files)
+   * Uses reduce to maintain counter state while walking the JSON
+   */
+  static async replaceBase64ImagesInJsonWithJq(jsonPath, outputPath, dirName, prefix) {
+    const { data, count } = await jqReplaceBase64WithPaths(
+      jsonPath,
+      dirName,
+      prefix
+    );
+    writeFileSync(outputPath, JSON.stringify(data, null, 2), "utf-8");
+    return count;
+  }
+  /**
+   * Extract a base64-encoded image to a file and return the relative path
+   */
+  static extractBase64ImageToFile(base64Data, imagesDir, index, prefix, dirName) {
+    const PREFIX = "data:image/png;base64,";
+    const base64Content = base64Data.startsWith(PREFIX) ? base64Data.slice(PREFIX.length) : base64Data;
+    const filename = `${prefix}_${index}.png`;
+    const filepath = join2(imagesDir, filename);
+    const buffer = Buffer.from(base64Content, "base64");
+    writeFileSync(filepath, buffer);
+    return `${dirName}/${filename}`;
+  }
+  /**
+   * Save JSON and HTML documents with base64 images extracted to separate files
+   * Uses jq for JSON processing to handle large files
+   *
+   * This method:
+   * 1. Extracts base64-encoded images from JSON and HTML content
+   * 2. Saves images as separate PNG files
+   * 3. Replaces base64 data with relative file paths
+   * 4. Saves the transformed documents to the output directory
+   */
+  static async saveDocumentsWithExtractedImages(logger, outputDir, filename, jsonSourcePath, htmlContent) {
+    try {
+      if (existsSync(outputDir)) {
+        rmSync(outputDir, { recursive: true, force: true });
+      }
+    } catch (e) {
+      logger.warn("[PDFConverter] Failed to clear output directory:", e);
+    }
+    mkdirSync(outputDir, { recursive: true });
+    const baseName = filename.replace(extname(filename), "");
+    const jsonPath = join2(outputDir, `${baseName}.json`);
+    try {
+      const pagesDir = join2(outputDir, "pages");
+      if (!existsSync(pagesDir)) {
+        mkdirSync(pagesDir, { recursive: true });
+      }
+      const base64Images = await _ImageExtractor.extractBase64ImagesFromJsonWithJq(jsonSourcePath);
+      base64Images.forEach((base64Data, index) => {
+        _ImageExtractor.extractBase64ImageToFile(
+          base64Data,
+          pagesDir,
+          index,
+          "page",
+          "pages"
+        );
+      });
+      logger.info(
+        `[PDFConverter] Extracted ${base64Images.length} images from JSON to ${pagesDir}`
+      );
+      const replacedCount = await _ImageExtractor.replaceBase64ImagesInJsonWithJq(
+        jsonSourcePath,
+        jsonPath,
+        "pages",
+        "page"
+      );
+      logger.info(
+        `[PDFConverter] Replaced ${replacedCount} base64 images with file paths`
+      );
+    } catch (e) {
+      logger.warn(
+        "[PDFConverter] Failed to extract images from JSON using jq. Error:",
+        e
+      );
+      throw e;
+    }
+    logger.info("[PDFConverter] Saved JSON:", jsonPath);
+    const htmlPath = join2(outputDir, `${baseName}.html`);
+    try {
+      const imagesDir = join2(outputDir, "images");
+      if (!existsSync(imagesDir)) {
+        mkdirSync(imagesDir, { recursive: true });
+      }
+      let imageIndex = 0;
+      const transformedHtml = htmlContent.replace(
+        /src="data:image\/png;base64,([^"]+)"/g,
+        (_, base64Content) => {
+          const filename2 = `image_${imageIndex}.png`;
+          const filepath = join2(imagesDir, filename2);
+          const buffer = Buffer.from(base64Content, "base64");
+          writeFileSync(filepath, buffer);
+          const relativePath = `images/${filename2}`;
+          imageIndex += 1;
+          return `src="${relativePath}"`;
+        }
+      );
+      logger.info(
+        `[PDFConverter] Extracted ${imageIndex} images from HTML to ${imagesDir}`
+      );
+      writeFileSync(htmlPath, transformedHtml, "utf-8");
+    } catch (e) {
+      logger.warn(
+        "[PDFConverter] Failed to extract images from HTML, writing original. Error:",
+        e
+      );
+      writeFileSync(htmlPath, htmlContent, "utf-8");
+    }
+    logger.info("[PDFConverter] Saved HTML:", htmlPath);
+  }
+  /**
+   * Extract documents from ZIP and save with extracted images
+   * Uses jq for JSON processing to handle large files without loading into Node.js memory
+   *
+   * Complete workflow:
+   * 1. Extract ZIP file to temporary directory
+   * 2. Find JSON and HTML files from extracted files
+   * 3. Use jq to extract base64 images from JSON and save as separate files
+   * 4. Use jq to replace base64 with file paths in JSON
+   * 5. Process HTML with regex to extract and replace images
+   * 6. Save transformed documents to output directory (as result.json and result.html)
+   */
+  static async extractAndSaveDocumentsFromZip(logger, zipPath, extractDir, outputDir) {
+    logger.info("[PDFConverter] Extracting ZIP file...");
+    await _ImageExtractor.extractZip(zipPath, extractDir);
+    const files = readdirSync(extractDir);
+    const jsonFile = files.find((f) => extname(f).toLowerCase() === ".json");
+    const htmlFile = files.find((f) => extname(f).toLowerCase() === ".html");
+    if (!jsonFile || !htmlFile) {
+      throw new Error(
+        `Expected one JSON and one HTML file in extracted directory. Found: ${files.join(", ")}`
+      );
+    }
+    const jsonPath = join2(extractDir, jsonFile);
+    const htmlPath = join2(extractDir, htmlFile);
+    const htmlContent = readFileSync(htmlPath, "utf-8");
+    logger.info("[PDFConverter] Saving converted files to output...");
+    await _ImageExtractor.saveDocumentsWithExtractedImages(
+      logger,
+      outputDir,
+      "result",
+      jsonPath,
+      htmlContent
+    );
+    logger.info("[PDFConverter] Files saved to:", outputDir);
+  }
+};
+
+// src/utils/local-file-server.ts
+import { createReadStream, statSync } from "fs";
+import { createServer } from "http";
+import { basename } from "path";
+var LocalFileServer = class {
+  server = null;
+  port = 0;
+  /**
+   * Start serving a file and return the URL
+   *
+   * @param filePath Absolute path to the file to serve
+   * @returns URL to access the file
+   */
+  async start(filePath) {
+    const filename = basename(filePath);
+    const stat = statSync(filePath);
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        if (req.url === `/${filename}`) {
+          res.writeHead(200, {
+            "Content-Type": "application/pdf",
+            "Content-Length": stat.size
+          });
+          createReadStream(filePath).pipe(res);
+        } else {
+          res.writeHead(404);
+          res.end("Not Found");
+        }
+      });
+      this.server.on("error", reject);
+      this.server.listen(0, "127.0.0.1", () => {
+        const address = this.server.address();
+        if (typeof address === "object" && address !== null) {
+          this.port = address.port;
+          resolve(`http://127.0.0.1:${this.port}/${filename}`);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+    });
+  }
+  /**
+   * Stop the server
+   */
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.server = null;
+          this.port = 0;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+};
+
+// src/core/image-pdf-converter.ts
+import { existsSync as existsSync2, rmSync as rmSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var ImagePdfConverter = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Convert a PDF file to an image-based PDF.
+   * Downloads the PDF from URL, converts it using ImageMagick, and returns the path.
+   *
+   * @param pdfUrl - URL of the source PDF
+   * @param reportId - Report identifier for temp file naming
+   * @returns Path to the converted image PDF in temp directory
+   */
+  async convert(pdfUrl, reportId) {
+    const timestamp = Date.now();
+    const tempDir = tmpdir();
+    const inputPath = join3(tempDir, `${reportId}-${timestamp}-input.pdf`);
+    const outputPath = join3(tempDir, `${reportId}-${timestamp}-image.pdf`);
+    try {
+      this.logger.info("[ImagePdfConverter] Downloading PDF from URL...");
+      await this.downloadPdf(pdfUrl, inputPath);
+      this.logger.info("[ImagePdfConverter] Converting to image PDF...");
+      await this.convertToImagePdf(inputPath, outputPath);
+      this.logger.info("[ImagePdfConverter] Image PDF created:", outputPath);
+      return outputPath;
+    } finally {
+      if (existsSync2(inputPath)) {
+        rmSync2(inputPath, { force: true });
+      }
+    }
+  }
+  /**
+   * Download PDF from URL to local path using curl
+   */
+  async downloadPdf(url, outputPath) {
+    const result = await spawnAsync("curl", [
+      "-L",
+      // Follow redirects
+      "-o",
+      outputPath,
+      "-s",
+      // Silent mode
+      "--fail",
+      // Fail on HTTP errors
+      url
+    ]);
+    if (result.code !== 0) {
+      throw new Error(
+        `Failed to download PDF: ${result.stderr || "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Convert PDF to image-based PDF using ImageMagick
+   */
+  async convertToImagePdf(inputPath, outputPath) {
+    const result = await spawnAsync("magick", [
+      "-density",
+      IMAGE_PDF_CONVERTER.DENSITY.toString(),
+      inputPath,
+      "-quality",
+      IMAGE_PDF_CONVERTER.QUALITY.toString(),
+      outputPath
+    ]);
+    if (result.code !== 0) {
+      throw new Error(
+        `Failed to convert PDF to image PDF: ${result.stderr || "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Cleanup the temporary image PDF file
+   */
+  cleanup(imagePdfPath) {
+    if (existsSync2(imagePdfPath)) {
+      this.logger.info(
+        "[ImagePdfConverter] Cleaning up temp file:",
+        imagePdfPath
+      );
+      rmSync2(imagePdfPath, { force: true });
+    }
+  }
+};
+
+// src/core/pdf-converter.ts
+var PDFConverter = class {
+  constructor(logger, client, enableImagePdfFallback = false) {
+    this.logger = logger;
+    this.client = client;
+    this.enableImagePdfFallback = enableImagePdfFallback;
+  }
+  async convert(url, reportId, onComplete, cleanupAfterCallback, options, abortSignal) {
+    this.logger.info("[PDFConverter] Converting:", url);
+    let originalError = null;
+    try {
+      await this.performConversion(
+        url,
+        reportId,
+        onComplete,
+        cleanupAfterCallback,
+        options,
+        abortSignal
+      );
+      return;
+    } catch (error) {
+      if (abortSignal?.aborted) {
+        throw error;
+      }
+      originalError = error;
+      this.logger.error("[PDFConverter] Conversion failed:", error);
+      if (!this.enableImagePdfFallback) {
+        throw error;
+      }
+    }
+    this.logger.info("[PDFConverter] Attempting image PDF fallback...");
+    const imagePdfConverter = new ImagePdfConverter(this.logger);
+    let imagePdfPath = null;
+    try {
+      imagePdfPath = await imagePdfConverter.convert(url, reportId);
+      const localUrl = `file://${imagePdfPath}`;
+      this.logger.info("[PDFConverter] Retrying with image PDF:", localUrl);
+      await this.performConversion(
+        localUrl,
+        reportId,
+        onComplete,
+        cleanupAfterCallback,
+        options,
+        abortSignal
+      );
+      this.logger.info("[PDFConverter] Fallback conversion succeeded");
+    } catch (fallbackError) {
+      this.logger.error(
+        "[PDFConverter] Fallback conversion also failed:",
+        fallbackError
+      );
+      throw new ImagePdfFallbackError(originalError, fallbackError);
+    } finally {
+      if (imagePdfPath) {
+        imagePdfConverter.cleanup(imagePdfPath);
+      }
+    }
+  }
+  async performConversion(url, reportId, onComplete, cleanupAfterCallback, options, abortSignal) {
+    const startTime = Date.now();
+    const conversionOptions = this.buildConversionOptions(options);
+    this.logger.info(
+      "[PDFConverter] Converting document with Async Source API..."
+    );
+    this.logger.info("[PDFConverter] Server will download from URL directly");
+    this.logger.info(
+      "[PDFConverter] Results will be returned as ZIP to avoid memory limits"
+    );
+    const { httpUrl, server } = await this.resolveUrl(url);
+    try {
+      const task = await this.startConversionTask(httpUrl, conversionOptions);
+      await this.trackTaskProgress(task);
+      if (abortSignal?.aborted) {
+        this.logger.info(
+          "[PDFConverter] Conversion aborted after docling completion"
+        );
+        const error = new Error("PDF conversion was aborted");
+        error.name = "AbortError";
+        throw error;
+      }
+      await this.downloadResult(task.taskId);
+    } finally {
+      if (server) {
+        this.logger.info("[PDFConverter] Stopping local file server...");
+        await server.stop();
+      }
+    }
+    const cwd = process.cwd();
+    const zipPath = join4(cwd, "result.zip");
+    const extractDir = join4(cwd, "result_extracted");
+    const outputDir = join4(cwd, "output", reportId);
+    try {
+      await this.processConvertedFiles(zipPath, extractDir, outputDir);
+      if (abortSignal?.aborted) {
+        this.logger.info("[PDFConverter] Conversion aborted before callback");
+        const error = new Error("PDF conversion was aborted");
+        error.name = "AbortError";
+        throw error;
+      }
+      this.logger.info("[PDFConverter] Executing completion callback...");
+      await onComplete(outputDir);
+      const duration = Date.now() - startTime;
+      this.logger.info("[PDFConverter] Conversion completed successfully!");
+      this.logger.info("[PDFConverter] Total time:", duration, "ms");
+    } finally {
+      this.logger.info("[PDFConverter] Cleaning up temporary files...");
+      if (existsSync3(zipPath)) {
+        rmSync3(zipPath, { force: true });
+      }
+      if (existsSync3(extractDir)) {
+        rmSync3(extractDir, { recursive: true, force: true });
+      }
+      if (cleanupAfterCallback) {
+        this.logger.info(
+          "[PDFConverter] Cleaning up output directory:",
+          outputDir
+        );
+        if (existsSync3(outputDir)) {
+          rmSync3(outputDir, { recursive: true, force: true });
+        }
+      } else {
+        this.logger.info("[PDFConverter] Output preserved at:", outputDir);
+      }
+    }
+  }
+  buildConversionOptions(options) {
+    return {
+      ...omit(options, ["num_threads"]),
+      to_formats: ["json", "html"],
+      image_export_mode: "embedded",
+      ocr_engine: "ocrmac",
+      generate_picture_images: true,
+      images_scale: 2,
+      /**
+       * While disabling this option yields the most accurate text extraction for readable PDFs,
+       * text layers overlaid on images or drawings can introduce noise when not merged properly.
+       * In practice, archaeological report PDFs almost always contain such overlapping cases.
+       * Enabling force_ocr mitigates this risk. Although OCR may introduce minor errors compared
+       * to direct text extraction, the accuracy remains high since the source is digital, not scanned paper.
+       */
+      force_ocr: true,
+      accelerator_options: {
+        device: "mps",
+        num_threads: options.num_threads
+      }
+    };
+  }
+  async startConversionTask(url, conversionOptions) {
+    const task = await this.client.convertSourceAsync({
+      sources: [
+        {
+          kind: "http",
+          url
+        }
+      ],
+      options: conversionOptions,
+      target: {
+        kind: "zip"
+      }
+    });
+    this.logger.info(`[PDFConverter] Task created: ${task.taskId}`);
+    this.logger.info("[PDFConverter] Polling for progress...");
+    return task;
+  }
+  /**
+   * Start a local file server for file:// URLs
+   *
+   * @param url URL to check (file:// or http://)
+   * @returns Object with httpUrl and optional server to stop later
+   */
+  async resolveUrl(url) {
+    if (url.startsWith("file://")) {
+      const filePath = url.slice(7);
+      const server = new LocalFileServer();
+      const httpUrl = await server.start(filePath);
+      this.logger.info("[PDFConverter] Started local file server:", httpUrl);
+      return { httpUrl, server };
+    }
+    return { httpUrl: url };
+  }
+  async trackTaskProgress(task) {
+    const conversionStartTime = Date.now();
+    let lastStatus = "";
+    let isCompleted = false;
+    const pollInterval = setInterval(() => {
+      if (isCompleted) return;
+      const elapsed = Math.floor((Date.now() - conversionStartTime) / 1e3);
+      process.stdout.write(
+        `\r[PDFConverter] Status: ${lastStatus || "processing"} (${elapsed}s elapsed)`
+      );
+    }, PDF_CONVERTER.POLL_INTERVAL_MS);
+    task.on("progress", (status) => {
+      lastStatus = status.task_status;
+      if (status.task_position !== void 0) {
+        process.stdout.write(
+          `\r[PDFConverter] Status: ${status.task_status} (position: ${status.task_position})`
+        );
+      }
+    });
+    task.on("complete", () => {
+      isCompleted = true;
+      clearInterval(pollInterval);
+      this.logger.info("\n[PDFConverter] Conversion completed!");
+    });
+    task.on("error", (error) => {
+      isCompleted = true;
+      clearInterval(pollInterval);
+      this.logger.error("\n[PDFConverter] Conversion error:", error.message);
+    });
+    try {
+      await task.waitForCompletion();
+    } finally {
+      isCompleted = true;
+      clearInterval(pollInterval);
+    }
+  }
+  async downloadResult(taskId) {
+    this.logger.info(
+      "\n[PDFConverter] Task completed, downloading ZIP file..."
+    );
+    const zipResult = await this.client.getTaskResultFile(taskId);
+    if (!zipResult.success || !zipResult.fileStream) {
+      throw new Error("Failed to get ZIP file result");
+    }
+    const zipPath = join4(process.cwd(), "result.zip");
+    this.logger.info("[PDFConverter] Saving ZIP file to:", zipPath);
+    const writeStream = createWriteStream2(zipPath);
+    await pipeline(zipResult.fileStream, writeStream);
+  }
+  async processConvertedFiles(zipPath, extractDir, outputDir) {
+    await ImageExtractor.extractAndSaveDocumentsFromZip(
+      this.logger,
+      zipPath,
+      extractDir,
+      outputDir
+    );
+  }
+};
+
+// src/core/pdf-parser.ts
+var PDFParser = class {
+  logger;
+  port;
+  baseUrl;
+  timeout;
+  venvPath;
+  killExistingProcess;
+  enableImagePdfFallback;
+  client = null;
+  constructor(options) {
+    const {
+      logger,
+      timeout = PDF_PARSER.DEFAULT_TIMEOUT_MS,
+      venvPath,
+      killExistingProcess = false,
+      enableImagePdfFallback = false
+    } = options;
+    this.logger = logger;
+    if ("baseUrl" in options) {
+      this.baseUrl = options.baseUrl;
+      this.port = void 0;
+    } else {
+      this.port = options.port;
+      this.baseUrl = void 0;
+    }
+    this.timeout = timeout;
+    this.venvPath = venvPath || join5(process.cwd(), ".venv");
+    this.killExistingProcess = killExistingProcess;
+    this.enableImagePdfFallback = enableImagePdfFallback;
+  }
+  async init() {
+    this.logger.info("[PDFParser] Initializing...");
+    this.checkOperatingSystem();
+    this.checkJqInstalled();
+    this.checkMacOSVersion();
+    if (this.enableImagePdfFallback && !this.baseUrl) {
+      this.checkImageMagickInstalled();
+      this.checkGhostscriptInstalled();
+    } else if (this.enableImagePdfFallback && this.baseUrl) {
+      this.logger.warn(
+        "[PDFParser] enableImagePdfFallback is ignored when using external server (baseUrl)"
+      );
+    }
+    if (this.baseUrl) {
+      this.logger.info("[PDFParser] Using external server:", this.baseUrl);
+      this.client = new Docling({
+        api: { baseUrl: this.baseUrl, timeout: this.timeout }
+      });
+      await this.waitForServerReady();
+      return;
+    }
+    this.logger.info("[PDFParser] Setting up local server...");
+    try {
+      const environment = new DoclingEnvironment({
+        logger: this.logger,
+        venvPath: this.venvPath,
+        port: this.port,
+        killExistingProcess: this.killExistingProcess
+      });
+      await environment.setup();
+      const clientUrl = `http://localhost:${this.port}`;
+      this.client = new Docling({
+        api: {
+          baseUrl: clientUrl,
+          timeout: this.timeout
+        }
+      });
+      await this.waitForServerReady();
+      this.logger.info("[PDFParser] Ready");
+    } catch (error) {
+      this.logger.error("[PDFParser] Initialization failed:", error);
+      throw new Error(`Failed to initialize PDFParser: ${error}`);
+    }
+  }
+  checkOperatingSystem() {
+    if (platform() !== "darwin") {
+      throw new Error(
+        "PDFParser is only supported on macOS. Current platform: " + platform()
+      );
+    }
+  }
+  checkJqInstalled() {
+    try {
+      execSync("which jq", { stdio: "ignore" });
+    } catch {
+      throw new Error(
+        "jq is not installed. Please install jq using: brew install jq"
+      );
+    }
+  }
+  checkMacOSVersion() {
+    try {
+      const versionOutput = execSync("sw_vers -productVersion", {
+        encoding: "utf-8"
+      }).trim();
+      const versionMatch = versionOutput.match(/^(\d+)\.(\d+)/);
+      if (versionMatch) {
+        const major = parseInt(versionMatch[1]);
+        const minor = parseInt(versionMatch[2]);
+        if (major < 10 || major === 10 && minor < 15) {
+          throw new Error(
+            `macOS 10.15 or later is required. Current version: ${versionOutput}`
+          );
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("macOS 10.15")) {
+        throw error;
+      }
+      throw new Error("Failed to check macOS version");
+    }
+  }
+  checkImageMagickInstalled() {
+    try {
+      execSync("which magick", { stdio: "ignore" });
+    } catch {
+      throw new Error(
+        "ImageMagick is not installed but enableImagePdfFallback is enabled. Please install ImageMagick using: brew install imagemagick"
+      );
+    }
+  }
+  checkGhostscriptInstalled() {
+    try {
+      execSync("which gs", { stdio: "ignore" });
+    } catch {
+      throw new Error(
+        "Ghostscript is not installed but enableImagePdfFallback is enabled. Please install Ghostscript using: brew install ghostscript"
+      );
+    }
+  }
+  /**
+   * Check if an error is a connection refused error (ECONNREFUSED).
+   * This typically indicates the Docling server has crashed.
+   */
+  isConnectionRefusedError(error) {
+    if (error instanceof Error) {
+      const errorStr = JSON.stringify(error);
+      return errorStr.includes("ECONNREFUSED");
+    }
+    return false;
+  }
+  /**
+   * Restart the Docling server after it has crashed.
+   * This kills any existing process on the port, starts a new server,
+   * and waits for it to become ready.
+   *
+   * Note: This method is only called when canRecover is true,
+   * which guarantees this.port is defined.
+   */
+  async restartServer() {
+    this.logger.info("[PDFParser] Restarting server...");
+    await DoclingEnvironment.killProcessOnPort(this.logger, this.port);
+    const environment = new DoclingEnvironment({
+      logger: this.logger,
+      venvPath: this.venvPath,
+      port: this.port,
+      killExistingProcess: false
+      // Already killed above
+    });
+    await environment.startServer();
+    this.client?.destroy();
+    this.client = new Docling({
+      api: {
+        baseUrl: `http://localhost:${this.port}`,
+        timeout: this.timeout
+      }
+    });
+    await this.waitForServerReady();
+    this.logger.info("[PDFParser] Server restarted successfully");
+  }
+  async waitForServerReady() {
+    const maxAttempts = PDF_PARSER.MAX_HEALTH_CHECK_ATTEMPTS;
+    const checkInterval = PDF_PARSER.HEALTH_CHECK_INTERVAL_MS;
+    const logInterval = PDF_PARSER.HEALTH_CHECK_LOG_INTERVAL_MS;
+    let lastLogTime = 0;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await this.client.health();
+        this.logger.info("[PDFParser] Server is ready");
+        return;
+      } catch {
+        const now = Date.now();
+        if (now - lastLogTime >= logInterval) {
+          this.logger.info(
+            "[PDFParser] Waiting for server... (attempt",
+            attempt,
+            "/",
+            maxAttempts,
+            ")"
+          );
+          lastLogTime = now;
+        }
+        if (attempt < maxAttempts) {
+          await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        }
+      }
+    }
+    throw new Error("Server failed to become ready after maximum attempts");
+  }
+  async parse(url, reportId, onComplete, cleanupAfterCallback, options, abortSignal) {
+    if (!this.client) {
+      throw new Error(
+        "PDFParser is not initialized. Call init() before using parse()"
+      );
+    }
+    const canRecover = !this.baseUrl && this.port !== void 0;
+    const maxAttempts = PDF_PARSER.MAX_SERVER_RECOVERY_ATTEMPTS;
+    let attempt = 0;
+    while (attempt <= maxAttempts) {
+      try {
+        const effectiveFallbackEnabled = this.enableImagePdfFallback && !this.baseUrl;
+        const converter = new PDFConverter(
+          this.logger,
+          this.client,
+          effectiveFallbackEnabled
+        );
+        return await converter.convert(
+          url,
+          reportId,
+          onComplete,
+          cleanupAfterCallback,
+          options,
+          abortSignal
+        );
+      } catch (error) {
+        if (abortSignal?.aborted) {
+          throw error;
+        }
+        if (canRecover && this.isConnectionRefusedError(error) && attempt < maxAttempts) {
+          this.logger.warn(
+            "[PDFParser] Connection refused, attempting server recovery..."
+          );
+          await this.restartServer();
+          attempt++;
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  /**
+   * Dispose the parser instance.
+   * - Sets the internal client to null
+   * - If a local docling server was started (no baseUrl), kills the process on the configured port
+   */
+  async dispose() {
+    this.logger.info("[PDFParser] Disposing...");
+    try {
+      if (!this.baseUrl && this.port) {
+        await DoclingEnvironment.killProcessOnPort(this.logger, this.port);
+      }
+    } catch (error) {
+      this.logger.error("[PDFParser] Error while disposing:", error);
+    } finally {
+      this.client?.destroy();
+      this.client = null;
+      this.logger.info("[PDFParser] Disposed");
+    }
+  }
+};
+export {
+  ImagePdfFallbackError,
+  PDFParser
+};
+//# sourceMappingURL=index.js.map