markpdfdown 0.4.2 → 0.4.3

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";
@@ -2635,6 +2635,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"
@@ -3444,6 +3445,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 +3521,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 +4407,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;
@@ -4694,9 +4810,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) {

package/dist/preload/index.js

@@ -41,7 +41,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: {