markpdfdown 0.3.1 → 0.4.1

package/dist/main/index.js

@@ -4358,10 +4358,58 @@ class AuthManager {
   }
 }
 const authManager = AuthManager.getInstance();
+const PAYMENT_STATUSES = /* @__PURE__ */ new Set(["pending", "completed", "failed", "refunded"]);
+const PAYMENT_PROVIDER_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "processing",
+  "completed",
+  "failed",
+  "canceled",
+  "expired",
+  "refunded",
+  "unknown"
+]);
 class CloudService {
   static instance;
   constructor() {
   }
+  normalizeCheckoutStatus(data) {
+    if (!data || typeof data !== "object") {
+      return null;
+    }
+    const sessionId = typeof data.session_id === "string" ? data.session_id.trim() : "";
+    const status = typeof data.status === "string" ? data.status : "";
+    const providerStatus = typeof data.provider_status === "string" ? data.provider_status : "";
+    const amountUsd = Number(data.amount_usd);
+    const creditsAdded = Number(data.credits_added);
+    const createdAt = typeof data.created_at === "string" ? data.created_at : "";
+    if (!sessionId || !PAYMENT_STATUSES.has(status)) {
+      return null;
+    }
+    if (!providerStatus || !PAYMENT_PROVIDER_STATUSES.has(providerStatus)) {
+      return null;
+    }
+    if (!Number.isFinite(amountUsd) || !Number.isFinite(creditsAdded)) {
+      return null;
+    }
+    if (typeof data.is_final !== "boolean" || typeof data.changed !== "boolean") {
+      return null;
+    }
+    if (!createdAt) {
+      return null;
+    }
+    return {
+      session_id: sessionId,
+      order_id: typeof data.order_id === "string" ? data.order_id : void 0,
+      status,
+      provider_status: providerStatus,
+      is_final: data.is_final,
+      changed: data.changed,
+      amount_usd: amountUsd,
+      credits_added: creditsAdded,
+      created_at: createdAt
+    };
+  }
   static getInstance() {
     if (!CloudService.instance) {
       CloudService.instance = new CloudService();
@@ -4688,6 +4736,116 @@ class CloudService {
       };
     }
   }
+  /**
+   * Create payment checkout session
+   */
+  async createCheckout(amountUsd) {
+    try {
+      if (!Number.isFinite(amountUsd) || amountUsd <= 0) {
+        return { success: false, error: "Invalid top-up amount" };
+      }
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/payment/checkout`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ amount_usd: amountUsd })
+      });
+      const responseJson = await res.json().catch(() => null);
+      if (!res.ok || !responseJson?.success) {
+        const serverMessage = responseJson?.error?.message;
+        const allowedAmounts = responseJson?.error?.details?.allowed_amounts_usd;
+        const allowedSuffix = Array.isArray(allowedAmounts) && allowedAmounts.length > 0 ? ` (allowed: ${allowedAmounts.join(", ")})` : "";
+        return {
+          success: false,
+          error: serverMessage ? `${serverMessage}${allowedSuffix}` : `Failed to create checkout session: ${res.status}`
+        };
+      }
+      if (!responseJson.data?.checkout_url || !responseJson.data?.session_id) {
+        return { success: false, error: "Invalid checkout response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] createCheckout error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Query checkout order status by session_id (supports long polling)
+   */
+  async getCheckoutStatus(sessionId, waitSeconds = 10) {
+    try {
+      const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+      if (!normalizedSessionId) {
+        return { success: false, error: "Invalid checkout session id" };
+      }
+      if (!Number.isFinite(waitSeconds)) {
+        return { success: false, error: "Invalid wait_seconds" };
+      }
+      const normalizedWaitSeconds = Math.min(30, Math.max(0, Math.floor(waitSeconds)));
+      const params = new URLSearchParams({
+        wait_seconds: String(normalizedWaitSeconds)
+      });
+      const requestTimeoutMs = Math.max((normalizedWaitSeconds + 20) * 1e3, 3e4);
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/payment/checkout/${encodeURIComponent(normalizedSessionId)}/status?${params.toString()}`,
+        {},
+        { timeoutMs: requestTimeoutMs }
+      );
+      const responseJson = await res.json().catch(() => null);
+      if (!res.ok || !responseJson?.success) {
+        return {
+          success: false,
+          error: responseJson?.error?.message || `Failed to query checkout status: ${res.status}`
+        };
+      }
+      const data = this.normalizeCheckoutStatus(responseJson.data);
+      if (!data) {
+        return { success: false, error: "Invalid checkout status response" };
+      }
+      return { success: true, data };
+    } catch (error) {
+      console.error("[CloudService] getCheckoutStatus error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Trigger proactive reconciliation for a checkout session
+   */
+  async reconcileCheckout(sessionId) {
+    try {
+      const normalizedSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
+      if (!normalizedSessionId) {
+        return { success: false, error: "Invalid checkout session id" };
+      }
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/payment/checkout/${encodeURIComponent(normalizedSessionId)}/reconcile`,
+        { method: "POST" }
+      );
+      const responseJson = await res.json().catch(() => null);
+      if (!res.ok || !responseJson?.success) {
+        return {
+          success: false,
+          error: responseJson?.error?.message || `Failed to reconcile checkout: ${res.status}`
+        };
+      }
+      const data = this.normalizeCheckoutStatus(responseJson.data);
+      if (!data) {
+        return { success: false, error: "Invalid checkout reconcile response" };
+      }
+      return { success: true, data };
+    } catch (error) {
+      console.error("[CloudService] reconcileCheckout error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   /**
    * Get credits info from the cloud API
    */
@@ -4753,6 +4911,42 @@ class CloudService {
       };
     }
   }
+  /**
+   * Get payment history from the cloud API
+   */
+  async getPaymentHistory(page = 1, pageSize = 20) {
+    try {
+      const params = new URLSearchParams({
+        page: String(page),
+        page_size: String(pageSize)
+      });
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/payment/history?${params.toString()}`
+      );
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch payment history: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success) {
+        return { success: false, error: responseJson.error?.message || "Invalid payment history response" };
+      }
+      return {
+        success: true,
+        data: responseJson.data,
+        pagination: responseJson.pagination
+      };
+    } catch (error) {
+      console.error("[CloudService] getPaymentHistory error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   /**
    * Delete a cloud task (only terminal states can be deleted)
    * Terminal states: FAILED=0, COMPLETED=6, CANCELLED=7, PARTIAL_FAILED=8
@@ -5200,6 +5394,54 @@ function registerCloudHandlers() {
       };
     }
   });
+  ipcMain.handle("cloud:createCheckout", async (_, params) => {
+    try {
+      if (!params || typeof params.amountUsd !== "number" || !Number.isFinite(params.amountUsd) || params.amountUsd <= 0) {
+        return { success: false, error: "Invalid amountUsd" };
+      }
+      return await cloudService.createCheckout(params.amountUsd);
+    } catch (error) {
+      console.error("[IPC] cloud:createCheckout error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getCheckoutStatus", async (_, params) => {
+    try {
+      const sessionId = typeof params?.sessionId === "string" ? params.sessionId.trim() : "";
+      if (!sessionId) {
+        return { success: false, error: "Invalid sessionId" };
+      }
+      const waitSeconds = params?.waitSeconds ?? 10;
+      if (typeof waitSeconds !== "number" || !Number.isFinite(waitSeconds)) {
+        return { success: false, error: "Invalid waitSeconds" };
+      }
+      return await cloudService.getCheckoutStatus(sessionId, waitSeconds);
+    } catch (error) {
+      console.error("[IPC] cloud:getCheckoutStatus error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:reconcileCheckout", async (_, params) => {
+    try {
+      const sessionId = typeof params?.sessionId === "string" ? params.sessionId.trim() : "";
+      if (!sessionId) {
+        return { success: false, error: "Invalid sessionId" };
+      }
+      return await cloudService.reconcileCheckout(sessionId);
+    } catch (error) {
+      console.error("[IPC] cloud:reconcileCheckout error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
   ipcMain.handle("cloud:getCredits", async () => {
     try {
       return await cloudService.getCredits();
@@ -5222,6 +5464,23 @@ function registerCloudHandlers() {
       };
     }
   });
+  ipcMain.handle("cloud:getPaymentHistory", async (_, params) => {
+    try {
+      if (!params || typeof params.page !== "number" || !Number.isFinite(params.page) || params.page < 1) {
+        return { success: false, error: "Invalid page" };
+      }
+      if (!params || typeof params.pageSize !== "number" || !Number.isFinite(params.pageSize) || params.pageSize < 1) {
+        return { success: false, error: "Invalid pageSize" };
+      }
+      return await cloudService.getPaymentHistory(params.page, params.pageSize);
+    } catch (error) {
+      console.error("[IPC] cloud:getPaymentHistory error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
   ipcMain.handle("cloud:sseConnect", async () => {
     try {
       await cloudSSEManager.connect();
@@ -5494,6 +5753,29 @@ function getIconPath() {
   return possiblePaths[0];
 }
 const PROTOCOL_NAME = "markpdfdown";
+const PAYMENT_CALLBACK_EVENT = "payment:callback";
+let pendingPaymentCallback = null;
+function toNullableNumber(value) {
+  if (value === null || value.trim() === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function dispatchPaymentCallback(payload) {
+  if (!mainWindow) {
+    pendingPaymentCallback = payload;
+    return;
+  }
+  const sendPayload = () => {
+    mainWindow?.webContents.send(PAYMENT_CALLBACK_EVENT, payload);
+  };
+  if (mainWindow.webContents.isLoadingMainFrame()) {
+    mainWindow.webContents.once("did-finish-load", sendPayload);
+    return;
+  }
+  sendPayload();
+}
 protocol.registerSchemesAsPrivileged([
   {
     scheme: "local-file",
@@ -5518,15 +5800,18 @@ function handleProtocolUrl(url) {
     console.warn("[Main] Ignoring URL with unexpected scheme");
     return;
   }
+  let parsed;
+  let host;
+  let pathname;
   try {
-    const parsed = new URL(url);
-    const host = parsed.host.toLowerCase();
-    const pathname = parsed.pathname.replace(/\/+/g, "/").replace(/\/+$/, "");
+    parsed = new URL(url);
+    host = parsed.host.toLowerCase();
+    pathname = parsed.pathname.replace(/\/+/g, "/").replace(/\/+$/, "");
     if (parsed.host.includes("%")) {
       console.warn("[Main] Ignoring protocol URL with encoded host");
       return;
     }
-    const isAllowed = host === "auth" && pathname === "/callback" || host === "auth" && pathname === "";
+    const isAllowed = host === "auth" && pathname === "/callback" || host === "auth" && pathname === "" || host === "payment" && pathname === "/callback";
     if (!isAllowed) {
       console.warn(`[Main] Ignoring protocol URL with unexpected path: ${host}${pathname}`);
       return;
@@ -5541,7 +5826,23 @@ function handleProtocolUrl(url) {
     }
     mainWindow.focus();
   }
-  authManager.checkDeviceTokenStatus();
+  if (host === "auth") {
+    authManager.checkDeviceTokenStatus();
+    return;
+  }
+  if (host === "payment" && pathname === "/callback") {
+    const payload = {
+      url,
+      status: parsed.searchParams.get("status"),
+      sessionId: parsed.searchParams.get("session_id"),
+      amountUsd: toNullableNumber(parsed.searchParams.get("amount_usd")),
+      creditsToAdd: toNullableNumber(parsed.searchParams.get("credits_to_add")),
+      query: Object.fromEntries(parsed.searchParams.entries()),
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    console.log("[Main] Payment callback received:", payload.status || "unknown");
+    dispatchPaymentCallback(payload);
+  }
 }
 app.on("open-url", (event, url) => {
   event.preventDefault();
@@ -5688,6 +5989,10 @@ function createWindow() {
     mainWindow = null;
     windowManager.setMainWindow(null);
   });
+  if (pendingPaymentCallback) {
+    dispatchPaymentCallback(pendingPaymentCallback);
+    pendingPaymentCallback = null;
+  }
 }
 app.whenReady().then(async () => {
   try {

package/dist/preload/index.js

@@ -68,8 +68,12 @@ electron.contextBridge.exposeInMainWorld("api", {
     getTaskResult: (id) => electron.ipcRenderer.invoke("cloud:getTaskResult", id),
     downloadPdf: (id) => electron.ipcRenderer.invoke("cloud:downloadPdf", id),
     getPageImage: (params) => electron.ipcRenderer.invoke("cloud:getPageImage", params),
+    createCheckout: (params) => electron.ipcRenderer.invoke("cloud:createCheckout", params),
+    getCheckoutStatus: (params) => electron.ipcRenderer.invoke("cloud:getCheckoutStatus", params),
+    reconcileCheckout: (params) => electron.ipcRenderer.invoke("cloud:reconcileCheckout", params),
     getCredits: () => electron.ipcRenderer.invoke("cloud:getCredits"),
     getCreditHistory: (params) => electron.ipcRenderer.invoke("cloud:getCreditHistory", params),
+    getPaymentHistory: (params) => electron.ipcRenderer.invoke("cloud:getPaymentHistory", params),
     sseConnect: () => electron.ipcRenderer.invoke("cloud:sseConnect"),
     sseDisconnect: () => electron.ipcRenderer.invoke("cloud:sseDisconnect"),
     sseResetAndDisconnect: () => electron.ipcRenderer.invoke("cloud:sseResetAndDisconnect")
@@ -150,6 +154,18 @@ electron.contextBridge.exposeInMainWorld("api", {
       return () => {
         electron.ipcRenderer.removeListener("cloud:taskEvent", handler);
       };
+    },
+    /**
+     * 监听支付回跳事件
+     * @param callback 事件回调函数
+     * @returns 清理函数
+     */
+    onPaymentCallback: (callback) => {
+      const handler = (_event, data) => callback(data);
+      electron.ipcRenderer.on("payment:callback", handler);
+      return () => {
+        electron.ipcRenderer.removeListener("payment:callback", handler);
+      };
     }
   },
   // ==================== Platform APIs ====================