markpdfdown 0.1.0

package/dist/main/index.js

@@ -0,0 +1,3523 @@
+import { app, ipcMain, dialog, protocol, BrowserWindow, shell } from "electron";
+import path from "path";
+import fs, { promises } from "fs";
+import isDev from "electron-is-dev";
+import { randomUUID } from "crypto";
+import pkg from "@prisma/client";
+import { EventEmitter } from "events";
+import { pdfToPng } from "pdf-to-png-converter";
+import { PDFDocument } from "pdf-lib";
+import sharp from "sharp";
+import fs$1 from "fs/promises";
+import { v4 } from "uuid";
+import __cjs_mod__ from "node:module";
+const __filename = import.meta.filename;
+const __dirname = import.meta.dirname;
+const require2 = __cjs_mod__.createRequire(import.meta.url);
+const getMigrationsDir = () => {
+  if (isDev) {
+    return path.join(
+      process.cwd(),
+      "src",
+      "core",
+      "infrastructure",
+      "db",
+      "migrations"
+    );
+  }
+  if (app) {
+    return path.join(app.getAppPath(), "..", "migrations");
+  }
+  return path.join(__dirname, "migrations");
+};
+const createMigrationsTableSQL = `
+CREATE TABLE IF NOT EXISTS _prisma_migrations (
+  id                    VARCHAR(36) PRIMARY KEY NOT NULL,
+  checksum              VARCHAR(64) NOT NULL,
+  finished_at           DATETIME,
+  migration_name        VARCHAR(255) NOT NULL,
+  logs                  TEXT,
+  rolled_back_at        DATETIME,
+  started_at            DATETIME NOT NULL DEFAULT current_timestamp,
+  applied_steps_count   INTEGER UNSIGNED NOT NULL DEFAULT 0
+);
+`;
+const recordMigration = async (prisma2, migrationName, checksum) => {
+  const id = generateUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await prisma2.$executeRaw`
+      INSERT INTO _prisma_migrations (
+        id, checksum, migration_name, started_at, finished_at, applied_steps_count
+      ) VALUES (
+        ${id}, ${checksum}, ${migrationName}, ${now}, ${now}, 1
+      );
+    `;
+    console.log(`Recorded migration: ${migrationName}`);
+  } catch (error) {
+    console.error(`Failed to record migration ${migrationName}:`, error);
+  }
+};
+const generateUUID = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+const calculateChecksum = async (content) => {
+  const crypto = await import("crypto");
+  return crypto.default.createHash("sha256").update(content).digest("hex");
+};
+const applyMigration = async (prisma2, migrationDir, migrationName) => {
+  const sqlFilePath = path.join(migrationDir, migrationName, "migration.sql");
+  try {
+    if (!fs.existsSync(sqlFilePath)) {
+      console.error(`Migration SQL file not found: ${sqlFilePath}`);
+      return false;
+    }
+    const sqlContent = fs.readFileSync(sqlFilePath, "utf8");
+    const sqlStatements = sqlContent.split(";").filter((stmt) => stmt.trim());
+    for (const statement of sqlStatements) {
+      if (statement.trim()) {
+        await prisma2.$executeRawUnsafe(statement.trim());
+      }
+    }
+    const checksum = await calculateChecksum(sqlContent);
+    await recordMigration(prisma2, migrationName, checksum);
+    console.log(`Successfully applied migration: ${migrationName}`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to apply migration ${migrationName}:`, error);
+    return false;
+  }
+};
+const getAppliedMigrations = async (prisma2) => {
+  try {
+    const tableExists = await prisma2.$queryRaw`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='_prisma_migrations';
+    `;
+    if (!tableExists || tableExists.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    const migrations = await prisma2.$queryRaw`
+      SELECT migration_name FROM _prisma_migrations
+      WHERE finished_at IS NOT NULL;
+    `;
+    return new Set(migrations.map((m) => m.migration_name));
+  } catch (error) {
+    console.error("Error getting applied migrations:", error);
+    return /* @__PURE__ */ new Set();
+  }
+};
+const runMigrations = async (prisma2 = null) => {
+  const startTime = Date.now();
+  console.log("Running database migrations...");
+  try {
+    await prisma2.$executeRawUnsafe(createMigrationsTableSQL);
+    const migrationsDir = getMigrationsDir();
+    console.log("Migrations directory:", migrationsDir);
+    if (!fs.existsSync(migrationsDir)) {
+      console.error(`Migrations directory not found: ${migrationsDir}`);
+      return false;
+    }
+    const appliedMigrations = await getAppliedMigrations(prisma2);
+    const migrationDirs = fs.readdirSync(migrationsDir, { withFileTypes: true }).filter(
+      (dirent) => dirent.isDirectory() && dirent.name !== "migration_lock.toml"
+    ).map((dirent) => dirent.name).sort();
+    let migrationsApplied = 0;
+    for (const migrationName of migrationDirs) {
+      const isApplied = appliedMigrations.has(migrationName);
+      if (!isApplied) {
+        console.log(`Applying migration: ${migrationName}`);
+        const success = await applyMigration(
+          prisma2,
+          migrationsDir,
+          migrationName
+        );
+        if (success) migrationsApplied++;
+      } else {
+        console.log(`Migration already applied: ${migrationName}`);
+      }
+    }
+    const elapsed = Date.now() - startTime;
+    console.log(
+      `Database migration complete. Applied ${migrationsApplied} migrations in ${elapsed}ms`
+    );
+    return migrationsApplied > 0;
+  } catch (error) {
+    console.error("Migration error:", error);
+    return false;
+  }
+};
+const { PrismaClient } = pkg;
+function getDatabaseUrl() {
+  if (!isDev) {
+    const userDataPath = app.getPath("userData");
+    const dbDir = path.join(userDataPath, "db");
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+    console.log(
+      "Using userData database path:",
+      `file:${path.join(dbDir, "app.db")}`
+    );
+    return `file:${path.join(dbDir, "app.db")}`;
+  }
+  console.log(
+    "Using default development database path:",
+    `file:${path.join(process.cwd(), "src", "core", "db", "dev.db")}`
+  );
+  return `file:${path.join(process.cwd(), "src", "core", "infrastructure", "db", "dev.db")}`;
+}
+const dbUrl = getDatabaseUrl();
+const prisma = new PrismaClient({
+  datasources: {
+    db: {
+      url: dbUrl
+    }
+  }
+});
+const initDatabase = async () => {
+  try {
+    console.log(`Initializing database(url:${dbUrl})...`);
+    await prisma.$queryRaw`SELECT 1`;
+    console.log("Database connection established successfully.");
+    await runMigrations(prisma);
+    return true;
+  } catch (error) {
+    console.error("Database initialization error:", error);
+    return false;
+  }
+};
+const disconnect = async () => {
+  await prisma.$disconnect();
+  console.log("Database connection has been closed");
+};
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2[TaskStatus2["CREATED"] = -1] = "CREATED";
+  TaskStatus2[TaskStatus2["FAILED"] = 0] = "FAILED";
+  TaskStatus2[TaskStatus2["PENDING"] = 1] = "PENDING";
+  TaskStatus2[TaskStatus2["SPLITTING"] = 2] = "SPLITTING";
+  TaskStatus2[TaskStatus2["PROCESSING"] = 3] = "PROCESSING";
+  TaskStatus2[TaskStatus2["READY_TO_MERGE"] = 4] = "READY_TO_MERGE";
+  TaskStatus2[TaskStatus2["MERGING"] = 5] = "MERGING";
+  TaskStatus2[TaskStatus2["COMPLETED"] = 6] = "COMPLETED";
+  TaskStatus2[TaskStatus2["CANCELLED"] = 7] = "CANCELLED";
+  TaskStatus2[TaskStatus2["PARTIAL_FAILED"] = 8] = "PARTIAL_FAILED";
+  return TaskStatus2;
+})(TaskStatus || {});
+var PageStatus = /* @__PURE__ */ ((PageStatus2) => {
+  PageStatus2[PageStatus2["FAILED"] = -1] = "FAILED";
+  PageStatus2[PageStatus2["PENDING"] = 0] = "PENDING";
+  PageStatus2[PageStatus2["PROCESSING"] = 1] = "PROCESSING";
+  PageStatus2[PageStatus2["COMPLETED"] = 2] = "COMPLETED";
+  PageStatus2[PageStatus2["RETRYING"] = 3] = "RETRYING";
+  return PageStatus2;
+})(PageStatus || {});
+var TaskEventType = /* @__PURE__ */ ((TaskEventType2) => {
+  TaskEventType2["TASK_UPDATED"] = "task:updated";
+  TaskEventType2["TASK_STATUS_CHANGED"] = "task:status_changed";
+  TaskEventType2["TASK_PROGRESS_CHANGED"] = "task:progress_changed";
+  TaskEventType2["TASK_DELETED"] = "task:deleted";
+  TaskEventType2["TASK_DETAIL_UPDATED"] = "taskDetail:updated";
+  return TaskEventType2;
+})(TaskEventType || {});
+class EventBus extends EventEmitter {
+  static instance;
+  constructor() {
+    super();
+    this.setMaxListeners(100);
+  }
+  static getInstance() {
+    if (!EventBus.instance) {
+      EventBus.instance = new EventBus();
+    }
+    return EventBus.instance;
+  }
+  emitTaskEvent(type, data) {
+    this.emit(type, data);
+    this.emit("task:*", { type, ...data });
+  }
+  emitTaskDetailEvent(type, data) {
+    this.emit(type, data);
+    this.emit("taskDetail:*", { type, ...data });
+  }
+  onTaskEvent(type, handler) {
+    this.on(type, handler);
+  }
+  onTaskDetailEvent(type, handler) {
+    this.on(type, handler);
+  }
+}
+const eventBus = EventBus.getInstance();
+class WorkerBase {
+  /** Unique worker identifier */
+  workerId;
+  /** Flag to control worker execution */
+  isRunning = false;
+  constructor() {
+    this.workerId = randomUUID();
+  }
+  /**
+   * Stop the worker gracefully.
+   * Sets isRunning flag to false, causing run() loop to exit.
+   */
+  stop() {
+    this.isRunning = false;
+    console.log(`[Worker-${this.workerId}] Stopping...`);
+  }
+  /**
+   * Atomically claim a task for processing.
+   *
+   * Uses Prisma transaction to ensure only one worker claims a task.
+   * The transaction:
+   * 1. Finds first available task matching fromStatus
+   * 2. Updates it to toStatus with this worker's ID
+   * 3. Returns the claimed task or null if none available
+   *
+   * @param fromStatus - Source status to claim from
+   * @param toStatus - Target status to set
+   * @returns Claimed task or null if no tasks available
+   */
+  async claimTask(fromStatus, toStatus) {
+    try {
+      const claimed = await prisma.$transaction(async (tx) => {
+        const task = await tx.task.findFirst({
+          where: {
+            status: fromStatus,
+            worker_id: null
+          },
+          orderBy: {
+            createdAt: "asc"
+            // FIFO order
+          }
+        });
+        if (!task) {
+          return null;
+        }
+        const updated = await tx.task.update({
+          where: {
+            id: task.id
+          },
+          data: {
+            status: toStatus,
+            worker_id: this.workerId,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        return updated;
+      });
+      if (claimed) {
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId: claimed.id,
+          task: claimed,
+          timestamp: Date.now()
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+          taskId: claimed.id,
+          task: { status: toStatus },
+          timestamp: Date.now()
+        });
+      }
+      return claimed;
+    } catch (error) {
+      console.error(`[Worker-${this.workerId}] Failed to claim task:`, error);
+      return null;
+    }
+  }
+  /**
+   * Update task status.
+   *
+   * @param taskId - Task ID to update
+   * @param status - New status
+   * @param data - Optional additional data to update
+   */
+  async updateTaskStatus(taskId, status, data) {
+    try {
+      const updated = await prisma.task.update({
+        where: {
+          id: taskId
+        },
+        data: {
+          status,
+          ...data,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+        taskId,
+        task: updated,
+        timestamp: Date.now()
+      });
+      if (status !== void 0) {
+        eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+          taskId,
+          task: { status },
+          timestamp: Date.now()
+        });
+      }
+      if (data?.progress !== void 0) {
+        eventBus.emitTaskEvent(TaskEventType.TASK_PROGRESS_CHANGED, {
+          taskId,
+          task: { progress: data.progress },
+          timestamp: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error(`[Worker-${this.workerId}] Failed to update task ${taskId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Handle task error.
+   * Sets task status to FAILED and stores error message.
+   *
+   * @param taskId - Task ID
+   * @param error - Error object or message
+   */
+  async handleError(taskId, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[Worker-${this.workerId}] Task ${taskId} failed:`, errorMessage);
+    try {
+      const updated = await prisma.task.update({
+        where: {
+          id: taskId
+        },
+        data: {
+          status: TaskStatus.FAILED,
+          error: errorMessage,
+          worker_id: null,
+          // Release worker
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+        taskId,
+        task: updated,
+        timestamp: Date.now()
+      });
+      eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+        taskId,
+        task: { status: TaskStatus.FAILED },
+        timestamp: Date.now()
+      });
+    } catch (updateError) {
+      console.error(
+        `[Worker-${this.workerId}] Failed to update task ${taskId} error state:`,
+        updateError
+      );
+    }
+  }
+  /**
+   * Sleep for the specified duration.
+   *
+   * @param ms - Milliseconds to sleep
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get worker ID.
+   */
+  getWorkerId() {
+    return this.workerId;
+  }
+  /**
+   * Check if worker is running.
+   */
+  getIsRunning() {
+    return this.isRunning;
+  }
+}
+class ImagePathUtil {
+  static uploadsDir = null;
+  /**
+   * Initialize the utility with the uploads directory path.
+   * Must be called once at application startup.
+   *
+   * @param uploadsDir - Base uploads directory path (e.g., {userData}/files)
+   */
+  static init(uploadsDir) {
+    this.uploadsDir = uploadsDir;
+  }
+  /**
+   * Get the full path to a page image file.
+   *
+   * @param taskId - Task ID
+   * @param page - Page number (1-based)
+   * @returns Full path to the image file (e.g., {uploadsDir}/{taskId}/split/page-{page}.png)
+   * @throws Error if utility is not initialized
+   */
+  static getPath(taskId, page) {
+    if (!this.uploadsDir) {
+      throw new Error("ImagePathUtil not initialized. Call ImagePathUtil.init() first.");
+    }
+    return path.join(this.uploadsDir, taskId, "split", `page-${page}.png`);
+  }
+  /**
+   * Get the task split directory path (contains all page images).
+   *
+   * @param taskId - Task ID
+   * @returns Full path to the split directory (e.g., {uploadsDir}/{taskId}/split)
+   * @throws Error if utility is not initialized
+   */
+  static getTaskDir(taskId) {
+    if (!this.uploadsDir) {
+      throw new Error("ImagePathUtil not initialized. Call ImagePathUtil.init() first.");
+    }
+    return path.join(this.uploadsDir, taskId, "split");
+  }
+  /**
+   * Get the uploads directory (for testing/debugging).
+   *
+   * @returns The uploads directory path or null if not initialized
+   */
+  static getUploadsDir() {
+    return this.uploadsDir;
+  }
+  /**
+   * Reset the utility (for testing purposes only).
+   */
+  static reset() {
+    this.uploadsDir = null;
+  }
+}
+class PageRangeParser {
+  /**
+   * Regular expression for validating page range format.
+   * Matches patterns like "1", "1-5", "1,3,5", "1-5,7,11-14"
+   */
+  static RANGE_REGEX = /^(\d+(-\d+)?(,\d+(-\d+)?)*)$/;
+  /**
+   * Parse a page range string into an array of page numbers.
+   *
+   * @param rangeStr - Page range string (e.g., "1-5,7,11-14") or null/empty for all pages
+   * @param totalPages - Total number of pages in the document
+   * @returns Sorted, deduplicated array of 1-based page numbers
+   * @throws Error if format is invalid or pages are out of bounds
+   *
+   * @example
+   * parse("1-3,5", 10) // [1, 2, 3, 5]
+   * parse("", 5) // [1, 2, 3, 4, 5]
+   * parse(null, 5) // [1, 2, 3, 4, 5]
+   * parse("3,1,2,2", 10) // [1, 2, 3] (sorted and deduplicated)
+   */
+  static parse(rangeStr, totalPages) {
+    if (!rangeStr || rangeStr.trim() === "") {
+      return Array.from({ length: totalPages }, (_, i) => i + 1);
+    }
+    const normalized = rangeStr.trim().replace(/\s+/g, "");
+    if (!this.validate(normalized)) {
+      throw new Error(`Invalid page range format: "${rangeStr}". Use formats like "1", "1-5", "1,3,5", or "1-5,7,11-14"`);
+    }
+    const pages = /* @__PURE__ */ new Set();
+    const parts = normalized.split(",");
+    for (const part of parts) {
+      if (part.includes("-")) {
+        const [startStr, endStr] = part.split("-");
+        const start = parseInt(startStr, 10);
+        const end = parseInt(endStr, 10);
+        if (start > end) {
+          throw new Error(`Invalid range: ${part}. Start page must be less than or equal to end page.`);
+        }
+        const clampedStart = Math.max(1, Math.min(start, totalPages));
+        const clampedEnd = Math.max(1, Math.min(end, totalPages));
+        if (start < 1 || end > totalPages || start > totalPages) {
+          console.warn(
+            `[PageRangeParser] Requested page range ${part} adjusted to fit document bounds (1-${totalPages})`
+          );
+        }
+        if (start > totalPages) {
+          continue;
+        }
+        for (let i = clampedStart; i <= clampedEnd; i++) {
+          pages.add(i);
+        }
+      } else {
+        const page = parseInt(part, 10);
+        if (page < 1 || page > totalPages) {
+          console.warn(
+            `[PageRangeParser] Page ${page} is out of bounds (valid: 1-${totalPages}), skipping`
+          );
+          continue;
+        }
+        pages.add(page);
+      }
+    }
+    const result = Array.from(pages).sort((a, b) => a - b);
+    if (result.length === 0) {
+      throw new Error(
+        `No valid pages found in range "${rangeStr}". Document has ${totalPages} page(s), valid range: 1-${totalPages}`
+      );
+    }
+    return result;
+  }
+  /**
+   * Validate a page range string format (without checking bounds).
+   *
+   * @param rangeStr - Page range string to validate
+   * @returns True if format is valid, false otherwise
+   *
+   * @example
+   * validate("1-5") // true
+   * validate("1,3,5") // true
+   * validate("abc") // false
+   * validate("1-") // false
+   */
+  static validate(rangeStr) {
+    if (!rangeStr || rangeStr.trim() === "") {
+      return true;
+    }
+    return this.RANGE_REGEX.test(rangeStr.trim());
+  }
+}
+const WORKER_CONFIG = {
+  /**
+   * Splitter worker configuration.
+   * Handles PDF and image splitting into individual pages.
+   */
+  splitter: {
+    /** Poll interval for checking new tasks (ms) */
+    pollInterval: 2e3,
+    /** PDF to PNG viewport scale (~144 DPI at 2.0) */
+    viewportScale: 2,
+    /** Output image format */
+    imageFormat: "png",
+    /** Maximum retry attempts for transient errors */
+    maxRetries: 3,
+    /** Base retry delay in milliseconds (exponential backoff) */
+    retryDelayBase: 1e3
+  },
+  /**
+   * Converter worker configuration.
+   * Handles image to markdown conversion via LLM.
+   */
+  converter: {
+    /** Number of parallel converter workers */
+    count: 3,
+    /** Poll interval for checking new task details (ms) */
+    pollInterval: 2e3,
+    /** Timeout for LLM conversion (ms) */
+    timeout: 12e4,
+    // 2 minutes
+    /** Maximum retry attempts for transient errors */
+    maxRetries: 3,
+    /** Base retry delay in milliseconds (exponential backoff) */
+    retryDelayBase: 1e3,
+    /** Maximum content length in characters */
+    maxContentLength: 5e5
+  },
+  /**
+   * Merger worker configuration.
+   * Handles merging markdown pages into final document.
+   */
+  merger: {
+    /** Poll interval for checking tasks ready to merge (ms) */
+    pollInterval: 2e3
+  },
+  /**
+   * Health check configuration.
+   * Monitors and recovers stuck workers/tasks.
+   */
+  healthCheck: {
+    /** Health check interval (ms) */
+    interval: 6e4,
+    // 1 minute
+    /** Task timeout threshold (ms) */
+    taskTimeout: 3e5
+    // 5 minutes
+  }
+};
+class PDFSplitter {
+  uploadsDir;
+  constructor(uploadsDir) {
+    this.uploadsDir = uploadsDir;
+  }
+  /**
+   * Split a PDF file into individual page images.
+   *
+   * @param task - Task containing PDF file information
+   * @returns Split result with page information
+   * @throws Error if splitting fails after retries
+   */
+  async split(task) {
+    if (!task.id) {
+      throw new Error("Task ID is required");
+    }
+    if (!task.filename) {
+      throw new Error("Task filename is required");
+    }
+    const taskId = task.id;
+    const filename = task.filename;
+    const sourcePath = path.join(this.uploadsDir, taskId, filename);
+    try {
+      const totalPages = await this.getPDFPageCountWithRetry(sourcePath);
+      const pageNumbers = PageRangeParser.parse(task.page_range, totalPages);
+      const pages = await this.convertPagesWithRetry(
+        sourcePath,
+        taskId,
+        pageNumbers,
+        task.page_range
+      );
+      return {
+        pages,
+        totalPages: pages.length
+      };
+    } catch (error) {
+      throw this.wrapError(error, taskId, filename);
+    }
+  }
+  /**
+   * Get PDF page count with retry logic.
+   * Uses pdf-lib for accurate page count without converting pages.
+   */
+  async getPDFPageCountWithRetry(pdfPath) {
+    return this.withRetry(async () => {
+      const pdfBytes = await promises.readFile(pdfPath);
+      const pdfDoc = await PDFDocument.load(pdfBytes, {
+        ignoreEncryption: false
+        // Will throw error for encrypted PDFs
+      });
+      const pageCount = pdfDoc.getPageCount();
+      if (pageCount < 1) {
+        throw new Error("PDF has no pages");
+      }
+      return pageCount;
+    }, "get PDF page count");
+  }
+  /**
+   * Convert specified pages with retry logic.
+   */
+  async convertPagesWithRetry(pdfPath, taskId, pageNumbers, pageRange) {
+    const taskDir = ImagePathUtil.getTaskDir(taskId);
+    await promises.mkdir(taskDir, { recursive: true });
+    return this.withRetry(async () => {
+      const relativeOutputFolder = path.relative(process.cwd(), taskDir);
+      const options = {
+        outputFolder: relativeOutputFolder,
+        viewportScale: WORKER_CONFIG.splitter.viewportScale,
+        strictPagesToProcess: false,
+        verbosityLevel: 0
+      };
+      if (pageRange && pageRange.trim() !== "") {
+        options.pagesToProcess = pageNumbers;
+      }
+      const result = await pdfToPng(pdfPath, options);
+      if (!result || result.length === 0) {
+        throw new Error("PDF conversion produced no output");
+      }
+      const pages = [];
+      for (let i = 0; i < result.length; i++) {
+        const pageNum = i + 1;
+        const sourcePageNum = pageRange && pageRange.trim() !== "" ? pageNumbers[i] : pageNum;
+        const targetPath = ImagePathUtil.getPath(taskId, pageNum);
+        if (result[i].path !== targetPath) {
+          await promises.rename(result[i].path, targetPath);
+        }
+        pages.push({
+          page: pageNum,
+          pageSource: sourcePageNum,
+          imagePath: targetPath
+        });
+      }
+      return pages;
+    }, "convert PDF pages");
+  }
+  /**
+   * Generic retry wrapper with exponential backoff.
+   *
+   * @param operation - Async operation to retry
+   * @param operationName - Name for logging
+   * @returns Operation result
+   */
+  async withRetry(operation, operationName) {
+    const maxRetries = WORKER_CONFIG.splitter.maxRetries;
+    const baseDelay = WORKER_CONFIG.splitter.retryDelayBase;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        const errorMessage = lastError.message.toLowerCase();
+        if (errorMessage.includes("password") || errorMessage.includes("encrypted") || errorMessage.includes("invalid pdf")) {
+          throw lastError;
+        }
+        if (attempt < maxRetries - 1) {
+          const delay = baseDelay * Math.pow(2, attempt);
+          console.warn(
+            `[PDFSplitter] Failed to ${operationName} (attempt ${attempt + 1}/${maxRetries}): ${lastError.message}. Retrying in ${delay}ms...`
+          );
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw new Error(
+      `Failed to ${operationName} after ${maxRetries} attempts: ${lastError?.message || "Unknown error"}`
+    );
+  }
+  /**
+   * Wrap errors with friendly, actionable messages.
+   */
+  wrapError(error, taskId, filename) {
+    const err = error;
+    const message = err.message.toLowerCase();
+    if (message.includes("password") || message.includes("encrypted")) {
+      return new Error(
+        `Cannot process password-protected PDF: ${filename}. Please provide an unencrypted version.`
+      );
+    }
+    if (message.includes("invalid pdf") || message.includes("corrupt")) {
+      return new Error(
+        `PDF file appears to be corrupted or invalid: ${filename}. Please check the file.`
+      );
+    }
+    if (message.includes("enoent") || message.includes("file not found")) {
+      return new Error(
+        `PDF file not found: ${filename}. The file may have been moved or deleted.`
+      );
+    }
+    return new Error(`Failed to split PDF ${filename}: ${err.message}`);
+  }
+  /**
+   * Clean up temporary files for a task.
+   *
+   * @param taskId - Task ID to clean up
+   */
+  async cleanup(taskId) {
+    const taskDir = ImagePathUtil.getTaskDir(taskId);
+    try {
+      await promises.rm(taskDir, { recursive: true, force: true });
+    } catch (error) {
+      console.warn(`[PDFSplitter] Failed to cleanup task ${taskId}:`, error);
+    }
+  }
+  /**
+   * Sleep for the specified duration.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+class ImageSplitter {
+  uploadsDir;
+  constructor(uploadsDir) {
+    this.uploadsDir = uploadsDir;
+  }
+  /**
+   * "Split" an image file (actually just copy to temp directory as page-1.png).
+   *
+   * @param task - Task containing image file information
+   * @returns Split result with single page
+   * @throws Error if file not found or copy fails
+   */
+  async split(task) {
+    if (!task.id) {
+      throw new Error("Task ID is required");
+    }
+    if (!task.filename) {
+      throw new Error("Task filename is required");
+    }
+    const taskId = task.id;
+    const filename = task.filename;
+    const sourcePath = path.join(this.uploadsDir, taskId, filename);
+    try {
+      await promises.access(sourcePath);
+      const ext = path.extname(filename).toLowerCase();
+      if (!ext) {
+        throw new Error(`Image file has no extension: ${filename}`);
+      }
+      const taskDir = ImagePathUtil.getTaskDir(taskId);
+      await promises.mkdir(taskDir, { recursive: true });
+      const targetPath = ImagePathUtil.getPath(taskId, 1);
+      await promises.copyFile(sourcePath, targetPath);
+      const pageInfo = {
+        page: 1,
+        pageSource: 1,
+        imagePath: targetPath
+      };
+      return {
+        pages: [pageInfo],
+        totalPages: 1
+      };
+    } catch (error) {
+      throw this.wrapError(error, taskId, filename);
+    }
+  }
+  /**
+   * Wrap errors with friendly, actionable messages.
+   */
+  wrapError(error, taskId, filename) {
+    const err = error;
+    const message = err.message.toLowerCase();
+    if (message.includes("enoent") || message.includes("no such file")) {
+      return new Error(
+        `Image file not found: ${filename}. The file may have been moved or deleted.`
+      );
+    }
+    if (message.includes("eacces") || message.includes("permission denied")) {
+      return new Error(
+        `Permission denied accessing image file: ${filename}. Check file permissions.`
+      );
+    }
+    if (message.includes("enospc") || message.includes("no space")) {
+      return new Error(
+        `Not enough disk space to process image: ${filename}. Free up space and try again.`
+      );
+    }
+    return new Error(`Failed to process image ${filename}: ${err.message}`);
+  }
+  /**
+   * Clean up temporary files for a task.
+   *
+   * @param taskId - Task ID to clean up
+   */
+  async cleanup(taskId) {
+    const taskDir = ImagePathUtil.getTaskDir(taskId);
+    try {
+      await promises.rm(taskDir, { recursive: true, force: true });
+    } catch (error) {
+      console.warn(`[ImageSplitter] Failed to cleanup task ${taskId}:`, error);
+    }
+  }
+}
+class SplitterFactory {
+  uploadsDir;
+  constructor(uploadsDir) {
+    this.uploadsDir = uploadsDir;
+  }
+  /**
+   * Create a splitter for the given file type.
+   *
+   * @param fileType - File type (e.g., "pdf", "jpg", "png")
+   * @returns Appropriate splitter instance
+   * @throws Error if file type is not supported
+   */
+  create(fileType) {
+    const normalizedType = fileType.toLowerCase().trim();
+    switch (normalizedType) {
+      case "pdf":
+        return new PDFSplitter(this.uploadsDir);
+      case "jpg":
+      case "jpeg":
+      case "png":
+      case "webp":
+        return new ImageSplitter(this.uploadsDir);
+      default:
+        throw new Error(
+          `Unsupported file type: ${fileType}. Supported types: pdf, jpg, jpeg, png, webp`
+        );
+    }
+  }
+  /**
+   * Extract file type from filename.
+   *
+   * @param filename - File name (e.g., "document.pdf", "image.JPG")
+   * @returns File extension in lowercase without the dot (e.g., "pdf", "jpg")
+   * @throws Error if filename has no extension
+   */
+  static getFileType(filename) {
+    const ext = path.extname(filename);
+    if (!ext || ext === ".") {
+      throw new Error(`Filename has no extension: ${filename}`);
+    }
+    return ext.slice(1).toLowerCase();
+  }
+  /**
+   * Create a splitter for the given filename.
+   *
+   * Convenience method that combines getFileType() and create().
+   *
+   * @param filename - File name
+   * @returns Appropriate splitter instance
+   * @throws Error if file type is not supported or filename has no extension
+   */
+  createFromFilename(filename) {
+    const fileType = SplitterFactory.getFileType(filename);
+    return this.create(fileType);
+  }
+}
+class SplitterWorker extends WorkerBase {
+  factory;
+  pollInterval;
+  constructor(uploadsDir) {
+    super();
+    this.factory = new SplitterFactory(uploadsDir);
+    this.pollInterval = WORKER_CONFIG.splitter.pollInterval;
+  }
+  /**
+   * Main worker loop.
+   * Continuously polls for PENDING tasks and processes them.
+   */
+  async run() {
+    this.isRunning = true;
+    console.log(`[Splitter-${this.workerId}] Started. Poll interval: ${this.pollInterval}ms`);
+    while (this.isRunning) {
+      try {
+        const task = await this.claimTask(TaskStatus.PENDING, TaskStatus.SPLITTING);
+        if (task) {
+          console.log(`[Splitter-${this.workerId}] Processing task ${task.id}: ${task.filename}`);
+          await this.splitTask(task);
+        } else {
+          await this.sleep(this.pollInterval);
+        }
+      } catch (error) {
+        console.error(`[Splitter-${this.workerId}] Unexpected error in main loop:`, error);
+        await this.sleep(this.pollInterval);
+      }
+    }
+    console.log(`[Splitter-${this.workerId}] Stopped.`);
+  }
+  /**
+   * Split a single task.
+   *
+   * @param task - Task to process
+   */
+  async splitTask(task) {
+    if (!task.id || !task.filename) {
+      await this.handleError(task.id, new Error("Task missing required fields"));
+      return;
+    }
+    try {
+      const splitter = this.factory.createFromFilename(task.filename);
+      console.log(`[Splitter-${this.workerId}] Splitting ${task.filename}...`);
+      const result = await splitter.split(task);
+      console.log(
+        `[Splitter-${this.workerId}] Split complete: ${result.totalPages} pages generated`
+      );
+      await this.createTaskDetails(task, result);
+      console.log(`[Splitter-${this.workerId}] Task ${task.id} completed successfully`);
+    } catch (error) {
+      console.error(`[Splitter-${this.workerId}] Failed to split task ${task.id}:`, error);
+      await this.handleError(task.id, error);
+      try {
+        const splitter = this.factory.createFromFilename(task.filename);
+        await splitter.cleanup(task.id);
+      } catch (cleanupError) {
+        console.warn(`[Splitter-${this.workerId}] Cleanup failed for task ${task.id}:`, cleanupError);
+      }
+    }
+  }
+  /**
+   * Create TaskDetail records and update Task status atomically.
+   *
+   * Uses a Prisma transaction to ensure:
+   * 1. All TaskDetail records are created
+   * 2. Task status is updated to PROCESSING
+   * 3. Task.pages is set to total page count
+   * 4. worker_id is released (set to null)
+   *
+   * @param task - Task being processed
+   * @param result - Split result with page information
+   */
+  async createTaskDetails(task, result) {
+    const taskId = task.id;
+    try {
+      const updated = await prisma.$transaction(async (tx) => {
+        const taskDetails = result.pages.map((pageInfo) => ({
+          task: taskId,
+          page: pageInfo.page,
+          page_source: pageInfo.pageSource,
+          status: PageStatus.PENDING,
+          // Ready for converter workers
+          worker_id: null,
+          provider: task.provider,
+          model: task.model,
+          content: "",
+          retry_count: 0
+        }));
+        await tx.taskDetail.createMany({
+          data: taskDetails
+        });
+        const updatedTask = await tx.task.update({
+          where: {
+            id: taskId
+          },
+          data: {
+            status: TaskStatus.PROCESSING,
+            // Ready for converter workers
+            pages: result.totalPages,
+            worker_id: null,
+            // Release this worker
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        return updatedTask;
+      });
+      eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+        taskId,
+        task: updated,
+        timestamp: Date.now()
+      });
+      eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+        taskId,
+        task: { status: TaskStatus.PROCESSING },
+        timestamp: Date.now()
+      });
+      console.log(
+        `[Splitter-${this.workerId}] Created ${result.totalPages} TaskDetail records for task ${taskId}`
+      );
+    } catch (error) {
+      console.error(
+        `[Splitter-${this.workerId}] Failed to create TaskDetail records for task ${taskId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}
+const findAll$2 = async () => {
+  return await prisma.provider.findMany({
+    where: {
+      status: 0
+    },
+    select: {
+      id: true,
+      name: true,
+      type: true,
+      api_key: true,
+      base_url: true,
+      suffix: true,
+      status: true,
+      createdAt: true,
+      updatedAt: true
+    },
+    orderBy: [{ createdAt: "desc" }]
+  });
+};
+const findById$1 = async (id) => {
+  return await prisma.provider.findUnique({
+    where: { id },
+    select: {
+      id: true,
+      name: true,
+      type: true,
+      api_key: true,
+      base_url: true,
+      suffix: true,
+      status: true,
+      createdAt: true,
+      updatedAt: true
+    }
+  });
+};
+const create$2 = async (data) => {
+  return await prisma.provider.create({
+    data: {
+      name: data?.name || "",
+      type: data?.type || "",
+      api_key: data?.api_key || "",
+      base_url: data?.base_url || "",
+      suffix: data?.suffix || "",
+      status: data?.status || 0
+    }
+  });
+};
+const update$1 = async (id, data) => {
+  return await prisma.provider.update({
+    where: { id },
+    data
+  });
+};
+const remove$2 = async (id) => {
+  await prisma.model.deleteMany({
+    where: { provider: id }
+  });
+  return await prisma.provider.delete({
+    where: { id }
+  });
+};
+const updateStatus = async (id, status) => {
+  return await prisma.provider.update({
+    where: { id },
+    data: { status }
+  });
+};
+const providerRepository = {
+  findAll: findAll$2,
+  findById: findById$1,
+  create: create$2,
+  update: update$1,
+  remove: remove$2,
+  updateStatus
+};
+class LLMClient {
+  apiKey;
+  baseUrl;
+  constructor(apiKey, baseUrl = "") {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Normalize options for backward compatibility with single prompt
+   * @param options Options that may contain old prompt format
+   * @returns Normalized options
+   */
+  normalizeOptions(options) {
+    const normalizedOptions = { ...options };
+    if ("prompt" in normalizedOptions && normalizedOptions.prompt) {
+      if (!normalizedOptions.messages || normalizedOptions.messages.length === 0) {
+        normalizedOptions.messages = [{
+          role: "user",
+          content: {
+            type: "text",
+            text: normalizedOptions.prompt
+          }
+        }];
+      }
+      delete normalizedOptions.prompt;
+    }
+    if (normalizedOptions.systemPrompt && (!normalizedOptions.messages || !normalizedOptions.messages.some((m) => m.role === "system"))) {
+      const systemMessage = {
+        role: "system",
+        content: {
+          type: "text",
+          text: normalizedOptions.systemPrompt
+        }
+      };
+      normalizedOptions.messages = normalizedOptions.messages || [];
+      normalizedOptions.messages.unshift(systemMessage);
+      delete normalizedOptions.systemPrompt;
+    }
+    return normalizedOptions;
+  }
+}
+class LLMClientFactory {
+  /**
+   * Create LLM client instance
+   * @param type LLM client type
+   * @param apiKey API key
+   * @param baseUrl Base URL (some services need custom URL)
+   */
+  static async createClient(type, apiKey, baseUrl) {
+    switch (type) {
+      case "openai": {
+        const OpenAIModule = await import("./OpenAIClient-gyy2nFkw.js");
+        return new OpenAIModule.OpenAIClient(apiKey, baseUrl || "");
+      }
+      case "openai-responses": {
+        const OpenAIResponsesModule = await import("./OpenAIResponsesClient-DETYz2nL.js");
+        return new OpenAIResponsesModule.OpenAIResponsesClient(apiKey, baseUrl || "");
+      }
+      case "gemini": {
+        const GeminiModule = await import("./GeminiClient-CrtYbwaF.js");
+        return new GeminiModule.GeminiClient(apiKey, baseUrl || "");
+      }
+      case "anthropic": {
+        const AnthropicModule = await import("./AnthropicClient-CTbHYiqm.js");
+        return new AnthropicModule.AnthropicClient(apiKey, baseUrl || "");
+      }
+      case "ollama": {
+        const OllamaModule = await import("./OllamaClient-DKJsnvIt.js");
+        return new OllamaModule.OllamaClient(apiKey, baseUrl || "");
+      }
+      default:
+        throw new Error(`Unsupported LLM client type: ${type}`);
+    }
+  }
+}
+const getLLMClient = async (providerId) => {
+  const provider = await providerRepository.findById(providerId);
+  if (!provider) {
+    throw new Error("服务商不存在");
+  }
+  let baseUrl = provider.base_url || "";
+  let suffix = provider.suffix || "";
+  if (!baseUrl) {
+    switch (provider.type) {
+      case "ollama":
+        baseUrl = "http://localhost:11434/api";
+        break;
+    }
+  }
+  if (!suffix) {
+    switch (provider.type) {
+      case "openai":
+        suffix = "/chat/completions";
+        break;
+      case "openai-responses":
+        suffix = "/responses";
+        break;
+      case "gemini":
+        suffix = "/models";
+        break;
+      case "anthropic":
+        suffix = "/messages";
+        break;
+      case "ollama":
+        suffix = "/generate";
+        break;
+    }
+  }
+  return LLMClientFactory.createClient(
+    provider.type || "",
+    provider.api_key || "",
+    `${baseUrl}${suffix}`
+  );
+};
+const completion = async (providerId, options) => {
+  const llmClient = await getLLMClient(providerId);
+  return llmClient.completion(options);
+};
+const getImageBase64 = async (imagePath) => {
+  const image = sharp(imagePath);
+  const buffer = await image.toBuffer();
+  return buffer.toString("base64");
+};
+const transformImageMessage = async (imagePath) => {
+  const imageBase64 = await getImageBase64(imagePath);
+  const message = [{
+    role: "system",
+    content: {
+      type: "text",
+      text: "You are a helpful assistant that can convert images to Markdown format. You are given an image, and you need to convert it to Markdown format. Please output the Markdown content only, without any other text."
+    }
+  }];
+  message.push({
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `Below is the image of one page of a document, please read the content in the image and transcribe it into plain Markdown format. Please note:
+1. Identify heading levels, text styles, formulas, and the format of table rows and columns
+2. Mathematical formulas should be transcribed using LaTeX syntax, ensuring consistency with the original
+3. Please output the Markdown content only, without any other text.
+
+Output Example:
+\`\`\`markdown
+{example}
+\`\`\``
+      },
+      {
+        type: "image_url",
+        image_url: { url: `data:image/jpeg;base64,${imageBase64}` }
+      }
+    ]
+  });
+  return message;
+};
+const modelLogic = {
+  completion,
+  transformImageMessage
+};
+class ConverterWorker extends WorkerBase {
+  maxRetries;
+  maxContentLength;
+  pollInterval;
+  retryDelayBase;
+  currentPageId = null;
+  constructor() {
+    super();
+    this.maxRetries = WORKER_CONFIG.converter.maxRetries;
+    this.maxContentLength = WORKER_CONFIG.converter.maxContentLength;
+    this.pollInterval = WORKER_CONFIG.converter.pollInterval;
+    this.retryDelayBase = WORKER_CONFIG.converter.retryDelayBase;
+  }
+  /**
+   * Main worker loop.
+   * Continuously polls for PENDING pages and processes them.
+   */
+  async run() {
+    this.isRunning = true;
+    console.log(`[Converter-${this.workerId.slice(0, 8)}] Started. Poll interval: ${this.pollInterval}ms`);
+    while (this.isRunning) {
+      try {
+        const page = await this.claimPage();
+        if (page) {
+          this.currentPageId = page.id;
+          console.log(`[Converter-${this.workerId.slice(0, 8)}] Claimed page ${page.page} of task ${page.task} (provider: ${page.provider}, model: ${page.model})`);
+          await this.processPageWithRetry(page);
+          this.currentPageId = null;
+        } else {
+          await this.sleep(this.pollInterval);
+        }
+      } catch (error) {
+        console.error(`[Converter-${this.workerId.slice(0, 8)}] Unexpected error in main loop:`, error);
+        if (this.currentPageId !== null) {
+          await this.releaseCurrentPage();
+        }
+        await this.sleep(this.pollInterval);
+      }
+    }
+    console.log(`[Converter-${this.workerId.slice(0, 8)}] Stopped.`);
+  }
+  /**
+   * Stop the worker gracefully.
+   * Releases the current page if any.
+   */
+  stop() {
+    this.isRunning = false;
+    console.log(`[Converter-${this.workerId.slice(0, 8)}] Stopping...`);
+    if (this.currentPageId !== null) {
+      this.releaseCurrentPage().catch((error) => {
+        console.error(`[Converter-${this.workerId.slice(0, 8)}] Failed to release page on stop:`, error);
+      });
+    }
+  }
+  /**
+   * Release the current page back to PENDING state.
+   */
+  async releaseCurrentPage() {
+    if (this.currentPageId === null) return;
+    try {
+      await prisma.taskDetail.update({
+        where: { id: this.currentPageId },
+        data: {
+          status: PageStatus.PENDING,
+          worker_id: null,
+          started_at: null
+        }
+      });
+      console.log(`[Converter-${this.workerId.slice(0, 8)}] Released page ${this.currentPageId}`);
+      this.currentPageId = null;
+    } catch (error) {
+      console.error(`[Converter-${this.workerId.slice(0, 8)}] Failed to release page ${this.currentPageId}:`, error);
+    }
+  }
+  /**
+   * Claim a PENDING page for processing using optimistic locking.
+   *
+   * Query conditions:
+   * - task.status = PROCESSING
+   * - task.status != CANCELLED
+   * - page.status = PENDING
+   * - page.worker_id = null
+   *
+   * Order: retry_count ASC, page ASC (prioritize fresh pages)
+   */
+  async claimPage() {
+    const maxAttempts = 5;
+    const checkedTaskIds = [];
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const candidate = await prisma.taskDetail.findFirst({
+          where: {
+            status: PageStatus.PENDING,
+            worker_id: null,
+            // Exclude pages from tasks we've already checked and found not in PROCESSING state
+            ...checkedTaskIds.length > 0 && { task: { notIn: checkedTaskIds } }
+          },
+          orderBy: [
+            { retry_count: "asc" },
+            { page: "asc" }
+          ]
+        });
+        if (!candidate) {
+          return null;
+        }
+        const task = await prisma.task.findUnique({
+          where: { id: candidate.task },
+          select: { status: true }
+        });
+        if (!task || task.status !== TaskStatus.PROCESSING && task.status !== TaskStatus.COMPLETED) {
+          checkedTaskIds.push(candidate.task);
+          continue;
+        }
+        const result = await prisma.taskDetail.updateMany({
+          where: {
+            id: candidate.id,
+            status: PageStatus.PENDING,
+            worker_id: null
+          },
+          data: {
+            status: PageStatus.PROCESSING,
+            worker_id: this.workerId,
+            started_at: /* @__PURE__ */ new Date()
+          }
+        });
+        if (result.count === 1) {
+          const claimed = await prisma.taskDetail.findUnique({
+            where: { id: candidate.id }
+          });
+          if (claimed) {
+            this.emitPageStatusEvent(claimed.task, claimed.id, claimed.page, PageStatus.PROCESSING);
+          }
+          return claimed;
+        }
+      } catch (error) {
+        console.error(`[Converter-${this.workerId.slice(0, 8)}] Claim attempt ${attempt + 1} failed:`, error);
+      }
+    }
+    return null;
+  }
+  /**
+   * Process a page with retry logic.
+   */
+  async processPageWithRetry(page) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const result = await this.convertPage(page);
+        await this.completePageSuccess(page, result);
+        console.log(`[Converter-${this.workerId.slice(0, 8)}] Page ${page.page} of task ${page.task} completed (model: ${page.model})`);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const errorType = this.analyzeError(lastError);
+        console.error(
+          `[Converter-${this.workerId.slice(0, 8)}] Page ${page.page} attempt ${attempt + 1} failed (${errorType}, model: ${page.model}):`,
+          lastError.message
+        );
+        if (!this.isRetryableError(errorType)) {
+          console.log(`[Converter-${this.workerId.slice(0, 8)}] Non-retryable error, marking as failed`);
+          break;
+        }
+        if (attempt < this.maxRetries) {
+          const taskStatus = await this.checkTaskStatus(page.task);
+          if (taskStatus === TaskStatus.CANCELLED) {
+            console.log(`[Converter-${this.workerId.slice(0, 8)}] Task cancelled, stopping retries`);
+            return;
+          }
+          await this.incrementRetryCount(page.id);
+          const delay = this.calculateRetryDelay(attempt, errorType);
+          console.log(`[Converter-${this.workerId.slice(0, 8)}] Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    await this.completePageFailed(page, lastError);
+    console.log(`[Converter-${this.workerId.slice(0, 8)}] Page ${page.page} of task ${page.task} failed (model: ${page.model})`);
+  }
+  /**
+   * Convert a page image to Markdown using LLM.
+   */
+  async convertPage(page) {
+    const startTime = Date.now();
+    const imagePath = ImagePathUtil.getPath(page.task, page.page);
+    const messages = await modelLogic.transformImageMessage(imagePath);
+    const response = await modelLogic.completion(page.provider, {
+      model: page.model,
+      messages,
+      stream: false
+      // Critical: disabled for token tracking
+    });
+    const inputTokens = this.extractInputTokens(response);
+    const outputTokens = this.extractOutputTokens(response);
+    if (!response.content || response.content.trim().length === 0) {
+      throw new Error("LLM returned empty content");
+    }
+    const markdown = this.cleanMarkdownContent(response.content);
+    if (markdown.length > this.maxContentLength) {
+      throw new Error(`Content exceeds maximum length: ${markdown.length} > ${this.maxContentLength}`);
+    }
+    const conversionTime = Date.now() - startTime;
+    return {
+      markdown,
+      inputTokens,
+      outputTokens,
+      conversionTime
+    };
+  }
+  /**
+   * Mark page as successfully completed and update task progress.
+   */
+  async completePageSuccess(page, result) {
+    const maxAttempts = 3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        await prisma.$transaction(
+          async (tx) => {
+            const currentPage = await tx.taskDetail.findUnique({
+              where: { id: page.id },
+              select: { worker_id: true, status: true }
+            });
+            if (!currentPage || currentPage.worker_id !== this.workerId) {
+              throw new Error("Page claimed by another worker");
+            }
+            if (currentPage.status === PageStatus.COMPLETED) {
+              return;
+            }
+            const task = await tx.task.findUnique({
+              where: { id: page.task },
+              select: { status: true, pages: true, completed_count: true, failed_count: true }
+            });
+            if (!task) {
+              throw new Error("Task not found");
+            }
+            if (task.status === TaskStatus.CANCELLED) {
+              throw new Error("Task has been cancelled");
+            }
+            await tx.taskDetail.update({
+              where: { id: page.id },
+              data: {
+                status: PageStatus.COMPLETED,
+                content: result.markdown,
+                input_tokens: result.inputTokens,
+                output_tokens: result.outputTokens,
+                conversion_time: result.conversionTime,
+                completed_at: /* @__PURE__ */ new Date(),
+                worker_id: null,
+                // Release worker
+                error: null
+              }
+            });
+            const updatedTask = await tx.task.update({
+              where: { id: page.task },
+              data: {
+                completed_count: { increment: 1 }
+              }
+            });
+            const finishedCount = updatedTask.completed_count + task.failed_count;
+            if (finishedCount >= task.pages) {
+              const newStatus = task.failed_count > 0 ? TaskStatus.PARTIAL_FAILED : TaskStatus.READY_TO_MERGE;
+              await tx.task.update({
+                where: { id: page.task },
+                data: {
+                  status: newStatus,
+                  worker_id: null
+                }
+              });
+            }
+            const progress = Math.round(updatedTask.completed_count / task.pages * 100);
+            await tx.task.update({
+              where: { id: page.task },
+              data: { progress }
+            });
+          },
+          {
+            isolationLevel: "Serializable"
+          }
+        );
+        this.emitPageStatusEvent(page.task, page.id, page.page, PageStatus.COMPLETED);
+        this.emitProgressEvent(page.task);
+        return;
+      } catch (error) {
+        if (error.code === "P2034" && attempt < maxAttempts - 1) {
+          console.warn(`[Converter-${this.workerId.slice(0, 8)}] Transaction conflict, retrying...`);
+          await this.sleep(100 * (attempt + 1));
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  /**
+   * Mark page as failed and update task progress.
+   */
+  async completePageFailed(page, error) {
+    const maxAttempts = 3;
+    const errorMessage = this.formatError(error);
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        await prisma.$transaction(
+          async (tx) => {
+            const currentPage = await tx.taskDetail.findUnique({
+              where: { id: page.id },
+              select: { worker_id: true, status: true }
+            });
+            if (!currentPage || currentPage.worker_id !== this.workerId) {
+              throw new Error("Page claimed by another worker");
+            }
+            if (currentPage.status === PageStatus.FAILED) {
+              return;
+            }
+            const task = await tx.task.findUnique({
+              where: { id: page.task },
+              select: { status: true, pages: true, completed_count: true, failed_count: true }
+            });
+            if (!task) {
+              throw new Error("Task not found");
+            }
+            if (task.status === TaskStatus.CANCELLED) {
+              throw new Error("Task has been cancelled");
+            }
+            await tx.taskDetail.update({
+              where: { id: page.id },
+              data: {
+                status: PageStatus.FAILED,
+                error: errorMessage,
+                completed_at: /* @__PURE__ */ new Date(),
+                worker_id: null
+                // Release worker
+              }
+            });
+            const updatedTask = await tx.task.update({
+              where: { id: page.task },
+              data: {
+                failed_count: { increment: 1 }
+              }
+            });
+            const finishedCount = task.completed_count + updatedTask.failed_count;
+            if (finishedCount >= task.pages) {
+              const newStatus = task.completed_count > 0 ? TaskStatus.PARTIAL_FAILED : TaskStatus.FAILED;
+              await tx.task.update({
+                where: { id: page.task },
+                data: {
+                  status: newStatus,
+                  worker_id: null,
+                  // Write page error to task when all pages failed
+                  error: newStatus === TaskStatus.FAILED ? errorMessage : void 0
+                }
+              });
+            }
+            const progress = Math.round(task.completed_count / task.pages * 100);
+            await tx.task.update({
+              where: { id: page.task },
+              data: { progress }
+            });
+          },
+          {
+            isolationLevel: "Serializable"
+          }
+        );
+        this.emitPageStatusEvent(page.task, page.id, page.page, PageStatus.FAILED);
+        this.emitProgressEvent(page.task);
+        return;
+      } catch (error2) {
+        if (error2.code === "P2034" && attempt < maxAttempts - 1) {
+          console.warn(`[Converter-${this.workerId.slice(0, 8)}] Transaction conflict, retrying...`);
+          await this.sleep(100 * (attempt + 1));
+          continue;
+        }
+        throw error2;
+      }
+    }
+  }
+  /**
+   * Check task status from database.
+   */
+  async checkTaskStatus(taskId) {
+    const task = await prisma.task.findUnique({
+      where: { id: taskId },
+      select: { status: true }
+    });
+    return task?.status ?? null;
+  }
+  /**
+   * Increment retry count for a page.
+   */
+  async incrementRetryCount(pageId) {
+    await prisma.taskDetail.update({
+      where: { id: pageId },
+      data: {
+        retry_count: { increment: 1 }
+      }
+    });
+  }
+  /**
+   * Emit page status change event.
+   */
+  emitPageStatusEvent(taskId, pageId, page, status) {
+    eventBus.emitTaskDetailEvent(TaskEventType.TASK_DETAIL_UPDATED, {
+      taskId,
+      pageId,
+      page,
+      status,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Emit task progress event.
+   */
+  emitProgressEvent(taskId) {
+    prisma.task.findUnique({
+      where: { id: taskId }
+    }).then((task) => {
+      if (task) {
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId,
+          task,
+          timestamp: Date.now()
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_PROGRESS_CHANGED, {
+          taskId,
+          task: { progress: task.progress },
+          timestamp: Date.now()
+        });
+        if (task.status === TaskStatus.READY_TO_MERGE || task.status === TaskStatus.PARTIAL_FAILED) {
+          eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+            taskId,
+            task: { status: task.status },
+            timestamp: Date.now()
+          });
+        }
+      }
+    }).catch((error) => {
+      console.error(`[Converter-${this.workerId.slice(0, 8)}] Failed to emit progress event:`, error);
+    });
+  }
+  /**
+   * Extract input tokens from LLM response.
+   * Adapts to different provider response formats.
+   */
+  extractInputTokens(response) {
+    const raw = response.rawResponse;
+    if (!raw) return 0;
+    if (raw.usage?.prompt_tokens !== void 0) {
+      return raw.usage.prompt_tokens;
+    }
+    if (raw.usage?.input_tokens !== void 0) {
+      return raw.usage.input_tokens;
+    }
+    if (raw.usageMetadata?.promptTokenCount !== void 0) {
+      return raw.usageMetadata.promptTokenCount;
+    }
+    return 0;
+  }
+  /**
+   * Extract output tokens from LLM response.
+   * Adapts to different provider response formats.
+   */
+  extractOutputTokens(response) {
+    const raw = response.rawResponse;
+    if (!raw) return 0;
+    if (raw.usage?.completion_tokens !== void 0) {
+      return raw.usage.completion_tokens;
+    }
+    if (raw.usage?.output_tokens !== void 0) {
+      return raw.usage.output_tokens;
+    }
+    if (raw.usageMetadata?.candidatesTokenCount !== void 0) {
+      return raw.usageMetadata.candidatesTokenCount;
+    }
+    return 0;
+  }
+  /**
+   * Clean markdown content by removing code block markers.
+   */
+  cleanMarkdownContent(content) {
+    let cleaned = content.trim();
+    if (cleaned.startsWith("```markdown")) {
+      cleaned = cleaned.slice("```markdown".length);
+    } else if (cleaned.startsWith("```md")) {
+      cleaned = cleaned.slice("```md".length);
+    } else if (cleaned.startsWith("```")) {
+      cleaned = cleaned.slice("```".length);
+    }
+    if (cleaned.endsWith("```")) {
+      cleaned = cleaned.slice(0, -3);
+    }
+    return cleaned.trim();
+  }
+  /**
+   * Format error message for storage (truncate to 500 chars).
+   */
+  formatError(error) {
+    const message = error.message || String(error);
+    if (message.length > 500) {
+      return message.slice(0, 497) + "...";
+    }
+    return message;
+  }
+  /**
+   * Analyze error to determine type.
+   */
+  analyzeError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("network") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("etimedout") || message.includes("fetch failed") || message.includes("socket hang up")) {
+      return "network_error";
+    }
+    if (message.includes("rate limit") || message.includes("rate_limit") || message.includes("too many requests") || message.includes("429")) {
+      return "rate_limit_error";
+    }
+    if (message.includes("quota") || message.includes("insufficient_quota") || message.includes("billing")) {
+      return "quota_exceeded_error";
+    }
+    if (message.includes("api key") || message.includes("apikey") || message.includes("invalid_api_key") || message.includes("unauthorized") || message.includes("authentication") || message.includes("model not found") || message.includes("not exist")) {
+      return "config_error";
+    }
+    if (message.includes("enoent") || message.includes("file not found") || message.includes("no such file")) {
+      return "file_error";
+    }
+    if (message.includes("timeout") || message.includes("timed out")) {
+      return "timeout_error";
+    }
+    if (message.includes("llm") || message.includes("api") || message.includes("openai") || message.includes("anthropic") || message.includes("gemini")) {
+      return "llm_error";
+    }
+    return "unknown_error";
+  }
+  /**
+   * Determine if an error type is retryable.
+   */
+  isRetryableError(errorType) {
+    switch (errorType) {
+      case "network_error":
+      case "llm_error":
+      case "rate_limit_error":
+      case "timeout_error":
+      case "unknown_error":
+        return true;
+      case "quota_exceeded_error":
+      case "config_error":
+      case "file_error":
+        return false;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Calculate retry delay with exponential backoff and jitter.
+   */
+  calculateRetryDelay(attempt, errorType) {
+    let delay = this.retryDelayBase * Math.pow(2, attempt);
+    if (errorType === "rate_limit_error") {
+      delay *= 2;
+    }
+    const jitter = Math.random() * delay * 0.25;
+    delay += jitter;
+    return Math.min(delay, 3e4);
+  }
+}
+class MergerWorker extends WorkerBase {
+  /** 上传文件根目录 */
+  uploadsDir;
+  /** 当前正在处理的任务 ID，用于优雅停止时释放 */
+  currentTaskId = null;
+  /**
+   * 构造函数
+   * @param uploadsDir - 上传文件根目录，合并后的文件将保存在此目录下的任务子目录中
+   */
+  constructor(uploadsDir) {
+    super();
+    this.uploadsDir = uploadsDir;
+  }
+  /**
+   * Worker 主循环
+   *
+   * 持续轮询 READY_TO_MERGE 状态的任务，抢占后进行合并处理。
+   * 通过 isRunning 标志支持优雅停止。
+   */
+  async run() {
+    this.isRunning = true;
+    console.log(`[Merger-${this.workerId.slice(0, 8)}] Started`);
+    while (this.isRunning) {
+      try {
+        const task = await this.claimTask(
+          TaskStatus.READY_TO_MERGE,
+          TaskStatus.MERGING
+        );
+        if (!task) {
+          await this.sleep(WORKER_CONFIG.merger.pollInterval);
+          continue;
+        }
+        this.currentTaskId = task.id;
+        console.log(`[Merger-${this.workerId.slice(0, 8)}] Claimed task ${task.id}`);
+        try {
+          await this.mergeTask(task);
+        } catch (error) {
+          console.error(`[Merger-${this.workerId.slice(0, 8)}] Failed to merge task ${task.id}:`, error);
+          await this.handleError(task.id, error);
+        } finally {
+          this.currentTaskId = null;
+        }
+      } catch (error) {
+        console.error(`[Merger-${this.workerId.slice(0, 8)}] Unexpected error in main loop:`, error);
+        if (this.currentTaskId !== null) {
+          await this.releaseCurrentTask();
+        }
+        await this.sleep(WORKER_CONFIG.merger.pollInterval);
+      }
+    }
+    console.log(`[Merger-${this.workerId.slice(0, 8)}] Stopped`);
+  }
+  /**
+   * 优雅停止 Worker
+   *
+   * 覆盖基类方法，添加释放当前任务的逻辑。
+   * 如果正在处理任务，将其释放回 READY_TO_MERGE 状态。
+   */
+  stop() {
+    this.isRunning = false;
+    console.log(`[Merger-${this.workerId.slice(0, 8)}] Stopping...`);
+    if (this.currentTaskId !== null) {
+      this.releaseCurrentTask().catch((error) => {
+        console.error(`[Merger-${this.workerId.slice(0, 8)}] Failed to release task on stop:`, error);
+      });
+    }
+  }
+  /**
+   * 释放当前任务回 READY_TO_MERGE 状态
+   *
+   * 用于优雅停止或异常恢复时释放任务。
+   */
+  async releaseCurrentTask() {
+    if (this.currentTaskId === null) return;
+    try {
+      await prisma.task.update({
+        where: { id: this.currentTaskId },
+        data: {
+          status: TaskStatus.READY_TO_MERGE,
+          worker_id: null
+        }
+      });
+      console.log(`[Merger-${this.workerId.slice(0, 8)}] Released task ${this.currentTaskId}`);
+      this.currentTaskId = null;
+    } catch (error) {
+      console.error(`[Merger-${this.workerId.slice(0, 8)}] Failed to release task ${this.currentTaskId}:`, error);
+    }
+  }
+  /**
+   * 执行任务合并
+   *
+   * @param task - 待合并的任务
+   */
+  async mergeTask(task) {
+    const pages = await this.getCompletedPages(task.id);
+    if (pages.length === 0) {
+      throw new Error("No completed pages found for merging");
+    }
+    console.log(`[Merger-${this.workerId.slice(0, 8)}] Merging ${pages.length} pages for task ${task.id}`);
+    const mergedContent = this.mergeMarkdown(pages);
+    const outputPath = await this.saveMergedFile(task, mergedContent);
+    await this.updateTaskStatus(task.id, TaskStatus.COMPLETED, {
+      progress: 100,
+      worker_id: null,
+      // 释放 worker 占用
+      merged_path: outputPath
+      // 合并后的文件路径，前端需要此字段启用下载按钮
+    });
+    console.log(`[Merger-${this.workerId.slice(0, 8)}] Task ${task.id} merged successfully: ${outputPath}`);
+  }
+  /**
+   * 获取任务的所有已完成页面
+   *
+   * @param taskId - 任务 ID
+   * @returns 已完成的页面列表，按页码排序
+   */
+  async getCompletedPages(taskId) {
+    return await prisma.taskDetail.findMany({
+      where: {
+        task: taskId,
+        status: PageStatus.COMPLETED
+      },
+      orderBy: {
+        page: "asc"
+      },
+      select: {
+        page: true,
+        content: true
+      }
+    });
+  }
+  /**
+   * 合并 Markdown 内容
+   *
+   * 格式：
+   * - 每页以 <!-- Page N --> 注释开头
+   * - 页面之间使用 --- 分隔线分隔
+   * - 使用 LF 换行符确保跨平台兼容性
+   *
+   * @param pages - 已完成的页面列表
+   * @returns 合并后的 Markdown 内容
+   */
+  mergeMarkdown(pages) {
+    return pages.map((page) => {
+      return `<!-- Page ${page.page} -->
+
+${page.content}`;
+    }).join("\n\n---\n\n");
+  }
+  /**
+   * 计算输出文件路径
+   *
+   * 使用 path.parse() 可靠地处理各种文件名边界情况：
+   * - 以点开头的隐藏文件（如 .hidden）
+   * - 多个点的文件名（如 my.report.2024.pdf）
+   * - 无扩展名的文件（如 document）
+   *
+   * 路径格式: {uploadsDir}/{taskId}/{filename}.md
+   * 例如: files/abc123/document.md (原文件为 document.pdf)
+   *
+   * @param task - 任务对象
+   * @returns 输出文件的完整路径
+   */
+  getOutputPath(task) {
+    const { name } = path.parse(task.filename);
+    const outputFileName = `${name}.md`;
+    return path.join(this.uploadsDir, task.id, outputFileName);
+  }
+  /**
+   * 保存合并后的文件
+   *
+   * @param task - 任务对象
+   * @param content - 合并后的 Markdown 内容
+   * @returns 保存的文件路径
+   */
+  async saveMergedFile(task, content) {
+    const outputPath = this.getOutputPath(task);
+    const outputDir = path.dirname(outputPath);
+    await this.ensureDirectoryExists(outputDir);
+    await fs$1.writeFile(outputPath, content, { encoding: "utf-8" });
+    return outputPath;
+  }
+  /**
+   * 确保目录存在，不存在则创建
+   *
+   * @param dirPath - 目录路径
+   */
+  async ensureDirectoryExists(dirPath) {
+    try {
+      await fs$1.access(dirPath);
+    } catch {
+      await fs$1.mkdir(dirPath, { recursive: true });
+    }
+  }
+}
+const getUploadDir = () => {
+  if (isDev) {
+    return path.join(process.cwd(), "files");
+  }
+  const userDataPath = app.getPath("userData");
+  return path.join(userDataPath, "files");
+};
+const getTempDir = () => {
+  if (isDev) {
+    return path.join(process.cwd(), "temp");
+  }
+  const userDataPath = app.getPath("userData");
+  return path.join(userDataPath, "temp");
+};
+const deleteDirectory = (dirPath) => {
+  if (fs.existsSync(dirPath)) {
+    if (fs.lstatSync(dirPath).isDirectory()) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(dirPath);
+    }
+  }
+};
+const getSplitDir = (taskId) => {
+  return path.join(getUploadDir(), taskId, "split");
+};
+const deleteTaskFiles = (id) => {
+  const uploadDir = path.join(getUploadDir(), id);
+  deleteDirectory(uploadDir);
+  const tempDir = path.join(getTempDir(), id);
+  deleteDirectory(tempDir);
+};
+const fileLogic = {
+  getUploadDir,
+  getTempDir,
+  getSplitDir,
+  deleteTaskFiles
+};
+class WorkerOrchestrator {
+  isRunning;
+  splitterWorker;
+  converterWorkers;
+  mergerWorker;
+  uploadsDir;
+  constructor() {
+    this.isRunning = false;
+    this.splitterWorker = null;
+    this.converterWorkers = [];
+    this.mergerWorker = null;
+    this.uploadsDir = fileLogic.getUploadDir();
+  }
+  /**
+   * Start all workers
+   */
+  async start() {
+    if (this.isRunning) {
+      console.warn("[WorkerOrchestrator] Workers already running");
+      return;
+    }
+    try {
+      console.log("[WorkerOrchestrator] Initializing workers...");
+      await this.cleanupOrphanedWork();
+      ImagePathUtil.init(this.uploadsDir);
+      console.log(`[WorkerOrchestrator] ImagePathUtil initialized with uploadsDir: ${this.uploadsDir}`);
+      this.splitterWorker = new SplitterWorker(this.uploadsDir);
+      console.log(`[WorkerOrchestrator] SplitterWorker created (ID: ${this.splitterWorker.getWorkerId()})`);
+      this.splitterWorker.run().catch((error) => {
+        console.error("[WorkerOrchestrator] SplitterWorker error:", error);
+      });
+      const converterCount = WORKER_CONFIG.converter.count;
+      for (let i = 0; i < converterCount; i++) {
+        const worker = new ConverterWorker();
+        this.converterWorkers.push(worker);
+        console.log(`[WorkerOrchestrator] ConverterWorker ${i + 1}/${converterCount} created (ID: ${worker.getWorkerId().slice(0, 8)})`);
+        worker.run().catch((error) => {
+          console.error(`[WorkerOrchestrator] ConverterWorker ${worker.getWorkerId().slice(0, 8)} error:`, error);
+        });
+      }
+      this.mergerWorker = new MergerWorker(this.uploadsDir);
+      console.log(`[WorkerOrchestrator] MergerWorker created (ID: ${this.mergerWorker.getWorkerId().slice(0, 8)})`);
+      this.mergerWorker.run().catch((error) => {
+        console.error("[WorkerOrchestrator] MergerWorker error:", error);
+      });
+      this.isRunning = true;
+      console.log("[WorkerOrchestrator] All workers started successfully");
+    } catch (error) {
+      console.error("[WorkerOrchestrator] Failed to start workers:", error);
+      this.isRunning = false;
+      throw error;
+    }
+  }
+  /**
+   * Stop all workers gracefully
+   */
+  async stop() {
+    if (!this.isRunning) {
+      console.warn("[WorkerOrchestrator] Workers not running");
+      return;
+    }
+    try {
+      console.log("[WorkerOrchestrator] Stopping workers...");
+      if (this.splitterWorker) {
+        this.splitterWorker.stop();
+        console.log("[WorkerOrchestrator] SplitterWorker stopped");
+        this.splitterWorker = null;
+      }
+      for (const worker of this.converterWorkers) {
+        worker.stop();
+        console.log(`[WorkerOrchestrator] ConverterWorker ${worker.getWorkerId().slice(0, 8)} stopped`);
+      }
+      this.converterWorkers = [];
+      if (this.mergerWorker) {
+        this.mergerWorker.stop();
+        console.log(`[WorkerOrchestrator] MergerWorker ${this.mergerWorker.getWorkerId().slice(0, 8)} stopped`);
+        this.mergerWorker = null;
+      }
+      this.isRunning = false;
+      console.log("[WorkerOrchestrator] All workers stopped");
+    } catch (error) {
+      console.error("[WorkerOrchestrator] Error stopping workers:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get running status
+   */
+  getStatus() {
+    return this.isRunning;
+  }
+  /**
+   * Get worker information (for debugging/monitoring)
+   */
+  getWorkerInfo() {
+    return {
+      isRunning: this.isRunning,
+      splitterWorker: this.splitterWorker ? {
+        id: this.splitterWorker.getWorkerId(),
+        running: this.splitterWorker.getIsRunning()
+      } : null,
+      converterWorkers: this.converterWorkers.map((worker) => ({
+        id: worker.getWorkerId().slice(0, 8),
+        running: worker.getIsRunning()
+      })),
+      mergerWorker: this.mergerWorker ? {
+        id: this.mergerWorker.getWorkerId().slice(0, 8),
+        running: this.mergerWorker.getIsRunning()
+      } : null,
+      directories: {
+        uploads: this.uploadsDir
+      }
+    };
+  }
+  /**
+   * Clean up orphaned tasks and pages from previous abnormal shutdown.
+   *
+   * This handles the case where the application was closed while tasks were in progress:
+   * - Pages with status=PROCESSING and worker_id set (orphaned by crashed workers)
+   * - Tasks with status=SPLITTING (orphaned splitter work)
+   *
+   * These are reset to their previous state so new workers can pick them up.
+   */
+  async cleanupOrphanedWork() {
+    try {
+      console.log("[WorkerOrchestrator] Checking for orphaned work from previous session...");
+      const orphanedPages = await prisma.taskDetail.updateMany({
+        where: {
+          status: PageStatus.PROCESSING,
+          worker_id: { not: null }
+        },
+        data: {
+          status: PageStatus.PENDING,
+          worker_id: null,
+          started_at: null
+        }
+      });
+      if (orphanedPages.count > 0) {
+        console.log(`[WorkerOrchestrator] Reset ${orphanedPages.count} orphaned pages to PENDING`);
+      }
+      const orphanedSplittingTasks = await prisma.task.updateMany({
+        where: {
+          status: TaskStatus.SPLITTING,
+          worker_id: { not: null }
+        },
+        data: {
+          status: TaskStatus.PENDING,
+          worker_id: null
+        }
+      });
+      if (orphanedSplittingTasks.count > 0) {
+        console.log(`[WorkerOrchestrator] Reset ${orphanedSplittingTasks.count} orphaned SPLITTING tasks to PENDING`);
+      }
+      const orphanedMergingTasks = await prisma.task.updateMany({
+        where: {
+          status: TaskStatus.MERGING,
+          worker_id: { not: null }
+        },
+        data: {
+          status: TaskStatus.READY_TO_MERGE,
+          worker_id: null
+        }
+      });
+      if (orphanedMergingTasks.count > 0) {
+        console.log(`[WorkerOrchestrator] Reset ${orphanedMergingTasks.count} orphaned MERGING tasks to READY_TO_MERGE`);
+      }
+      const result = {
+        orphanedPages: orphanedPages.count,
+        orphanedSplittingTasks: orphanedSplittingTasks.count,
+        orphanedMergingTasks: orphanedMergingTasks.count,
+        total: orphanedPages.count + orphanedSplittingTasks.count + orphanedMergingTasks.count
+      };
+      if (result.total === 0) {
+        console.log("[WorkerOrchestrator] No orphaned work found");
+      } else {
+        console.log(`[WorkerOrchestrator] Cleanup complete: ${result.total} items recovered`);
+      }
+      return result;
+    } catch (error) {
+      console.error("[WorkerOrchestrator] Failed to clean up orphaned work:", error);
+      return {
+        orphanedPages: 0,
+        orphanedSplittingTasks: 0,
+        orphanedMergingTasks: 0,
+        total: 0
+      };
+    }
+  }
+}
+const workerOrchestrator = new WorkerOrchestrator();
+const IPC_CHANNELS = {
+  // Provider channels
+  PROVIDER: {
+    GET_ALL: "provider:getAll",
+    GET_BY_ID: "provider:getById",
+    CREATE: "provider:create",
+    UPDATE: "provider:update",
+    DELETE: "provider:delete",
+    UPDATE_STATUS: "provider:updateStatus"
+  },
+  // Model channels
+  MODEL: {
+    GET_ALL: "model:getAll",
+    GET_BY_PROVIDER: "model:getByProvider",
+    CREATE: "model:create",
+    DELETE: "model:delete"
+  },
+  // Task channels
+  TASK: {
+    CREATE: "task:create",
+    GET_ALL: "task:getAll",
+    GET_BY_ID: "task:getById",
+    UPDATE: "task:update",
+    DELETE: "task:delete",
+    HAS_RUNNING: "task:hasRunningTasks"
+  },
+  // Task Detail channels
+  TASK_DETAIL: {
+    GET_BY_PAGE: "taskDetail:getByPage",
+    GET_ALL_BY_TASK: "taskDetail:getAllByTask",
+    RETRY: "taskDetail:retry",
+    RETRY_FAILED: "taskDetail:retryFailed",
+    GET_COST_STATS: "taskDetail:getCostStats"
+  },
+  // File channels
+  FILE: {
+    GET_IMAGE_PATH: "file:getImagePath",
+    DOWNLOAD_MARKDOWN: "file:downloadMarkdown",
+    SELECT_DIALOG: "file:selectDialog",
+    UPLOAD: "file:upload",
+    UPLOAD_MULTIPLE: "file:uploadMultiple",
+    UPLOAD_FILE_CONTENT: "file:uploadFileContent"
+  },
+  // Completion (LLM) channels
+  COMPLETION: {
+    MARK_IMAGEDOWN: "completion:markImagedown",
+    TEST_CONNECTION: "completion:testConnection"
+  }
+};
+function registerProviderHandlers() {
+  ipcMain.handle(IPC_CHANNELS.PROVIDER.GET_ALL, async () => {
+    try {
+      const providers = await providerRepository.findAll();
+      return { success: true, data: providers };
+    } catch (error) {
+      console.error("[IPC] provider:getAll error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.GET_BY_ID,
+    async (_, id) => {
+      try {
+        const provider = await providerRepository.findById(id);
+        if (!provider) {
+          return { success: false, error: "Provider not found" };
+        }
+        return { success: true, data: provider };
+      } catch (error) {
+        console.error("[IPC] provider:getById error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.CREATE,
+    async (_, data) => {
+      try {
+        const { name, type } = data;
+        if (!name || !type) {
+          return { success: false, error: "Name and type are required" };
+        }
+        const newProvider = await providerRepository.create({
+          name,
+          type,
+          api_key: "",
+          base_url: "",
+          suffix: "",
+          status: 0
+        });
+        return { success: true, data: newProvider };
+      } catch (error) {
+        console.error("[IPC] provider:create error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.UPDATE,
+    async (_, id, data) => {
+      try {
+        const existingProvider = await providerRepository.findById(id);
+        if (!existingProvider) {
+          return { success: false, error: "Provider not found" };
+        }
+        const updateData = {};
+        if (data.api_key !== void 0) updateData.api_key = data.api_key;
+        if (data.base_url !== void 0) updateData.base_url = data.base_url;
+        if (data.suffix !== void 0) updateData.suffix = data.suffix;
+        const updatedProvider = await providerRepository.update(id, updateData);
+        return { success: true, data: updatedProvider };
+      } catch (error) {
+        console.error("[IPC] provider:update error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.DELETE,
+    async (_, id) => {
+      try {
+        const existingProvider = await providerRepository.findById(id);
+        if (!existingProvider) {
+          return { success: false, error: "Provider not found" };
+        }
+        await providerRepository.remove(id);
+        return { success: true };
+      } catch (error) {
+        console.error("[IPC] provider:delete error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.UPDATE_STATUS,
+    async (_, id, status) => {
+      try {
+        if (status === void 0) {
+          return { success: false, error: "Invalid status value" };
+        }
+        const existingProvider = await providerRepository.findById(id);
+        if (!existingProvider) {
+          return { success: false, error: "Provider not found" };
+        }
+        const updatedProvider = await providerRepository.updateStatus(id, status);
+        return { success: true, data: updatedProvider };
+      } catch (error) {
+        console.error("[IPC] provider:updateStatus error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  console.log("[IPC] Provider handlers registered");
+}
+const findAll$1 = async () => {
+  return await prisma.model.findMany({
+    orderBy: [{ createdAt: "desc" }]
+  });
+};
+const findByProviderId = async (provider) => {
+  return await prisma.model.findMany({
+    where: { provider },
+    orderBy: [{ createdAt: "desc" }]
+  });
+};
+const create$1 = async (modelData) => {
+  return await prisma.model.create({
+    data: modelData
+  });
+};
+const remove$1 = async (id, provider) => {
+  return await prisma.model.delete({
+    where: {
+      id_provider: {
+        id,
+        provider
+      }
+    }
+  });
+};
+const removeByProviderId = async (provider) => {
+  return await prisma.model.deleteMany({
+    where: { provider }
+  });
+};
+const modelRepository = {
+  findAll: findAll$1,
+  findByProviderId,
+  create: create$1,
+  remove: remove$1,
+  removeByProviderId
+};
+function registerModelHandlers() {
+  ipcMain.handle(IPC_CHANNELS.MODEL.GET_ALL, async () => {
+    try {
+      const providers = await providerRepository.findAll();
+      const models = await modelRepository.findAll();
+      const groupedModels = providers.map((provider) => ({
+        provider: provider.id,
+        providerName: provider.name,
+        models: models.filter((model) => model.provider === provider.id)
+      }));
+      return { success: true, data: groupedModels };
+    } catch (error) {
+      console.error("[IPC] model:getAll error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(
+    IPC_CHANNELS.MODEL.GET_BY_PROVIDER,
+    async (_, providerId) => {
+      try {
+        const models = await modelRepository.findByProviderId(providerId);
+        return { success: true, data: models };
+      } catch (error) {
+        console.error("[IPC] model:getByProvider error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(IPC_CHANNELS.MODEL.CREATE, async (_, data) => {
+    try {
+      const { id, provider, name } = data;
+      if (!id || !provider || !name) {
+        return { success: false, error: "Model ID, provider ID, and name are required" };
+      }
+      const newModel = await modelRepository.create({ id, provider, name });
+      return { success: true, data: newModel };
+    } catch (error) {
+      console.error("[IPC] model:create error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(
+    IPC_CHANNELS.MODEL.DELETE,
+    async (_, id, provider) => {
+      try {
+        if (!id || !provider) {
+          return { success: false, error: "Model ID and provider ID are required" };
+        }
+        await modelRepository.remove(id, provider);
+        return { success: true, data: { message: "Model deleted successfully" } };
+      } catch (error) {
+        console.error("[IPC] model:delete error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  console.log("[IPC] Model handlers registered");
+}
+const findAll = async (page, pageSize) => {
+  return await prisma.task.findMany({
+    skip: (page - 1) * pageSize,
+    take: pageSize,
+    orderBy: {
+      createdAt: "desc"
+    }
+  });
+};
+const getTotal = async () => {
+  return await prisma.task.count();
+};
+const findById = async (id) => {
+  return await prisma.task.findUnique({
+    where: { id }
+  });
+};
+const create = async (task) => {
+  return await prisma.task.create({
+    data: {
+      id: v4(),
+      filename: task?.filename || "",
+      type: task?.type || "",
+      page_range: task?.page_range || "",
+      pages: task?.pages || 0,
+      provider: task?.provider || 0,
+      model: task?.model || "",
+      model_name: task?.model_name || "",
+      progress: 0,
+      status: 0
+    }
+  });
+};
+const createTasks = async (tasks) => {
+  const createdTasks = [];
+  for (const task of tasks) {
+    const createdTask = await create(task);
+    createdTasks.push(createdTask);
+  }
+  return createdTasks;
+};
+const update = async (id, task) => {
+  return await prisma.task.update({
+    where: { id },
+    data: task
+  });
+};
+const remove = async (id) => {
+  await prisma.task.delete({
+    where: { id }
+  });
+  return await prisma.taskDetail.deleteMany({
+    where: { task: id }
+  });
+};
+const taskRepository = {
+  findAll,
+  findById,
+  create,
+  createTasks,
+  getTotal,
+  update,
+  remove
+};
+function registerTaskHandlers() {
+  ipcMain.handle(
+    IPC_CHANNELS.TASK.CREATE,
+    async (_, tasks) => {
+      try {
+        if (!Array.isArray(tasks) || tasks.length === 0) {
+          return { success: false, error: "Task list cannot be empty" };
+        }
+        const tasksWithId = tasks.map((task) => ({
+          ...task,
+          id: v4(),
+          progress: 0,
+          status: -1
+          // CREATED - waiting for file upload
+        }));
+        const createdTasks = await taskRepository.createTasks(tasksWithId);
+        return { success: true, data: createdTasks };
+      } catch (error) {
+        console.error("[IPC] task:create error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK.GET_ALL,
+    async (_, params) => {
+      try {
+        const { page = 1, pageSize = 10 } = params || {};
+        const tasks = await taskRepository.findAll(page, pageSize);
+        const total = await taskRepository.getTotal();
+        return { success: true, data: { list: tasks, total } };
+      } catch (error) {
+        console.error("[IPC] task:getAll error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(IPC_CHANNELS.TASK.GET_BY_ID, async (_, id) => {
+    try {
+      if (!id) {
+        return { success: false, error: "Task ID is required" };
+      }
+      const task = await taskRepository.findById(id);
+      if (!task) {
+        return { success: false, error: "Task not found" };
+      }
+      return { success: true, data: task };
+    } catch (error) {
+      console.error("[IPC] task:getById error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(
+    IPC_CHANNELS.TASK.UPDATE,
+    async (_, id, data) => {
+      try {
+        const updatedTask = await taskRepository.update(id, data);
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId: id,
+          task: updatedTask,
+          timestamp: Date.now()
+        });
+        if (data.status !== void 0) {
+          eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+            taskId: id,
+            task: { status: data.status },
+            timestamp: Date.now()
+          });
+        }
+        return { success: true, data: updatedTask };
+      } catch (error) {
+        console.error("[IPC] task:update error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(IPC_CHANNELS.TASK.DELETE, async (_, id) => {
+    try {
+      await fileLogic.deleteTaskFiles(id);
+      const deletedTask = await taskRepository.remove(id);
+      eventBus.emitTaskEvent(TaskEventType.TASK_DELETED, {
+        taskId: id,
+        timestamp: Date.now()
+      });
+      return { success: true, data: deletedTask };
+    } catch (error) {
+      console.error("[IPC] task:delete error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(IPC_CHANNELS.TASK.HAS_RUNNING, async () => {
+    try {
+      const runningStatuses = [
+        TaskStatus.PENDING,
+        TaskStatus.SPLITTING,
+        TaskStatus.PROCESSING,
+        TaskStatus.READY_TO_MERGE,
+        TaskStatus.MERGING
+      ];
+      const count = await prisma.task.count({
+        where: {
+          status: {
+            in: runningStatuses
+          }
+        }
+      });
+      return { success: true, data: { hasRunning: count > 0, count } };
+    } catch (error) {
+      console.error("[IPC] task:hasRunningTasks error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  console.log("[IPC] Task handlers registered");
+}
+const findByTaskId = async (taskId) => {
+  return await prisma.taskDetail.findMany({
+    where: { task: taskId },
+    orderBy: {
+      page: "asc"
+    }
+  });
+};
+const findByTaskAndPage = async (taskId, page) => {
+  return await prisma.taskDetail.findFirst({
+    where: {
+      task: taskId,
+      page
+    }
+  });
+};
+const countByTaskId = async (taskId) => {
+  return await prisma.taskDetail.count({
+    where: { task: taskId }
+  });
+};
+const taskDetailRepository = {
+  findByTaskId,
+  findByTaskAndPage,
+  countByTaskId
+};
+function registerTaskDetailHandlers() {
+  ipcMain.handle(
+    IPC_CHANNELS.TASK_DETAIL.GET_BY_PAGE,
+    async (_, taskId, page) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        if (!page || page < 1) {
+          return { success: false, error: "Page number must be greater than 0" };
+        }
+        const taskDetail = await taskDetailRepository.findByTaskAndPage(taskId, page);
+        if (!taskDetail) {
+          return { success: false, error: "Page detail not found" };
+        }
+        const imagePath = ImagePathUtil.getPath(taskId, page);
+        const imageExists = fs.existsSync(imagePath);
+        const taskDetailWithImage = {
+          ...taskDetail,
+          imagePath,
+          imageExists
+        };
+        return { success: true, data: taskDetailWithImage };
+      } catch (error) {
+        console.error("[IPC] taskDetail:getByPage error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK_DETAIL.GET_ALL_BY_TASK,
+    async (_, taskId) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        const taskDetails = await taskDetailRepository.findByTaskId(taskId);
+        return { success: true, data: taskDetails };
+      } catch (error) {
+        console.error("[IPC] taskDetail:getAllByTask error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK_DETAIL.RETRY,
+    async (_, pageId) => {
+      try {
+        if (!pageId) {
+          return { success: false, error: "Page ID is required" };
+        }
+        const result = await prisma.$transaction(async (tx) => {
+          const page = await tx.taskDetail.findUnique({
+            where: { id: pageId }
+          });
+          if (!page) {
+            throw new Error("Page not found");
+          }
+          if (page.status !== PageStatus.FAILED && page.status !== PageStatus.COMPLETED) {
+            throw new Error("Can only retry failed or completed pages");
+          }
+          const task = await tx.task.findUnique({
+            where: { id: page.task }
+          });
+          if (!task) {
+            throw new Error("Task not found");
+          }
+          if (task.status === TaskStatus.CANCELLED) {
+            throw new Error("Task is cancelled, cannot retry");
+          }
+          const updatedPage = await tx.taskDetail.update({
+            where: { id: pageId },
+            data: {
+              status: PageStatus.PENDING,
+              retry_count: 0,
+              error: null,
+              worker_id: null,
+              started_at: null,
+              completed_at: null,
+              input_tokens: 0,
+              output_tokens: 0,
+              conversion_time: 0,
+              content: ""
+            }
+          });
+          const decrementField = page.status === PageStatus.FAILED ? "failed_count" : "completed_count";
+          const updatedTask = await tx.task.update({
+            where: { id: page.task },
+            data: {
+              [decrementField]: { decrement: 1 },
+              status: TaskStatus.PROCESSING,
+              progress: Math.max(0, task.progress - Math.round(100 / task.pages))
+            }
+          });
+          return { page: updatedPage, task: updatedTask };
+        }, {
+          isolationLevel: "Serializable"
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId: result.task.id,
+          task: result.task,
+          timestamp: Date.now()
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+          taskId: result.task.id,
+          task: { status: result.task.status },
+          timestamp: Date.now()
+        });
+        return { success: true, data: result.page };
+      } catch (error) {
+        console.error("[IPC] taskDetail:retry error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK_DETAIL.RETRY_FAILED,
+    async (_, taskId) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        const result = await prisma.$transaction(async (tx) => {
+          const task = await tx.task.findUnique({
+            where: { id: taskId }
+          });
+          if (!task) {
+            throw new Error("Task not found");
+          }
+          if (task.status === TaskStatus.CANCELLED) {
+            throw new Error("Task is cancelled, cannot retry");
+          }
+          const failedCount = await tx.taskDetail.count({
+            where: {
+              task: taskId,
+              status: PageStatus.FAILED
+            }
+          });
+          if (failedCount === 0) {
+            throw new Error("No failed pages to retry");
+          }
+          await tx.taskDetail.updateMany({
+            where: {
+              task: taskId,
+              status: PageStatus.FAILED
+            },
+            data: {
+              status: PageStatus.PENDING,
+              retry_count: 0,
+              error: null,
+              worker_id: null,
+              started_at: null,
+              completed_at: null,
+              input_tokens: 0,
+              output_tokens: 0,
+              conversion_time: 0,
+              content: ""
+            }
+          });
+          const updatedTask = await tx.task.update({
+            where: { id: taskId },
+            data: {
+              failed_count: 0,
+              status: TaskStatus.PROCESSING,
+              progress: Math.round(task.completed_count / task.pages * 100)
+            }
+          });
+          return { updatedCount: failedCount, task: updatedTask };
+        }, {
+          isolationLevel: "Serializable"
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId: result.task.id,
+          task: result.task,
+          timestamp: Date.now()
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+          taskId: result.task.id,
+          task: { status: result.task.status },
+          timestamp: Date.now()
+        });
+        return { success: true, data: { retried: result.updatedCount } };
+      } catch (error) {
+        console.error("[IPC] taskDetail:retryFailed error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK_DETAIL.GET_COST_STATS,
+    async (_, taskId) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        const aggregate = await prisma.taskDetail.aggregate({
+          where: { task: taskId },
+          _sum: {
+            input_tokens: true,
+            output_tokens: true,
+            conversion_time: true
+          },
+          _avg: {
+            conversion_time: true
+          },
+          _count: {
+            id: true
+          }
+        });
+        const byStatus = await prisma.taskDetail.groupBy({
+          by: ["status"],
+          where: { task: taskId },
+          _count: {
+            id: true
+          },
+          _sum: {
+            input_tokens: true,
+            output_tokens: true
+          }
+        });
+        const statusMap = {
+          [-1]: "failed",
+          [0]: "pending",
+          [1]: "processing",
+          [2]: "completed",
+          [3]: "retrying"
+        };
+        const byStatusFormatted = byStatus.reduce((acc, item) => {
+          const statusName = statusMap[item.status] || `status_${item.status}`;
+          acc[statusName] = {
+            count: item._count.id,
+            input_tokens: item._sum.input_tokens || 0,
+            output_tokens: item._sum.output_tokens || 0
+          };
+          return acc;
+        }, {});
+        return {
+          success: true,
+          data: {
+            total: {
+              pages: aggregate._count.id,
+              input_tokens: aggregate._sum.input_tokens || 0,
+              output_tokens: aggregate._sum.output_tokens || 0,
+              total_tokens: (aggregate._sum.input_tokens || 0) + (aggregate._sum.output_tokens || 0),
+              total_conversion_time: aggregate._sum.conversion_time || 0,
+              avg_conversion_time: Math.round(aggregate._avg.conversion_time || 0)
+            },
+            byStatus: byStatusFormatted
+          }
+        };
+      } catch (error) {
+        console.error("[IPC] taskDetail:getCostStats error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  console.log("[IPC] TaskDetail handlers registered");
+}
+function registerFileHandlers() {
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.GET_IMAGE_PATH,
+    async (_, taskId, page) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        if (!page || page < 1) {
+          return { success: false, error: "Page number must be greater than 0" };
+        }
+        const imagePath = ImagePathUtil.getPath(taskId, page);
+        const exists = fs.existsSync(imagePath);
+        return {
+          success: true,
+          data: { imagePath, exists }
+        };
+      } catch (error) {
+        console.error("[IPC] file:getImagePath error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.DOWNLOAD_MARKDOWN,
+    async (_, taskId) => {
+      try {
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        const task = await taskRepository.findById(taskId);
+        if (!task) {
+          return { success: false, error: "Task not found" };
+        }
+        if (!task.merged_path) {
+          return { success: false, error: "Merged file does not exist, task may not be completed" };
+        }
+        if (!fs.existsSync(task.merged_path)) {
+          return { success: false, error: "Merged file is missing" };
+        }
+        const result = await dialog.showSaveDialog({
+          title: "Save Markdown File",
+          defaultPath: task.filename.replace(/\.[^/.]+$/, ".md"),
+          filters: [
+            { name: "Markdown Files", extensions: ["md"] },
+            { name: "All Files", extensions: ["*"] }
+          ]
+        });
+        if (result.canceled || !result.filePath) {
+          return { success: false, error: "User cancelled save" };
+        }
+        fs.copyFileSync(task.merged_path, result.filePath);
+        return {
+          success: true,
+          data: { savedPath: result.filePath }
+        };
+      } catch (error) {
+        console.error("[IPC] file:downloadMarkdown error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(IPC_CHANNELS.FILE.SELECT_DIALOG, async () => {
+    try {
+      const result = await dialog.showOpenDialog({
+        properties: ["openFile", "multiSelections"],
+        filters: [
+          {
+            name: "PDF and Images",
+            extensions: ["pdf", "jpg", "jpeg", "png", "bmp", "gif"]
+          },
+          { name: "PDF Documents", extensions: ["pdf"] },
+          { name: "Images", extensions: ["jpg", "jpeg", "png", "bmp", "gif"] },
+          { name: "All Files", extensions: ["*"] }
+        ]
+      });
+      return {
+        success: true,
+        data: { filePaths: result.filePaths, canceled: result.canceled }
+      };
+    } catch (error) {
+      console.error("[IPC] file:selectDialog error:", error);
+      return { success: false, error: error.message };
+    }
+  });
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.UPLOAD,
+    async (_, taskId, filePath) => {
+      try {
+        if (!taskId || !filePath) {
+          return { success: false, error: "Task ID and file path are required" };
+        }
+        if (!fs.existsSync(filePath)) {
+          return { success: false, error: "File does not exist" };
+        }
+        const baseUploadDir = fileLogic.getUploadDir();
+        const uploadDir = path.join(baseUploadDir, taskId);
+        if (!fs.existsSync(uploadDir)) {
+          fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        const fileName = path.basename(filePath);
+        const destPath = path.join(uploadDir, fileName);
+        fs.copyFileSync(filePath, destPath);
+        const stats = fs.statSync(destPath);
+        const fileInfo = {
+          originalName: fileName,
+          savedName: fileName,
+          path: destPath,
+          size: stats.size,
+          taskId
+        };
+        return { success: true, data: fileInfo };
+      } catch (error) {
+        console.error("[IPC] file:upload error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.UPLOAD_MULTIPLE,
+    async (_, taskId, filePaths) => {
+      try {
+        if (!taskId || !Array.isArray(filePaths) || filePaths.length === 0) {
+          return { success: false, error: "Task ID and file path list are required" };
+        }
+        const uploadResults = [];
+        for (const filePath of filePaths) {
+          if (!fs.existsSync(filePath)) {
+            continue;
+          }
+          const baseUploadDir = fileLogic.getUploadDir();
+          const uploadDir = path.join(baseUploadDir, taskId);
+          if (!fs.existsSync(uploadDir)) {
+            fs.mkdirSync(uploadDir, { recursive: true });
+          }
+          const fileName = path.basename(filePath);
+          const destPath = path.join(uploadDir, fileName);
+          fs.copyFileSync(filePath, destPath);
+          const stats = fs.statSync(destPath);
+          uploadResults.push({
+            originalName: fileName,
+            savedName: fileName,
+            path: destPath,
+            size: stats.size,
+            taskId
+          });
+        }
+        return {
+          success: true,
+          data: { message: "Files uploaded successfully", files: uploadResults }
+        };
+      } catch (error) {
+        console.error("[IPC] file:uploadMultiple error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.UPLOAD_FILE_CONTENT,
+    async (_, taskId, fileName, fileBuffer) => {
+      try {
+        if (!taskId || !fileName || !fileBuffer) {
+          return { success: false, error: "Task ID, file name, and file content are required" };
+        }
+        const baseUploadDir = fileLogic.getUploadDir();
+        const uploadDir = path.join(baseUploadDir, taskId);
+        if (!fs.existsSync(uploadDir)) {
+          fs.mkdirSync(uploadDir, { recursive: true });
+        }
+        const destPath = path.join(uploadDir, fileName);
+        const buffer = Buffer.from(fileBuffer);
+        fs.writeFileSync(destPath, buffer);
+        const stats = fs.statSync(destPath);
+        const fileInfo = {
+          originalName: fileName,
+          savedName: fileName,
+          path: destPath,
+          size: stats.size,
+          taskId
+        };
+        return { success: true, data: fileInfo };
+      } catch (error) {
+        console.error("[IPC] file:uploadFileContent error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  console.log("[IPC] File handlers registered");
+}
+function registerCompletionHandlers() {
+  ipcMain.handle(
+    IPC_CHANNELS.COMPLETION.MARK_IMAGEDOWN,
+    async (_, providerId, modelId, url) => {
+      try {
+        if (!providerId || !modelId || !url) {
+          return { success: false, error: "providerId, modelId, and url are required" };
+        }
+        const result = await modelLogic.completion(providerId, {
+          model: modelId,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "image_url",
+                  image_url: { url }
+                },
+                {
+                  type: "text",
+                  text: "Convert this image to markdown."
+                }
+              ]
+            }
+          ]
+        });
+        return { success: true, data: result };
+      } catch (error) {
+        console.error("[IPC] completion:markImagedown error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.COMPLETION.TEST_CONNECTION,
+    async (_, providerId, modelId) => {
+      try {
+        if (!providerId || !modelId) {
+          return { success: false, error: "providerId and modelId are required" };
+        }
+        const testImageBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+        const result = await modelLogic.completion(providerId, {
+          model: modelId,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "image_url",
+                  image_url: {
+                    url: `data:image/png;base64,${testImageBase64}`
+                  }
+                },
+                {
+                  type: "text",
+                  text: "Test connection."
+                }
+              ]
+            }
+          ]
+        });
+        return { success: true, data: result };
+      } catch (error) {
+        console.error("[IPC] completion:testConnection error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  console.log("[IPC] Completion handlers registered");
+}
+function registerAppHandlers() {
+  ipcMain.handle("app:getVersion", () => {
+    return app.getVersion();
+  });
+}
+function registerAllHandlers() {
+  registerProviderHandlers();
+  registerModelHandlers();
+  registerTaskHandlers();
+  registerTaskDetailHandlers();
+  registerFileHandlers();
+  registerCompletionHandlers();
+  registerAppHandlers();
+  console.log("[IPC] All handlers registered successfully");
+}
+function registerIpcHandlers() {
+  registerAllHandlers();
+}
+class WindowManager {
+  static instance;
+  mainWindow = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!WindowManager.instance) {
+      WindowManager.instance = new WindowManager();
+    }
+    return WindowManager.instance;
+  }
+  setMainWindow(window) {
+    this.mainWindow = window;
+    if (window) {
+      window.on("closed", () => {
+        this.mainWindow = null;
+      });
+    }
+  }
+  getMainWindow() {
+    return this.mainWindow;
+  }
+  isWindowAvailable() {
+    return this.mainWindow !== null && !this.mainWindow.isDestroyed();
+  }
+  sendToRenderer(channel, ...args) {
+    if (this.isWindowAvailable()) {
+      this.mainWindow.webContents.send(channel, ...args);
+    } else {
+      console.warn(`[WindowManager] Window not available (channel: ${channel})`);
+    }
+  }
+}
+const windowManager = WindowManager.getInstance();
+class EventBridge {
+  isInitialized = false;
+  initialize() {
+    if (this.isInitialized) return;
+    eventBus.onTaskEvent("task:*", this.handleTaskEvent.bind(this));
+    eventBus.onTaskDetailEvent("taskDetail:*", this.handleTaskDetailEvent.bind(this));
+    this.isInitialized = true;
+    console.log("[EventBridge] Initialized");
+  }
+  handleTaskEvent(data) {
+    const { type, taskId, task, timestamp } = data;
+    windowManager.sendToRenderer("task:event", {
+      type,
+      taskId,
+      task,
+      timestamp
+    });
+  }
+  handleTaskDetailEvent(data) {
+    const { type, taskId, pageId, page, status, timestamp } = data;
+    windowManager.sendToRenderer("taskDetail:event", {
+      type,
+      taskId,
+      pageId,
+      page,
+      status,
+      timestamp
+    });
+  }
+  cleanup() {
+    eventBus.removeAllListeners();
+    this.isInitialized = false;
+  }
+}
+const eventBridge = new EventBridge();
+protocol.registerSchemesAsPrivileged([
+  {
+    scheme: "local-file",
+    privileges: {
+      secure: true,
+      supportFetchAPI: true,
+      bypassCSP: false,
+      corsEnabled: false
+    }
+  }
+]);
+let mainWindow;
+function registerLocalFileProtocol() {
+  protocol.registerFileProtocol("local-file", (request, callback) => {
+    try {
+      let url = request.url.substring("local-file://".length);
+      if (url.startsWith("/") && /^\/[A-Za-z]:/.test(url)) {
+        url = url.substring(1);
+      }
+      const decodedPath = decodeURIComponent(url);
+      const uploadsDir = fileLogic.getUploadDir();
+      const tempDir = fileLogic.getTempDir();
+      const normalizedPath = path.normalize(decodedPath);
+      const isInUploads = normalizedPath.startsWith(uploadsDir);
+      const isInTemp = normalizedPath.startsWith(tempDir);
+      if (!isInUploads && !isInTemp) {
+        console.error("[Protocol] Attempted to access file outside allowed directories:", normalizedPath);
+        callback({ error: -10 });
+        return;
+      }
+      if (!fs.existsSync(normalizedPath)) {
+        console.error("[Protocol] File not found:", normalizedPath);
+        callback({ error: -6 });
+        return;
+      }
+      callback({ path: normalizedPath });
+    } catch (error) {
+      console.error("[Protocol] Error handling local-file request:", error);
+      callback({ error: -2 });
+    }
+  });
+}
+async function startTask() {
+  await workerOrchestrator.start();
+}
+async function stopTask() {
+  await workerOrchestrator.stop();
+}
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    // macOS: 使用隐藏标题栏，Windows/Linux: 使用无边框窗口
+    ...process.platform === "darwin" ? { titleBarStyle: "hidden" } : { frame: false },
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      preload: path.join(__dirname, "../preload/index.js")
+    },
+    icon: path.join(
+      process.env.ELECTRON_RENDERER_URL ? process.cwd() : app.getAppPath(),
+      process.platform === "darwin" ? "public/icons/mac/icon.icns" : process.platform === "win32" ? "public/icons/win/icon.ico" : "public/icons/png/512x512.png"
+    )
+  });
+  windowManager.setMainWindow(mainWindow);
+  if (process.env.ELECTRON_RENDERER_URL) {
+    mainWindow.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+  }
+  mainWindow.webContents.on("will-navigate", (event, url) => {
+    if (url.startsWith("http") && !url.includes("localhost")) {
+      event.preventDefault();
+      shell.openExternal(url);
+    }
+  });
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    if (url.startsWith("http")) {
+      shell.openExternal(url);
+      return { action: "deny" };
+    }
+    return { action: "allow" };
+  });
+  ipcMain.on("open-external-link", (_, url) => {
+    if (url && typeof url === "string") {
+      shell.openExternal(url);
+    }
+  });
+  ipcMain.on("window:minimize", () => {
+    if (mainWindow) {
+      mainWindow.minimize();
+    }
+  });
+  ipcMain.on("window:maximize", () => {
+    if (mainWindow) {
+      if (mainWindow.isMaximized()) {
+        mainWindow.unmaximize();
+      } else {
+        mainWindow.maximize();
+      }
+    }
+  });
+  ipcMain.on("window:close", () => {
+    if (mainWindow) {
+      mainWindow.close();
+    }
+  });
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+    windowManager.setMainWindow(null);
+  });
+}
+app.whenReady().then(async () => {
+  try {
+    const startTime = Date.now();
+    registerLocalFileProtocol();
+    console.log("[Main] Custom protocol 'local-file' registered");
+    registerIpcHandlers();
+    eventBridge.initialize();
+    createWindow();
+    console.log(`[Main] Window created in ${Date.now() - startTime}ms`);
+    initializeBackgroundServices().catch((error) => {
+      console.error("[Main] Background services initialization failed:", error);
+    });
+  } catch (error) {
+    console.error("[Main] Error starting application:", error);
+    app.quit();
+  }
+});
+async function initializeBackgroundServices() {
+  try {
+    const startTime = Date.now();
+    console.log("[Main] Initializing database in background...");
+    await initDatabase();
+    console.log(`[Main] Database initialized in ${Date.now() - startTime}ms`);
+    console.log("[Main] Starting task logic in background...");
+    const taskStartTime = Date.now();
+    await startTask();
+    console.log(`[Main] Task logic started in ${Date.now() - taskStartTime}ms`);
+    console.log(
+      `[Main] Background services initialized successfully in ${Date.now() - startTime}ms`
+    );
+    if (mainWindow) {
+      mainWindow.webContents.send("app:ready");
+    }
+  } catch (error) {
+    console.error("[Main] Background services initialization error:", error);
+    throw error;
+  }
+}
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    if (workerOrchestrator.getStatus()) {
+      stopTask();
+    }
+    eventBridge.cleanup();
+    disconnect();
+    app.quit();
+  }
+});
+app.on("activate", async () => {
+  if (mainWindow === null) {
+    try {
+      createWindow();
+      if (!workerOrchestrator.getStatus()) {
+        await startTask();
+      }
+    } catch (error) {
+      console.error("[Main] Error reactivating application:", error);
+      app.quit();
+    }
+  }
+});
+export {
+  LLMClient as L
+};