markpdfdown 0.4.2 → 0.4.5

package/dist/main/index.js

@@ -1,4 +1,4 @@
-import { app, ipcMain, dialog, shell, safeStorage, protocol, nativeImage, BrowserWindow } from "electron";
+import { app, ipcMain, dialog, clipboard, nativeImage, shell, safeStorage, protocol, BrowserWindow } from "electron";
 import path from "path";
 import fs, { promises } from "fs";
 import isDev from "electron-is-dev";
@@ -1653,7 +1653,14 @@ class ConverterWorker extends WorkerBase {
             }
             const task = await tx.task.findUnique({
               where: { id: page.task },
-              select: { status: true, pages: true, completed_count: true, failed_count: true }
+              select: {
+                status: true,
+                pages: true,
+                completed_count: true,
+                failed_count: true,
+                provider: true,
+                model: true
+              }
             });
             if (!task) {
               throw new Error("Task not found");
@@ -1672,7 +1679,9 @@ class ConverterWorker extends WorkerBase {
                 completed_at: /* @__PURE__ */ new Date(),
                 worker_id: null,
                 // Release worker
-                error: null
+                error: null,
+                provider: task.provider,
+                model: task.model
               }
             });
             const updatedTask = await tx.task.update({
@@ -1737,7 +1746,14 @@ class ConverterWorker extends WorkerBase {
             }
             const task = await tx.task.findUnique({
               where: { id: page.task },
-              select: { status: true, pages: true, completed_count: true, failed_count: true }
+              select: {
+                status: true,
+                pages: true,
+                completed_count: true,
+                failed_count: true,
+                provider: true,
+                model: true
+              }
             });
             if (!task) {
               throw new Error("Task not found");
@@ -1751,8 +1767,10 @@ class ConverterWorker extends WorkerBase {
                 status: PageStatus.FAILED,
                 error: errorMessage,
                 completed_at: /* @__PURE__ */ new Date(),
-                worker_id: null
+                worker_id: null,
                 // Release worker
+                provider: task.provider,
+                model: task.model
               }
             });
             const updatedTask = await tx.task.update({
@@ -2620,6 +2638,7 @@ const IPC_CHANNELS = {
     GET_ALL: "task:getAll",
     GET_BY_ID: "task:getById",
     UPDATE: "task:update",
+    RETRY: "task:retry",
     DELETE: "task:delete",
     HAS_RUNNING: "task:hasRunningTasks"
   },
@@ -2635,6 +2654,7 @@ const IPC_CHANNELS = {
   FILE: {
     GET_IMAGE_PATH: "file:getImagePath",
     DOWNLOAD_MARKDOWN: "file:downloadMarkdown",
+    COPY_IMAGE_TO_CLIPBOARD: "file:copyImageToClipboard",
     SELECT_DIALOG: "file:selectDialog",
     UPLOAD: "file:upload",
     UPLOAD_FILE_CONTENT: "file:uploadFileContent"
@@ -3122,6 +3142,123 @@ function registerTaskHandlers() {
       }
     }
   );
+  ipcMain.handle(
+    IPC_CHANNELS.TASK.RETRY,
+    async (_, params) => {
+      try {
+        const payload = typeof params === "string" ? { taskId: params } : params;
+        const taskId = payload?.taskId;
+        if (!taskId) {
+          return { success: false, error: "Task ID is required" };
+        }
+        const hasProviderOverride = payload?.providerId !== void 0;
+        const hasModelOverride = payload?.modelId !== void 0;
+        const hasAnyModelOverride = hasProviderOverride || hasModelOverride;
+        if (hasAnyModelOverride && (!hasProviderOverride || !hasModelOverride)) {
+          return { success: false, error: "providerId and modelId must be provided together" };
+        }
+        const updatedTask = await prisma.$transaction(async (tx) => {
+          const task = await tx.task.findUnique({
+            where: { id: taskId }
+          });
+          if (!task) {
+            throw new Error("Task not found");
+          }
+          const retryableStatuses = [
+            TaskStatus.FAILED,
+            TaskStatus.COMPLETED,
+            TaskStatus.CANCELLED,
+            TaskStatus.PARTIAL_FAILED
+          ];
+          if (!retryableStatuses.includes(task.status)) {
+            throw new Error("Task is not retryable");
+          }
+          let targetProvider = task.provider;
+          let targetModel = task.model;
+          let targetModelName = task.model_name;
+          if (hasAnyModelOverride) {
+            const providerId = payload.providerId;
+            const modelId = payload.modelId;
+            const provider = await tx.provider.findUnique({
+              where: { id: providerId },
+              select: { id: true, name: true, status: true }
+            });
+            if (!provider || provider.status !== 0) {
+              throw new Error("Provider not found or disabled");
+            }
+            const model = await tx.model.findUnique({
+              where: {
+                id_provider: {
+                  id: modelId,
+                  provider: providerId
+                }
+              },
+              select: { id: true, name: true, provider: true }
+            });
+            if (!model) {
+              throw new Error("Model not found for provider");
+            }
+            targetProvider = providerId;
+            targetModel = modelId;
+            targetModelName = `${model.name} | ${provider.name}`;
+          }
+          const detailCount = await tx.taskDetail.count({
+            where: { task: taskId }
+          });
+          if (detailCount > 0) {
+            await tx.taskDetail.updateMany({
+              where: { task: taskId },
+              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: "",
+                provider: targetProvider,
+                model: targetModel
+              }
+            });
+          }
+          return await tx.task.update({
+            where: { id: taskId },
+            data: {
+              provider: targetProvider,
+              model: targetModel,
+              model_name: targetModelName,
+              status: detailCount > 0 ? TaskStatus.PROCESSING : TaskStatus.PENDING,
+              progress: 0,
+              completed_count: 0,
+              failed_count: 0,
+              error: null,
+              merged_path: null,
+              worker_id: null
+            }
+          });
+        }, {
+          isolationLevel: "Serializable"
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_UPDATED, {
+          taskId,
+          task: updatedTask,
+          timestamp: Date.now()
+        });
+        eventBus.emitTaskEvent(TaskEventType.TASK_STATUS_CHANGED, {
+          taskId,
+          task: { status: updatedTask.status },
+          timestamp: Date.now()
+        });
+        return { success: true, data: updatedTask };
+      } catch (error) {
+        console.error("[IPC] task:retry error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
   ipcMain.handle(IPC_CHANNELS.TASK.DELETE, async (_, id) => {
     try {
       await fileLogic.deleteTaskFiles(id);
@@ -3232,11 +3369,19 @@ function registerTaskDetailHandlers() {
   );
   ipcMain.handle(
     IPC_CHANNELS.TASK_DETAIL.RETRY,
-    async (_, pageId) => {
+    async (_, params) => {
       try {
+        const payload = typeof params === "number" ? { pageId: params } : params;
+        const pageId = payload?.pageId;
         if (!pageId) {
           return { success: false, error: "Page ID is required" };
         }
+        const hasProviderOverride = payload?.providerId !== void 0;
+        const hasModelOverride = payload?.modelId !== void 0;
+        const hasAnyModelOverride = hasProviderOverride || hasModelOverride;
+        if (hasAnyModelOverride && (!hasProviderOverride || !hasModelOverride)) {
+          return { success: false, error: "providerId and modelId must be provided together" };
+        }
         const result = await prisma.$transaction(async (tx) => {
           const page = await tx.taskDetail.findUnique({
             where: { id: pageId }
@@ -3256,6 +3401,33 @@ function registerTaskDetailHandlers() {
           if (task.status === TaskStatus.CANCELLED) {
             throw new Error("Task is cancelled, cannot retry");
           }
+          let targetProvider = page.provider;
+          let targetModel = page.model;
+          if (hasAnyModelOverride) {
+            const providerId = payload.providerId;
+            const modelId = payload.modelId;
+            const provider = await tx.provider.findUnique({
+              where: { id: providerId },
+              select: { id: true, status: true }
+            });
+            if (!provider || provider.status !== 0) {
+              throw new Error("Provider not found or disabled");
+            }
+            const model = await tx.model.findUnique({
+              where: {
+                id_provider: {
+                  id: modelId,
+                  provider: providerId
+                }
+              },
+              select: { id: true }
+            });
+            if (!model) {
+              throw new Error("Model not found for provider");
+            }
+            targetProvider = providerId;
+            targetModel = modelId;
+          }
           const updatedPage = await tx.taskDetail.update({
             where: { id: pageId },
             data: {
@@ -3268,7 +3440,9 @@ function registerTaskDetailHandlers() {
               input_tokens: 0,
               output_tokens: 0,
               conversion_time: 0,
-              content: ""
+              content: "",
+              provider: targetProvider,
+              model: targetModel
             }
           });
           const decrementField = page.status === PageStatus.FAILED ? "failed_count" : "completed_count";
@@ -3444,6 +3618,20 @@ function registerTaskDetailHandlers() {
   );
   console.log("[IPC] TaskDetail handlers registered");
 }
+async function createImageFromSource(imageSource) {
+  const normalizedSource = imageSource.trim();
+  const lowerSource = normalizedSource.toLowerCase();
+  if (lowerSource.startsWith("data:image/")) {
+    return nativeImage.createFromDataURL(normalizedSource);
+  }
+  if (lowerSource.startsWith("http://") || lowerSource.startsWith("https://")) {
+    throw new Error("Remote image URLs are not allowed");
+  }
+  if (lowerSource.startsWith("file://")) {
+    return nativeImage.createFromPath(fileURLToPath(normalizedSource));
+  }
+  return nativeImage.createFromPath(normalizedSource);
+}
 function registerFileHandlers() {
   ipcMain.handle(
     IPC_CHANNELS.FILE.GET_IMAGE_PATH,
@@ -3506,6 +3694,25 @@ function registerFileHandlers() {
       }
     }
   );
+  ipcMain.handle(
+    IPC_CHANNELS.FILE.COPY_IMAGE_TO_CLIPBOARD,
+    async (_, imageSource) => {
+      try {
+        if (!imageSource) {
+          return { success: false, error: "Image source is required" };
+        }
+        const image = await createImageFromSource(imageSource);
+        if (image.isEmpty()) {
+          return { success: false, error: "Image data is empty or invalid" };
+        }
+        clipboard.writeImage(image);
+        return { success: true, data: { copied: true } };
+      } catch (error) {
+        console.error("[IPC] file:copyImageToClipboard error:", error);
+        return { success: false, error: error.message || "Failed to copy image" };
+      }
+    }
+  );
   ipcMain.handle(IPC_CHANNELS.FILE.SELECT_DIALOG, async (_, allowOffice) => {
     try {
       const pdfAndImageExtensions = ["pdf", "jpg", "jpeg", "png", "bmp", "gif"];
@@ -4373,6 +4580,88 @@ class CloudService {
   static instance;
   constructor() {
   }
+  extractDownloadFileName(contentDisposition, fallback) {
+    const rfc5987Name = this.parseRFC5987Filename(contentDisposition);
+    if (rfc5987Name) {
+      return this.sanitizeDownloadFileName(rfc5987Name, fallback);
+    }
+    const plainName = this.parsePlainFilename(contentDisposition);
+    if (!plainName) {
+      return this.sanitizeDownloadFileName(fallback, fallback);
+    }
+    const repairedName = this.tryRepairUtf8Mojibake(plainName);
+    return this.sanitizeDownloadFileName(repairedName || plainName, fallback);
+  }
+  parseRFC5987Filename(contentDisposition) {
+    const match = contentDisposition.match(/filename\*\s*=\s*([^;]+)/i);
+    if (!match) return null;
+    const rawValue = match[1]?.trim();
+    if (!rawValue) return null;
+    const unquoted = rawValue.replace(/^"(.*)"$/, "$1");
+    const parts = unquoted.match(/^([^']*)'[^']*'(.*)$/);
+    if (!parts) return null;
+    const charset = (parts[1] || "utf-8").trim().toLowerCase();
+    const encodedValue = parts[2] || "";
+    try {
+      if (charset === "utf-8" || charset === "utf8") {
+        return decodeURIComponent(encodedValue);
+      }
+      const bytes = this.percentDecodeToBytes(encodedValue);
+      if (charset === "iso-8859-1" || charset === "latin1") {
+        return Buffer.from(bytes).toString("latin1");
+      }
+      return Buffer.from(bytes).toString("utf8");
+    } catch {
+      return null;
+    }
+  }
+  parsePlainFilename(contentDisposition) {
+    const match = contentDisposition.match(/filename\s*=\s*("(?:\\.|[^"])*"|[^;]+)/i);
+    if (!match) return null;
+    let value = match[1]?.trim();
+    if (!value) return null;
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    return value;
+  }
+  percentDecodeToBytes(input) {
+    const bytes = [];
+    for (let i = 0; i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        const parsed = Number.parseInt(hex, 16);
+        if (!Number.isNaN(parsed)) {
+          bytes.push(parsed);
+          i += 2;
+          continue;
+        }
+      }
+      bytes.push(input.charCodeAt(i));
+    }
+    return bytes;
+  }
+  tryRepairUtf8Mojibake(input) {
+    const hasCjk = /[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(input);
+    if (hasCjk) return null;
+    const latinSupplementCount = Array.from(input).filter((ch) => {
+      const code = ch.charCodeAt(0);
+      return code >= 192 && code <= 255;
+    }).length;
+    if (latinSupplementCount < 2) return null;
+    const repaired = Buffer.from(input, "latin1").toString("utf8");
+    if (!repaired) return null;
+    const repairedHasCjk = /[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(repaired);
+    const roundTrip = Buffer.from(repaired, "utf8").toString("latin1") === input;
+    if (repairedHasCjk && roundTrip) {
+      return repaired;
+    }
+    return null;
+  }
+  sanitizeDownloadFileName(input, fallback) {
+    return path.basename(input).replace(/[\u0000-\u001f<>:"|?*]/g, "_") || fallback;
+  }
   normalizeCheckoutStatus(data) {
     if (!data || typeof data !== "object") {
       return null;
@@ -4600,11 +4889,17 @@ class CloudService {
   /**
    * Retry an entire task (creates a new task)
    */
-  async retryTask(id) {
+  async retryTask(id, model) {
     try {
-      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/retry`, {
-        method: "POST"
-      });
+      const hasModelOverride = typeof model === "string" && model.length > 0;
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/retry`,
+        hasModelOverride ? {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model })
+        } : { method: "POST" }
+      );
       if (!res.ok) {
         const errorBody = await res.json().catch(() => null);
         return {
@@ -4628,11 +4923,16 @@ class CloudService {
   /**
    * Retry a single page
    */
-  async retryPage(taskId, pageNumber) {
+  async retryPage(taskId, pageNumber, model) {
     try {
+      const hasModelOverride = typeof model === "string" && model.length > 0;
       const res = await authManager.fetchWithAuth(
         `${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(taskId)}/pages/${encodeURIComponent(String(pageNumber))}/retry`,
-        { method: "POST" }
+        hasModelOverride ? {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model })
+        } : { method: "POST" }
       );
       if (!res.ok) {
         const errorBody = await res.json().catch(() => null);
@@ -4694,9 +4994,8 @@ class CloudService {
         };
       }
       const contentDisposition = res.headers.get("Content-Disposition") || "";
-      const match = contentDisposition.match(/filename="?([^";\n]+)"?/);
-      const rawName = match ? match[1] : `task-${id}.pdf`;
-      const fileName = path.basename(rawName).replace(/[\u0000-\u001f<>:"|?*]/g, "_") || `task-${id}.pdf`;
+      const fallbackName = `task-${id}.pdf`;
+      const fileName = this.extractDownloadFileName(contentDisposition, fallbackName);
       const buffer = await res.arrayBuffer();
       return { success: true, data: { buffer, fileName } };
     } catch (error) {
@@ -5314,9 +5613,10 @@ function registerCloudHandlers() {
       };
     }
   });
-  ipcMain.handle("cloud:retryTask", async (_, id) => {
+  ipcMain.handle("cloud:retryTask", async (_, params) => {
     try {
-      return await cloudService.retryTask(id);
+      const payload = typeof params === "string" ? { id: params } : params;
+      return await cloudService.retryTask(payload.id, payload.model);
     } catch (error) {
       console.error("[IPC] cloud:retryTask error:", error);
       return {
@@ -5338,7 +5638,7 @@ function registerCloudHandlers() {
   });
   ipcMain.handle("cloud:retryPage", async (_, params) => {
     try {
-      return await cloudService.retryPage(params.taskId, params.pageNumber);
+      return await cloudService.retryPage(params.taskId, params.pageNumber, params.model);
     } catch (error) {
       console.error("[IPC] cloud:retryPage error:", error);
       return {

package/dist/preload/index.js

@@ -25,6 +25,7 @@ electron.contextBridge.exposeInMainWorld("api", {
     getAll: (params) => electron.ipcRenderer.invoke("task:getAll", params),
     getById: (id) => electron.ipcRenderer.invoke("task:getById", id),
     update: (id, data) => electron.ipcRenderer.invoke("task:update", id, data),
+    retry: (params) => electron.ipcRenderer.invoke("task:retry", params),
     delete: (id) => electron.ipcRenderer.invoke("task:delete", id),
     hasRunningTasks: () => electron.ipcRenderer.invoke("task:hasRunningTasks")
   },
@@ -32,7 +33,7 @@ electron.contextBridge.exposeInMainWorld("api", {
   taskDetail: {
     getByPage: (taskId, page) => electron.ipcRenderer.invoke("taskDetail:getByPage", taskId, page),
     getAllByTask: (taskId) => electron.ipcRenderer.invoke("taskDetail:getAllByTask", taskId),
-    retry: (pageId) => electron.ipcRenderer.invoke("taskDetail:retry", pageId),
+    retry: (params) => electron.ipcRenderer.invoke("taskDetail:retry", params),
     retryFailed: (taskId) => electron.ipcRenderer.invoke("taskDetail:retryFailed", taskId)
   },
   // ==================== File APIs ====================
@@ -41,7 +42,8 @@ electron.contextBridge.exposeInMainWorld("api", {
     upload: (taskId, filePath) => electron.ipcRenderer.invoke("file:upload", taskId, filePath),
     uploadFileContent: (taskId, fileName, fileBuffer) => electron.ipcRenderer.invoke("file:uploadFileContent", taskId, fileName, fileBuffer),
     getImagePath: (taskId, page) => electron.ipcRenderer.invoke("file:getImagePath", taskId, page),
-    downloadMarkdown: (taskId) => electron.ipcRenderer.invoke("file:downloadMarkdown", taskId)
+    downloadMarkdown: (taskId) => electron.ipcRenderer.invoke("file:downloadMarkdown", taskId),
+    copyImageToClipboard: (imageSource) => electron.ipcRenderer.invoke("file:copyImageToClipboard", imageSource)
   },
   // ==================== Completion APIs ====================
   completion: {
@@ -62,7 +64,7 @@ electron.contextBridge.exposeInMainWorld("api", {
     getTaskById: (id) => electron.ipcRenderer.invoke("cloud:getTaskById", id),
     getTaskPages: (params) => electron.ipcRenderer.invoke("cloud:getTaskPages", params),
     cancelTask: (id) => electron.ipcRenderer.invoke("cloud:cancelTask", id),
-    retryTask: (id) => electron.ipcRenderer.invoke("cloud:retryTask", id),
+    retryTask: (params) => electron.ipcRenderer.invoke("cloud:retryTask", params),
     deleteTask: (id) => electron.ipcRenderer.invoke("cloud:deleteTask", id),
     retryPage: (params) => electron.ipcRenderer.invoke("cloud:retryPage", params),
     getTaskResult: (id) => electron.ipcRenderer.invoke("cloud:getTaskResult", id),