markpdfdown 0.2.2 → 0.3.1

package/dist/main/index.js

@@ -1,4 +1,4 @@
-import { app, ipcMain, dialog, protocol, nativeImage, BrowserWindow, shell } from "electron";
+import { app, ipcMain, dialog, shell, safeStorage, protocol, nativeImage, BrowserWindow } from "electron";
 import path from "path";
 import fs, { promises } from "fs";
 import isDev from "electron-is-dev";
@@ -1318,23 +1318,23 @@ class LLMClientFactory {
   static async createClient(type, apiKey, baseUrl) {
     switch (type) {
       case "openai": {
-        const OpenAIModule = await import("./OpenAIClient-gyy2nFkw.js");
+        const OpenAIModule = await import("./OpenAIClient-DsHXIb_l.js");
         return new OpenAIModule.OpenAIClient(apiKey, baseUrl || "");
       }
       case "openai-responses": {
-        const OpenAIResponsesModule = await import("./OpenAIResponsesClient-DETYz2nL.js");
+        const OpenAIResponsesModule = await import("./OpenAIResponsesClient-DgM49Ri3.js");
         return new OpenAIResponsesModule.OpenAIResponsesClient(apiKey, baseUrl || "");
       }
       case "gemini": {
-        const GeminiModule = await import("./GeminiClient-CrtYbwaF.js");
+        const GeminiModule = await import("./GeminiClient-DBJawhLe.js");
         return new GeminiModule.GeminiClient(apiKey, baseUrl || "");
       }
       case "anthropic": {
-        const AnthropicModule = await import("./AnthropicClient-CTbHYiqm.js");
+        const AnthropicModule = await import("./AnthropicClient-Dm_xth4j.js");
         return new AnthropicModule.AnthropicClient(apiKey, baseUrl || "");
       }
       case "ollama": {
-        const OllamaModule = await import("./OllamaClient-DKJsnvIt.js");
+        const OllamaModule = await import("./OllamaClient-CJY8PExo.js");
         return new OllamaModule.OllamaClient(apiKey, baseUrl || "");
       }
       default:
@@ -3506,19 +3506,27 @@ function registerFileHandlers() {
       }
     }
   );
-  ipcMain.handle(IPC_CHANNELS.FILE.SELECT_DIALOG, async () => {
+  ipcMain.handle(IPC_CHANNELS.FILE.SELECT_DIALOG, async (_, allowOffice) => {
     try {
+      const pdfAndImageExtensions = ["pdf", "jpg", "jpeg", "png", "bmp", "gif"];
+      const officeExtensions = ["doc", "docx", "xls", "xlsx", "ppt", "pptx"];
+      const filters = allowOffice ? [
+        {
+          name: "Supported Files",
+          extensions: [...pdfAndImageExtensions, ...officeExtensions]
+        },
+        { name: "PDF and Images", extensions: pdfAndImageExtensions },
+        { name: "Office Documents", extensions: officeExtensions },
+        { name: "All Files", extensions: ["*"] }
+      ] : [
+        { name: "PDF and Images", extensions: pdfAndImageExtensions },
+        { name: "PDF Documents", extensions: ["pdf"] },
+        { name: "Images", extensions: ["jpg", "jpeg", "png", "bmp", "gif"] },
+        { name: "All Files", extensions: ["*"] }
+      ];
       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: ["*"] }
-        ]
+        filters
       });
       return {
         success: true,
@@ -3723,6 +3731,7 @@ function registerAppHandlers() {
     return getAppVersion();
   });
 }
+const API_BASE_URL = process.env.API_BASE_URL || "https://markdown.fit";
 class WindowManager {
   static instance;
   mainWindow = null;
@@ -3757,186 +3766,1734 @@ class WindowManager {
   }
 }
 const windowManager = WindowManager.getInstance();
-const { autoUpdater } = pkg$1;
-class UpdateService {
+const REFRESH_TOKEN_DIR = "auth";
+const REFRESH_TOKEN_FILE = "refresh_token.enc";
+const TOKEN_REFRESH_MARGIN_MS = 60 * 1e3;
+const DEVICE_POLL_INTERVAL_MS = 5e3;
+const INIT_RETRY_DELAY_MS = 30 * 1e3;
+const MAX_AUTO_REFRESH_RETRIES = 3;
+class AuthTokenInvalidError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthTokenInvalidError";
+  }
+}
+function buildUserAgent() {
+  const appVersion = app.getVersion();
+  const electronVersion = process.versions.electron;
+  const chromeVersion = process.versions.chrome;
+  const nodeVersion = process.versions.node;
+  const platform = `${process.platform}; ${process.arch}`;
+  return `MarkPDFdown/${appVersion} Electron/${electronVersion} Chrome/${chromeVersion} Node/${nodeVersion} (${platform})`;
+}
+class AuthManager {
   static instance;
-  initialized = false;
-  isChecking = false;
+  accessToken = null;
+  accessTokenExpiresAt = 0;
+  refreshToken = null;
+  userProfile = null;
+  deviceFlowStatus = "idle";
+  userCode = null;
+  verificationUrl = null;
+  error = null;
+  isLoading = false;
+  pollTimer = null;
+  refreshTimer = null;
+  initRetryTimer = null;
+  autoRefreshRetryCount = 0;
+  deviceCode = null;
+  pollExpiresAt = 0;
+  userAgent = "";
+  refreshInFlight = null;
   constructor() {
   }
   static getInstance() {
-    if (!UpdateService.instance) {
-      UpdateService.instance = new UpdateService();
+    if (!AuthManager.instance) {
+      AuthManager.instance = new AuthManager();
     }
-    return UpdateService.instance;
-  }
-  ensureInitialized() {
-    if (this.initialized) return;
-    if (!app.isPackaged) return;
-    this.initialized = true;
-    autoUpdater.autoDownload = true;
-    autoUpdater.allowPrerelease = false;
-    autoUpdater.autoInstallOnAppQuit = true;
-    this.registerListeners();
-  }
-  registerListeners() {
-    autoUpdater.on("checking-for-update", () => {
-      console.log("[UpdateService] Checking for updates...");
-      this.sendStatus({ status: UpdateStatus.CHECKING });
-    });
-    autoUpdater.on("update-available", (info) => {
-      console.log("[UpdateService] Update available:", info.version);
-      this.sendStatus({ status: UpdateStatus.AVAILABLE, version: info.version });
-    });
-    autoUpdater.on("update-not-available", (info) => {
-      console.log("[UpdateService] No update available. Current version:", info.version);
-      this.sendStatus({ status: UpdateStatus.NOT_AVAILABLE, version: info.version });
-    });
-    autoUpdater.on("download-progress", (progress) => {
-      console.log(`[UpdateService] Download progress: ${progress.percent.toFixed(1)}%`);
-      this.sendStatus({ status: UpdateStatus.DOWNLOADING, progress: progress.percent });
-    });
-    autoUpdater.on("update-downloaded", (info) => {
-      console.log("[UpdateService] Update downloaded:", info.version);
-      this.sendStatus({ status: UpdateStatus.DOWNLOADED, version: info.version });
-    });
-    autoUpdater.on("error", (error) => {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const safeMessage = errorMessage.length > 200 ? `${errorMessage.slice(0, 200)}...` : errorMessage;
-      const errorDetails = {
-        message: safeMessage,
-        name: error instanceof Error ? error.name : void 0,
-        stack: error instanceof Error ? error.stack : void 0,
-        code: error.code,
-        statusCode: error.statusCode
-      };
-      console.error("[UpdateService] Error:", errorDetails);
-      this.sendStatus({ status: UpdateStatus.ERROR, error: safeMessage });
-    });
+    return AuthManager.instance;
   }
-  sendStatus(data) {
-    windowManager.sendToRenderer(IPC_CHANNELS.EVENTS.UPDATER_STATUS, data);
+  /**
+   * Initialize on app startup: restore session from persisted refresh token
+   */
+  async initialize() {
+    console.log("[AuthManager] Initializing...");
+    this.userAgent = buildUserAgent();
+    console.log(`[AuthManager] User-Agent: ${this.userAgent}`);
+    this.isLoading = true;
+    this.broadcastState();
+    try {
+      const storedRefreshToken = this.loadRefreshToken();
+      if (!storedRefreshToken) {
+        console.log("[AuthManager] No stored refresh token, starting fresh");
+        this.isLoading = false;
+        this.broadcastState();
+        return;
+      }
+      this.refreshToken = storedRefreshToken;
+      await this.refreshAccessToken();
+      await this.fetchUserProfile();
+      console.log("[AuthManager] Session restored successfully");
+    } catch (err) {
+      console.warn("[AuthManager] Failed to restore session:", err);
+      if (err instanceof AuthTokenInvalidError) {
+        this.clearTokens();
+      } else {
+        this.accessToken = null;
+        this.accessTokenExpiresAt = 0;
+        this.userProfile = null;
+        this.scheduleInitRetry();
+      }
+    }
+    this.isLoading = false;
+    this.broadcastState();
   }
-  async checkForUpdates() {
-    this.ensureInitialized();
-    if (!this.initialized) return;
-    if (this.isChecking) return;
-    this.isChecking = true;
+  /**
+   * Start the device authorization login flow
+   */
+  async startDeviceLogin() {
+    if (this.deviceFlowStatus === "polling" || this.deviceFlowStatus === "pending_browser") {
+      return { success: false, error: "Login already in progress" };
+    }
+    this.error = null;
+    this.deviceFlowStatus = "pending_browser";
+    this.broadcastState();
     try {
-      await autoUpdater.checkForUpdates();
-    } finally {
-      this.isChecking = false;
+      const res = await fetch(`${API_BASE_URL}/api/v1/auth/device/code`, {
+        method: "POST",
+        headers: this.getDefaultHeaders({ "Content-Type": "application/json" })
+      });
+      if (!res.ok) {
+        throw new Error(`Device code request failed: ${res.status}`);
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        throw new Error(`Device code request failed: invalid response`);
+      }
+      const data = responseJson.data;
+      this.deviceCode = data.device_code;
+      this.userCode = data.user_code;
+      this.verificationUrl = data.verification_url;
+      this.pollExpiresAt = Date.now() + data.expires_in * 1e3;
+      try {
+        await shell.openExternal(data.verification_url);
+      } catch (browserErr) {
+        console.error("[AuthManager] Failed to open browser:", browserErr);
+        this.deviceFlowStatus = "error";
+        this.error = "Failed to open browser for authorization";
+        this.broadcastState();
+        return { success: false, error: this.error };
+      }
+      this.deviceFlowStatus = "polling";
+      this.broadcastState();
+      this.startPolling(data.interval || DEVICE_POLL_INTERVAL_MS / 1e3);
+      return { success: true };
+    } catch (err) {
+      console.error("[AuthManager] Device login failed:", err);
+      this.deviceFlowStatus = "error";
+      this.error = err instanceof Error ? err.message : String(err);
+      this.broadcastState();
+      return { success: false, error: this.error };
     }
   }
-  quitAndInstall() {
-    this.ensureInitialized();
-    autoUpdater.quitAndInstall();
+  /**
+   * Cancel an in-progress login flow
+   */
+  cancelLogin() {
+    this.stopPolling();
+    this.deviceCode = null;
+    this.userCode = null;
+    this.verificationUrl = null;
+    this.deviceFlowStatus = "idle";
+    this.error = null;
+    this.broadcastState();
   }
-}
-const updateService = UpdateService.getInstance();
-function registerUpdaterHandlers() {
-  ipcMain.handle(IPC_CHANNELS.UPDATER.CHECK_FOR_UPDATES, async () => {
-    if (!app.isPackaged) {
-      console.log("[Updater] Skipping update check in development mode");
-      windowManager.sendToRenderer(IPC_CHANNELS.EVENTS.UPDATER_STATUS, {
-        status: UpdateStatus.NOT_AVAILABLE
-      });
+  /**
+   * Check device token status immediately (for OAuth callback)
+   * Call this when receiving protocol URL callback to speed up token acquisition
+   */
+  async checkDeviceTokenStatus() {
+    if (!this.deviceCode || this.deviceFlowStatus !== "polling") {
       return;
     }
-    await updateService.checkForUpdates();
-  });
-  ipcMain.handle(IPC_CHANNELS.UPDATER.QUIT_AND_INSTALL, () => {
-    updateService.quitAndInstall();
-  });
-}
-function registerAllHandlers() {
-  registerProviderHandlers();
-  registerModelHandlers();
-  registerTaskHandlers();
-  registerTaskDetailHandlers();
-  registerFileHandlers();
-  registerCompletionHandlers();
-  registerAppHandlers();
-  registerUpdaterHandlers();
-  console.log("[IPC] All handlers registered successfully");
-}
-function registerIpcHandlers() {
-  registerAllHandlers();
-}
-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");
+    console.log("[AuthManager] Checking device token status immediately...");
+    try {
+      const res = await fetch(
+        `${API_BASE_URL}/api/v1/auth/device/token?device_code=${encodeURIComponent(this.deviceCode)}`,
+        { headers: this.getDefaultHeaders() }
+      );
+      if (res.status === 200) {
+        const responseJson = await res.json();
+        if (!responseJson.success || !responseJson.data) {
+          throw new Error("Token check failed: invalid response");
+        }
+        this.handleTokenResponse(responseJson.data);
+        this.stopPolling();
+        this.deviceFlowStatus = "idle";
+        this.userCode = null;
+        this.verificationUrl = null;
+        this.deviceCode = null;
+        await this.fetchUserProfile();
+        this.broadcastState();
+        console.log("[AuthManager] Token obtained via immediate check");
+        return;
+      }
+      if (res.status === 428) {
+        console.log("[AuthManager] Still waiting, polling will continue...");
+        return;
+      }
+      const body = await res.text();
+      console.warn("[AuthManager] Token check error:", res.status, body);
+    } catch (err) {
+      console.warn("[AuthManager] Token check failed:", err);
+    }
   }
-  handleTaskEvent(data) {
-    const { type, taskId, task, timestamp } = data;
-    windowManager.sendToRenderer("task:event", {
-      type,
-      taskId,
-      task,
-      timestamp
-    });
+  /**
+   * Log out: call API, clear local tokens
+   */
+  async logout() {
+    if (this.accessToken) {
+      try {
+        await this.fetchWithAuth(`${API_BASE_URL}/api/v1/auth/logout`, { method: "POST" });
+      } catch (err) {
+        console.warn("[AuthManager] Logout API call failed:", err);
+      }
+    }
+    this.clearTokens();
+    this.broadcastState();
   }
-  handleTaskDetailEvent(data) {
-    const { type, taskId, pageId, page, status, timestamp } = data;
-    windowManager.sendToRenderer("taskDetail:event", {
-      type,
-      taskId,
-      pageId,
-      page,
-      status,
-      timestamp
-    });
+  /**
+   * Get a valid access token, refreshing if needed
+   */
+  async getAccessToken() {
+    if (!this.refreshToken) {
+      return null;
+    }
+    if (this.accessToken && Date.now() < this.accessTokenExpiresAt - TOKEN_REFRESH_MARGIN_MS) {
+      return this.accessToken;
+    }
+    try {
+      await this.refreshAccessToken();
+      return this.accessToken;
+    } catch (err) {
+      if (err instanceof AuthTokenInvalidError) {
+        this.clearTokens();
+        this.broadcastState();
+      }
+      return null;
+    }
   }
-  cleanup() {
-    eventBus.removeAllListeners();
-    this.isInitialized = false;
+  /**
+   * Get current auth state snapshot
+   */
+  getAuthState() {
+    return {
+      isAuthenticated: !!this.accessToken && !!this.userProfile,
+      isLoading: this.isLoading,
+      user: this.userProfile,
+      deviceFlowStatus: this.deviceFlowStatus,
+      userCode: this.userCode,
+      verificationUrl: this.verificationUrl,
+      error: this.error
+    };
   }
-}
-const eventBridge = new EventBridge();
-if (!app.isPackaged) {
-  app.setName("MarkPDFdown");
-  const userDataPath = app.getPath("userData");
-  if (userDataPath.endsWith("Electron")) {
-    const newPath = userDataPath.replace(/Electron$/, "MarkPDFdown");
-    app.setPath("userData", newPath);
+  /**
+   * Get cached user profile
+   */
+  getUserProfile() {
+    return this.userProfile;
   }
-}
-function getIconPath() {
-  let iconName;
-  if (app.isPackaged) {
-    iconName = process.platform === "darwin" ? "icons/mac/icon.icns" : process.platform === "win32" ? "icons/win/icon.ico" : "icons/png/512x512.png";
-  } else {
-    iconName = process.platform === "darwin" ? "icons/mac/png/512x512.png" : "icons/png/512x512.png";
+  /**
+   * Make an authenticated API request. Automatically retries once on 401 by refreshing the token.
+   * @param url - Request URL
+   * @param options - Fetch RequestInit options
+   * @param meta - Additional options: timeoutMs (0 = no timeout, default auto-detected from body type)
+   */
+  async fetchWithAuth(url, options = {}, meta) {
+    const token = await this.getAccessToken();
+    if (!token) {
+      throw new Error("Authentication required");
+    }
+    const isFormData = options.body instanceof FormData;
+    const timeoutMs = meta?.timeoutMs !== void 0 ? meta.timeoutMs : isFormData ? 120 * 1e3 : 8e3;
+    const callerSignal = options.signal;
+    const buildSignal = () => {
+      const signals = [];
+      let tid = null;
+      if (callerSignal) signals.push(callerSignal);
+      if (timeoutMs > 0) {
+        const tc = new AbortController();
+        tid = setTimeout(() => tc.abort(), timeoutMs);
+        signals.push(tc.signal);
+      }
+      if (signals.length === 0) return { signal: void 0, timeoutId: null };
+      if (signals.length === 1) return { signal: signals[0], timeoutId: tid };
+      if (typeof AbortSignal.any === "function") {
+        return { signal: AbortSignal.any(signals), timeoutId: tid };
+      }
+      const fc = new AbortController();
+      for (const s of signals) {
+        if (s.aborted) {
+          fc.abort(s.reason);
+          break;
+        }
+        s.addEventListener("abort", () => fc.abort(s.reason), { once: true });
+      }
+      return { signal: fc.signal, timeoutId: tid };
+    };
+    const { signal, timeoutId } = buildSignal();
+    try {
+      const res = await fetch(url, {
+        ...options,
+        signal,
+        headers: {
+          ...this.getDefaultHeaders(),
+          Authorization: `Bearer ${token}`,
+          ...options.headers
+        }
+      });
+      if (res.status !== 401) {
+        return res;
+      }
+      if (!this.refreshToken) {
+        this.clearTokens();
+        this.broadcastState();
+        throw new Error("Authentication required");
+      }
+      try {
+        await this.refreshAccessToken();
+      } catch (err) {
+        if (err instanceof AuthTokenInvalidError) {
+          this.clearTokens();
+          this.broadcastState();
+        }
+        throw new Error("Authentication required");
+      }
+      const { signal: retrySignal, timeoutId: retryTimeoutId } = buildSignal();
+      try {
+        return await fetch(url, {
+          ...options,
+          signal: retrySignal,
+          headers: {
+            ...this.getDefaultHeaders(),
+            Authorization: `Bearer ${this.accessToken}`,
+            ...options.headers
+          }
+        });
+      } finally {
+        if (retryTimeoutId) clearTimeout(retryTimeoutId);
+      }
+    } catch (error) {
+      if (error?.name === "AbortError" && callerSignal?.aborted) {
+        throw error;
+      }
+      if (error?.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      throw error;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
   }
-  if (process.env.ELECTRON_RENDERER_URL) {
-    return path.join(process.cwd(), "public", iconName);
+  // ─── Private Methods ─────────────────────────────────────────────
+  getDefaultHeaders(extra = {}) {
+    return {
+      "User-Agent": this.userAgent,
+      ...extra
+    };
   }
-  if (app.isPackaged) {
-    return path.join(process.resourcesPath, iconName);
+  startPolling(intervalSeconds) {
+    const intervalMs = Math.max(intervalSeconds * 1e3, DEVICE_POLL_INTERVAL_MS);
+    const poll = async () => {
+      if (Date.now() > this.pollExpiresAt) {
+        this.deviceFlowStatus = "expired";
+        this.error = "Device code expired";
+        this.stopPolling();
+        this.broadcastState();
+        return;
+      }
+      try {
+        const res = await fetch(
+          `${API_BASE_URL}/api/v1/auth/device/token?device_code=${encodeURIComponent(this.deviceCode)}`,
+          { headers: this.getDefaultHeaders() }
+        );
+        if (res.status === 200) {
+          const responseJson = await res.json();
+          if (!responseJson.success || !responseJson.data) {
+            throw new Error("Token polling failed: invalid response");
+          }
+          this.handleTokenResponse(responseJson.data);
+          this.stopPolling();
+          this.deviceFlowStatus = "idle";
+          this.userCode = null;
+          this.verificationUrl = null;
+          this.deviceCode = null;
+          await this.fetchUserProfile();
+          this.broadcastState();
+          return;
+        }
+        if (res.status === 428) {
+          this.pollTimer = setTimeout(poll, intervalMs);
+          return;
+        }
+        const body = await res.text();
+        throw new Error(`Token polling failed: ${res.status} ${body}`);
+      } catch (err) {
+        if (this.deviceFlowStatus === "polling") {
+          console.warn("[AuthManager] Poll error, retrying:", err);
+          this.pollTimer = setTimeout(poll, intervalMs);
+        }
+      }
+    };
+    this.pollTimer = setTimeout(poll, intervalMs);
   }
-  const appPath = app.getAppPath();
-  const possiblePaths = [
-    path.join(appPath, "..", "..", "public", iconName),
-    // dist/main -> 根目录
-    path.join(appPath, "..", "public", iconName),
-    // dist -> 根目录
-    path.join(appPath, "public", iconName),
-    // 当前目录
-    path.join(process.cwd(), "public", iconName)
-    // 工作目录
-  ];
-  for (const iconPath of possiblePaths) {
-    if (fs.existsSync(iconPath)) {
-      return iconPath;
+  stopPolling() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  handleTokenResponse(data) {
+    this.accessToken = data.access_token;
+    this.accessTokenExpiresAt = Date.now() + data.expires_in * 1e3;
+    if (data.refresh_token) {
+      this.refreshToken = data.refresh_token;
+      this.persistRefreshToken(data.refresh_token);
+    } else {
+      console.warn("[AuthManager] No refresh_token in response, skipping persistence");
+    }
+    this.scheduleTokenRefresh(data.expires_in);
+  }
+  scheduleTokenRefresh(expiresInSeconds) {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+    if (!this.refreshToken) {
+      console.log("[AuthManager] No refresh token, skipping auto-refresh schedule");
+      return;
+    }
+    const refreshInMs = Math.max(expiresInSeconds * 1e3 - TOKEN_REFRESH_MARGIN_MS, 0);
+    this.refreshTimer = setTimeout(async () => {
+      try {
+        await this.refreshAccessToken();
+      } catch (err) {
+        console.error("[AuthManager] Auto-refresh failed:", err);
+        if (err instanceof AuthTokenInvalidError) {
+          this.clearTokens();
+          this.broadcastState();
+        } else {
+          this.autoRefreshRetryCount++;
+          if (this.autoRefreshRetryCount <= MAX_AUTO_REFRESH_RETRIES) {
+            const retryDelayMs = Math.min(3e4 * Math.pow(2, this.autoRefreshRetryCount - 1), 5 * 60 * 1e3);
+            console.log(`[AuthManager] Scheduling auto-refresh retry ${this.autoRefreshRetryCount}/${MAX_AUTO_REFRESH_RETRIES} in ${retryDelayMs / 1e3}s`);
+            this.refreshTimer = setTimeout(async () => {
+              try {
+                await this.refreshAccessToken();
+              } catch (retryErr) {
+                console.error("[AuthManager] Auto-refresh retry failed:", retryErr);
+                if (retryErr instanceof AuthTokenInvalidError) {
+                  this.clearTokens();
+                  this.broadcastState();
+                } else if (this.autoRefreshRetryCount < MAX_AUTO_REFRESH_RETRIES) {
+                  this.scheduleTokenRefresh(retryDelayMs / 1e3);
+                } else {
+                  console.error("[AuthManager] Max auto-refresh retries reached, keeping refresh token for next manual attempt");
+                }
+              }
+            }, retryDelayMs);
+          } else {
+            console.error("[AuthManager] Max auto-refresh retries reached, keeping refresh token for next manual attempt");
+          }
+        }
+      }
+    }, refreshInMs);
+  }
+  async refreshAccessToken() {
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
+    }
+    this.refreshInFlight = this.doRefreshAccessToken();
+    try {
+      await this.refreshInFlight;
+    } finally {
+      this.refreshInFlight = null;
+    }
+  }
+  async doRefreshAccessToken() {
+    if (!this.refreshToken) {
+      throw new AuthTokenInvalidError("No refresh token available");
+    }
+    let res;
+    try {
+      res = await fetch(`${API_BASE_URL}/api/v1/auth/token/refresh`, {
+        method: "POST",
+        headers: this.getDefaultHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ refresh_token: this.refreshToken })
+      });
+    } catch (err) {
+      throw new Error(`Token refresh network error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!res.ok) {
+      if (res.status === 401 || res.status === 403) {
+        throw new AuthTokenInvalidError(`Token refresh rejected: ${res.status}`);
+      }
+      throw new Error(`Token refresh server error: ${res.status}`);
+    }
+    const responseJson = await res.json();
+    if (!responseJson.success || !responseJson.data) {
+      throw new Error("Token refresh failed: invalid response");
+    }
+    this.handleTokenResponse(responseJson.data);
+    this.autoRefreshRetryCount = 0;
+  }
+  async fetchUserProfile() {
+    if (!this.accessToken) return;
+    const res = await this.fetchWithAuth(`${API_BASE_URL}/api/v1/user/profile`);
+    if (!res.ok) {
+      throw new Error(`Fetch user profile failed: ${res.status}`);
+    }
+    const responseJson = await res.json();
+    if (!responseJson.success || !responseJson.data) {
+      throw new Error("Fetch user profile failed: invalid response");
+    }
+    this.userProfile = responseJson.data;
+  }
+  persistRefreshToken(token) {
+    try {
+      if (!safeStorage.isEncryptionAvailable()) {
+        console.warn("[AuthManager] Encryption not available, refresh token will only be kept in memory (not persisted to disk)");
+        return;
+      }
+      const dir = path.join(app.getPath("userData"), REFRESH_TOKEN_DIR);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      const filePath = path.join(dir, REFRESH_TOKEN_FILE);
+      const encrypted = safeStorage.encryptString(token);
+      fs.writeFileSync(filePath, encrypted);
+    } catch (err) {
+      console.warn("[AuthManager] Failed to persist refresh token:", err);
+    }
+  }
+  loadRefreshToken() {
+    try {
+      if (!safeStorage.isEncryptionAvailable()) {
+        console.warn("[AuthManager] Encryption not available, cannot load persisted refresh token");
+        return null;
+      }
+      const filePath = path.join(app.getPath("userData"), REFRESH_TOKEN_DIR, REFRESH_TOKEN_FILE);
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+      const data = fs.readFileSync(filePath);
+      return safeStorage.decryptString(data);
+    } catch (err) {
+      console.warn("[AuthManager] Failed to load refresh token:", err);
+      return null;
+    }
+  }
+  deleteRefreshToken() {
+    try {
+      const filePath = path.join(app.getPath("userData"), REFRESH_TOKEN_DIR, REFRESH_TOKEN_FILE);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (err) {
+      console.warn("[AuthManager] Failed to delete refresh token:", err);
+    }
+  }
+  /**
+   * Schedule a retry of initialization after a transient failure.
+   * The refresh token is still stored on disk, so we just need to try refreshing again.
+   */
+  scheduleInitRetry() {
+    if (this.initRetryTimer) {
+      clearTimeout(this.initRetryTimer);
+    }
+    console.log(`[AuthManager] Scheduling init retry in ${INIT_RETRY_DELAY_MS / 1e3}s`);
+    this.initRetryTimer = setTimeout(async () => {
+      this.initRetryTimer = null;
+      if (this.accessToken || !this.refreshToken) {
+        return;
+      }
+      console.log("[AuthManager] Retrying session restoration...");
+      try {
+        await this.refreshAccessToken();
+        await this.fetchUserProfile();
+        console.log("[AuthManager] Session restored on retry");
+        this.broadcastState();
+      } catch (err) {
+        console.warn("[AuthManager] Init retry failed:", err);
+        if (err instanceof AuthTokenInvalidError) {
+          this.clearTokens();
+          this.broadcastState();
+        }
+      }
+    }, INIT_RETRY_DELAY_MS);
+  }
+  clearTokens() {
+    this.accessToken = null;
+    this.accessTokenExpiresAt = 0;
+    this.refreshToken = null;
+    this.userProfile = null;
+    this.error = null;
+    this.deviceFlowStatus = "idle";
+    this.userCode = null;
+    this.verificationUrl = null;
+    this.deviceCode = null;
+    this.autoRefreshRetryCount = 0;
+    this.stopPolling();
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    if (this.initRetryTimer) {
+      clearTimeout(this.initRetryTimer);
+      this.initRetryTimer = null;
+    }
+    this.deleteRefreshToken();
+  }
+  broadcastState() {
+    windowManager.sendToRenderer("auth:stateChanged", this.getAuthState());
+  }
+}
+const authManager = AuthManager.getInstance();
+class CloudService {
+  static instance;
+  constructor() {
+  }
+  static getInstance() {
+    if (!CloudService.instance) {
+      CloudService.instance = new CloudService();
+    }
+    return CloudService.instance;
+  }
+  /**
+   * Convert a file using the cloud API
+   * @param fileData - File data with either path (local file) or content (ArrayBuffer)
+   * @returns Task creation response with task_id and events_url
+   */
+  async convert(fileData) {
+    try {
+      const token = await authManager.getAccessToken();
+      if (!token) {
+        return { success: false, error: "Authentication required" };
+      }
+      const model = fileData.model || "lite";
+      console.log("[CloudService] Starting cloud conversion for:", fileData.name, "model:", model);
+      const formData = new FormData();
+      let fileBuffer;
+      if (fileData.content) {
+        fileBuffer = fileData.content;
+      } else if (fileData.path) {
+        const buffer = await fs$1.readFile(fileData.path);
+        fileBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+      } else {
+        return { success: false, error: "No file content or path provided" };
+      }
+      const blob = new Blob([fileBuffer]);
+      formData.append("file", blob, fileData.name);
+      formData.append("model", model);
+      formData.append("language", "auto");
+      if (fileData.page_range) {
+        formData.append("page_range", fileData.page_range);
+      }
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/convert`, {
+        method: "POST",
+        body: formData
+        // Note: Do NOT set Content-Type manually - let the browser/fetch set it with proper boundary
+      });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        const errorMessage = errorBody?.error?.message || `Upload failed: ${res.status}`;
+        console.error("[CloudService] Convert API error:", errorMessage);
+        return { success: false, error: errorMessage };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid response from server" };
+      }
+      console.log("[CloudService] Task created:", responseJson.data.task_id);
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] convert error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get tasks from the cloud API
+   */
+  async getTasks(page = 1, pageSize = 10) {
+    try {
+      const params = new URLSearchParams({
+        page: String(page),
+        page_size: String(pageSize)
+      });
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/tasks?${params.toString()}`
+      );
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch tasks: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success) {
+        return { success: false, error: responseJson.error?.message || "Invalid tasks response" };
+      }
+      return {
+        success: true,
+        data: responseJson.data,
+        pagination: responseJson.pagination
+      };
+    } catch (error) {
+      console.error("[CloudService] getTasks error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get a single task by ID
+   */
+  async getTaskById(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}`);
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch task: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid task response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] getTaskById error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get pages for a task
+   */
+  async getTaskPages(id, page = 1, pageSize = 50) {
+    try {
+      const params = new URLSearchParams({
+        page: String(page),
+        page_size: String(pageSize)
+      });
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/pages?${params.toString()}`
+      );
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch task pages: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success) {
+        return { success: false, error: responseJson.error?.message || "Invalid pages response" };
+      }
+      return {
+        success: true,
+        data: responseJson.data,
+        pagination: responseJson.pagination
+      };
+    } catch (error) {
+      console.error("[CloudService] getTaskPages error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Cancel a task
+   */
+  async cancelTask(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/cancel`, {
+        method: "POST"
+      });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to cancel task: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid cancel response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] cancelTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Retry an entire task (creates a new task)
+   */
+  async retryTask(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/retry`, {
+        method: "POST"
+      });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to retry task: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid retry response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] retryTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Retry a single page
+   */
+  async retryPage(taskId, pageNumber) {
+    try {
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(taskId)}/pages/${encodeURIComponent(String(pageNumber))}/retry`,
+        { method: "POST" }
+      );
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to retry page: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid page retry response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] retryPage error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get task conversion result (merged markdown)
+   */
+  async getTaskResult(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/result`, {}, { timeoutMs: 0 });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch result: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid result response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] getTaskResult error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Download PDF file for a task
+   */
+  async downloadPdf(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}/pdf`, {}, { timeoutMs: 0 });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to download PDF: ${res.status}`
+        };
+      }
+      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 buffer = await res.arrayBuffer();
+      return { success: true, data: { buffer, fileName } };
+    } catch (error) {
+      console.error("[CloudService] downloadPdf error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get page image via proxy (for relative API paths that need auth)
+   */
+  async getPageImage(taskId, pageNumber) {
+    try {
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(taskId)}/pages/${encodeURIComponent(String(pageNumber))}/image`,
+        {},
+        { timeoutMs: 0 }
+      );
+      if (!res.ok) {
+        return {
+          success: false,
+          error: `Failed to fetch page image: ${res.status}`
+        };
+      }
+      const contentType = res.headers.get("Content-Type") || "image/png";
+      const buffer = await res.arrayBuffer();
+      const base64 = Buffer.from(buffer).toString("base64");
+      const dataUrl = `data:${contentType};base64,${base64}`;
+      return { success: true, data: { dataUrl } };
+    } catch (error) {
+      console.error("[CloudService] getPageImage error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get credits info from the cloud API
+   */
+  async getCredits() {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/credits`);
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch credits: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid credits response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] getCredits error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get credit history (transactions) from the cloud API
+   */
+  async getCreditHistory(page = 1, pageSize = 20, type) {
+    try {
+      const params = new URLSearchParams({
+        page: String(page),
+        page_size: String(pageSize)
+      });
+      if (type) {
+        params.set("type", type);
+      }
+      const res = await authManager.fetchWithAuth(
+        `${API_BASE_URL}/api/v1/credits/transactions?${params.toString()}`
+      );
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to fetch credit history: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success) {
+        return { success: false, error: responseJson.error?.message || "Invalid credit history response" };
+      }
+      return {
+        success: true,
+        data: responseJson.data,
+        pagination: responseJson.pagination
+      };
+    } catch (error) {
+      console.error("[CloudService] getCreditHistory 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
+   */
+  async deleteTask(id) {
+    try {
+      const res = await authManager.fetchWithAuth(`${API_BASE_URL}/api/v1/tasks/${encodeURIComponent(id)}`, {
+        method: "DELETE"
+      });
+      if (!res.ok) {
+        const errorBody = await res.json().catch(() => null);
+        return {
+          success: false,
+          error: errorBody?.error?.message || `Failed to delete task: ${res.status}`
+        };
+      }
+      const responseJson = await res.json();
+      if (!responseJson.success || !responseJson.data) {
+        return { success: false, error: "Invalid delete response" };
+      }
+      return { success: true, data: responseJson.data };
+    } catch (error) {
+      console.error("[CloudService] deleteTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+}
+const cloudService = CloudService.getInstance();
+const HEARTBEAT_TIMEOUT_MS = 9e4;
+const INITIAL_RECONNECT_DELAY_MS = 1e3;
+const MAX_RECONNECT_DELAY_MS = 3e4;
+const FORWARDABLE_EVENTS = /* @__PURE__ */ new Set([
+  "pdf_ready",
+  "page_started",
+  "page_completed",
+  "page_failed",
+  "page_retry_started",
+  "completed",
+  "error",
+  "cancelled"
+]);
+class CloudSSEManager {
+  static instance;
+  abortController = null;
+  lastEventId = "0";
+  reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  connected = false;
+  constructor() {
+  }
+  static getInstance() {
+    if (!CloudSSEManager.instance) {
+      CloudSSEManager.instance = new CloudSSEManager();
+    }
+    return CloudSSEManager.instance;
+  }
+  /**
+   * Connect to the global SSE endpoint.
+   * Safe to call multiple times — tears down any existing connection first.
+   * Preserves lastEventId so reconnection can resume from where it left off.
+   */
+  async connect() {
+    if (this.connected) {
+      console.log("[CloudSSE] Already connected, skipping");
+      return;
+    }
+    this.connected = true;
+    const token = await authManager.getAccessToken();
+    if (!token) {
+      console.log("[CloudSSE] No auth token, skipping connect");
+      this.connected = false;
+      return;
+    }
+    if (!this.connected) {
+      console.log("[CloudSSE] Disconnected while obtaining token, aborting");
+      return;
+    }
+    this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+    try {
+      await this.startStream();
+    } catch (error) {
+      console.error("[CloudSSE] startStream failed during connect:", error);
+      this.connected = false;
+    }
+  }
+  /**
+   * Disconnect from SSE but preserve lastEventId for resumption.
+   * Use this for temporary disconnections (e.g., component unmount, re-render).
+   */
+  disconnect() {
+    console.log("[CloudSSE] Disconnecting (preserving lastEventId for resumption)");
+    this.connected = false;
+    this.cleanup();
+  }
+  /**
+   * Fully disconnect and reset all state including lastEventId.
+   * Use this only on explicit logout — the next connect() will start fresh.
+   */
+  resetAndDisconnect() {
+    console.log("[CloudSSE] Full reset and disconnect");
+    this.connected = false;
+    this.lastEventId = "0";
+    this.cleanup();
+  }
+  cleanup() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  resetHeartbeatTimer() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setTimeout(() => {
+      console.warn("[CloudSSE] Heartbeat timeout, reconnecting...");
+      this.reconnect();
+    }, HEARTBEAT_TIMEOUT_MS);
+  }
+  async reconnect() {
+    if (!this.connected) return;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    console.log(`[CloudSSE] Reconnecting in ${this.reconnectDelay}ms (lastEventId=${this.lastEventId})...`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (!this.connected) return;
+      await this.startStream();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+  }
+  async startStream() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    const url = `${API_BASE_URL}/api/v1/tasks/events`;
+    this.abortController = new AbortController();
+    const headers = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    if (this.lastEventId !== "0") {
+      headers["Last-Event-ID"] = this.lastEventId;
+    }
+    try {
+      if (isDev) {
+        console.log(`[CloudSSE] Connecting to ${url} (Last-Event-ID=${this.lastEventId})`);
+      }
+      const res = await authManager.fetchWithAuth(url, {
+        headers,
+        signal: this.abortController.signal
+      }, { timeoutMs: 0 });
+      if (isDev) {
+        console.log(`[CloudSSE] Response status: ${res.status}, content-type: ${res.headers.get("content-type")}`);
+      }
+      if (!res.ok) {
+        console.error(`[CloudSSE] HTTP error: ${res.status}`);
+        this.reconnect();
+        return;
+      }
+      const contentType = res.headers.get("content-type") || "";
+      if (!contentType.includes("text/event-stream")) {
+        console.error(`[CloudSSE] Unexpected content-type: ${contentType}, expected text/event-stream`);
+        this.reconnect();
+        return;
+      }
+      if (!res.body) {
+        console.error("[CloudSSE] No response body");
+        this.reconnect();
+        return;
+      }
+      this.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+      this.resetHeartbeatTimer();
+      console.log("[CloudSSE] Connected, reading stream...");
+      await this.readStream(res.body);
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("[CloudSSE] Stream aborted");
+        return;
+      }
+      console.error("[CloudSSE] Stream error:", error?.message || error);
+      this.reconnect();
+    }
+  }
+  async readStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let chunkCount = 0;
+    let aborted = false;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          console.log(`[CloudSSE] Stream ended after ${chunkCount} chunks`);
+          break;
+        }
+        chunkCount++;
+        const chunk = decoder.decode(value, { stream: true });
+        if (isDev) {
+          console.log(`[CloudSSE] Chunk #${chunkCount} (${value.byteLength} bytes)`);
+        }
+        buffer += chunk;
+        buffer = buffer.replace(/\r\n/g, "\n");
+        const messages = buffer.split("\n\n");
+        buffer = messages.pop() || "";
+        for (const msg of messages) {
+          if (msg.trim()) {
+            this.parseSSEMessage(msg);
+          }
+        }
+      }
+    } catch (error) {
+      if (error.name === "AbortError") {
+        aborted = true;
+      } else {
+        console.error("[CloudSSE] Read error:", error?.message || error);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (!aborted && this.connected) {
+      this.reconnect();
+    }
+  }
+  parseSSEMessage(raw) {
+    let eventType = "";
+    let data = "";
+    let id = "";
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        if (data.length > 0) data += "\n";
+        data += line.slice(5).trim();
+      } else if (line.startsWith("id:")) {
+        id = line.slice(3).trim();
+      }
+    }
+    if (id) {
+      this.lastEventId = id;
+    }
+    if (!eventType || !data) return;
+    this.resetHeartbeatTimer();
+    if (isDev && eventType !== "heartbeat") {
+      console.log(`[CloudSSE] Event: type=${eventType}, id=${id || "none"}, data=${data.substring(0, 200)}`);
+    }
+    if (eventType === "connected" || eventType === "heartbeat") {
+      return;
+    }
+    try {
+      const parsedData = JSON.parse(data);
+      if (!FORWARDABLE_EVENTS.has(eventType)) {
+        console.warn(`[CloudSSE] Unknown event type: ${eventType}, skipping`);
+        return;
+      }
+      const event = {
+        type: eventType,
+        data: parsedData
+      };
+      if (isDev) {
+        console.log(`[CloudSSE] Forwarding to renderer: type=${eventType}, task_id=${parsedData.task_id || "none"}`);
+      }
+      windowManager.sendToRenderer("cloud:taskEvent", event);
+    } catch (error) {
+      console.error("[CloudSSE] Failed to parse event data:", error, data);
+    }
+  }
+}
+const cloudSSEManager = CloudSSEManager.getInstance();
+const MAX_UPLOAD_SIZE_BYTES = 100 * 1024 * 1024;
+function registerCloudHandlers() {
+  ipcMain.handle("cloud:convert", async (_, fileData) => {
+    try {
+      if (!fileData.path && !fileData.content) {
+        return { success: false, error: "No file content or path provided" };
+      }
+      if (fileData.content && fileData.content.byteLength > MAX_UPLOAD_SIZE_BYTES) {
+        return { success: false, error: `File too large (max ${MAX_UPLOAD_SIZE_BYTES / 1024 / 1024}MB)` };
+      }
+      if (fileData.path) {
+        try {
+          const stat = await fs.promises.stat(fileData.path);
+          if (stat.size > MAX_UPLOAD_SIZE_BYTES) {
+            return { success: false, error: `File too large (max ${MAX_UPLOAD_SIZE_BYTES / 1024 / 1024}MB)` };
+          }
+        } catch {
+          return { success: false, error: "File not found or not accessible" };
+        }
+      }
+      const result = await cloudService.convert(fileData);
+      return result;
+    } catch (error) {
+      console.error("[IPC] cloud:convert error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getTasks", async (_, params) => {
+    try {
+      return await cloudService.getTasks(params.page, params.pageSize);
+    } catch (error) {
+      console.error("[IPC] cloud:getTasks error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getTaskById", async (_, id) => {
+    try {
+      return await cloudService.getTaskById(id);
+    } catch (error) {
+      console.error("[IPC] cloud:getTaskById error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getTaskPages", async (_, params) => {
+    try {
+      return await cloudService.getTaskPages(params.taskId, params.page, params.pageSize);
+    } catch (error) {
+      console.error("[IPC] cloud:getTaskPages error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:cancelTask", async (_, id) => {
+    try {
+      return await cloudService.cancelTask(id);
+    } catch (error) {
+      console.error("[IPC] cloud:cancelTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:retryTask", async (_, id) => {
+    try {
+      return await cloudService.retryTask(id);
+    } catch (error) {
+      console.error("[IPC] cloud:retryTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:deleteTask", async (_, id) => {
+    try {
+      return await cloudService.deleteTask(id);
+    } catch (error) {
+      console.error("[IPC] cloud:deleteTask error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:retryPage", async (_, params) => {
+    try {
+      return await cloudService.retryPage(params.taskId, params.pageNumber);
+    } catch (error) {
+      console.error("[IPC] cloud:retryPage error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getTaskResult", async (_, id) => {
+    try {
+      return await cloudService.getTaskResult(id);
+    } catch (error) {
+      console.error("[IPC] cloud:getTaskResult error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:downloadPdf", async (_, id) => {
+    try {
+      const result = await cloudService.downloadPdf(id);
+      if (!result.success || !result.data) {
+        return { success: false, error: result.error || "Download failed" };
+      }
+      const { buffer, fileName } = result.data;
+      const downloadsPath = app.getPath("downloads");
+      const saveResult = await dialog.showSaveDialog({
+        defaultPath: path.join(downloadsPath, fileName),
+        filters: [{ name: "PDF", extensions: ["pdf"] }]
+      });
+      if (saveResult.canceled || !saveResult.filePath) {
+        return { success: false, error: "Cancelled" };
+      }
+      fs.writeFileSync(saveResult.filePath, Buffer.from(buffer));
+      return { success: true, data: { filePath: saveResult.filePath } };
+    } catch (error) {
+      console.error("[IPC] cloud:downloadPdf error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getPageImage", async (_, params) => {
+    try {
+      return await cloudService.getPageImage(params.taskId, params.pageNumber);
+    } catch (error) {
+      console.error("[IPC] cloud:getPageImage error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getCredits", async () => {
+    try {
+      return await cloudService.getCredits();
+    } catch (error) {
+      console.error("[IPC] cloud:getCredits error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:getCreditHistory", async (_, params) => {
+    try {
+      return await cloudService.getCreditHistory(params.page, params.pageSize, params.type);
+    } catch (error) {
+      console.error("[IPC] cloud:getCreditHistory error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:sseConnect", async () => {
+    try {
+      await cloudSSEManager.connect();
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] cloud:sseConnect error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:sseDisconnect", async () => {
+    try {
+      cloudSSEManager.disconnect();
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] cloud:sseDisconnect error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("cloud:sseResetAndDisconnect", async () => {
+    try {
+      cloudSSEManager.resetAndDisconnect();
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] cloud:sseResetAndDisconnect error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  console.log("[IPC] Cloud handlers registered");
+}
+function registerAuthHandlers() {
+  ipcMain.handle("auth:login", async () => {
+    try {
+      const result = await authManager.startDeviceLogin();
+      return result;
+    } catch (error) {
+      console.error("[IPC] auth:login error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("auth:cancelLogin", async () => {
+    try {
+      authManager.cancelLogin();
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] auth:cancelLogin error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("auth:logout", async () => {
+    try {
+      await authManager.logout();
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] auth:logout error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  ipcMain.handle("auth:getAuthState", async () => {
+    try {
+      const state = authManager.getAuthState();
+      return { success: true, data: state };
+    } catch (error) {
+      console.error("[IPC] auth:getAuthState error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  console.log("[IPC] Auth handlers registered");
+}
+const { autoUpdater } = pkg$1;
+class UpdateService {
+  static instance;
+  initialized = false;
+  isChecking = false;
+  constructor() {
+  }
+  static getInstance() {
+    if (!UpdateService.instance) {
+      UpdateService.instance = new UpdateService();
+    }
+    return UpdateService.instance;
+  }
+  ensureInitialized() {
+    if (this.initialized) return;
+    if (!app.isPackaged) return;
+    this.initialized = true;
+    autoUpdater.autoDownload = true;
+    autoUpdater.allowPrerelease = false;
+    autoUpdater.autoInstallOnAppQuit = true;
+    this.registerListeners();
+  }
+  registerListeners() {
+    autoUpdater.on("checking-for-update", () => {
+      console.log("[UpdateService] Checking for updates...");
+      this.sendStatus({ status: UpdateStatus.CHECKING });
+    });
+    autoUpdater.on("update-available", (info) => {
+      console.log("[UpdateService] Update available:", info.version);
+      this.sendStatus({ status: UpdateStatus.AVAILABLE, version: info.version });
+    });
+    autoUpdater.on("update-not-available", (info) => {
+      console.log("[UpdateService] No update available. Current version:", info.version);
+      this.sendStatus({ status: UpdateStatus.NOT_AVAILABLE, version: info.version });
+    });
+    autoUpdater.on("download-progress", (progress) => {
+      console.log(`[UpdateService] Download progress: ${progress.percent.toFixed(1)}%`);
+      this.sendStatus({ status: UpdateStatus.DOWNLOADING, progress: progress.percent });
+    });
+    autoUpdater.on("update-downloaded", (info) => {
+      console.log("[UpdateService] Update downloaded:", info.version);
+      this.sendStatus({ status: UpdateStatus.DOWNLOADED, version: info.version });
+    });
+    autoUpdater.on("error", (error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const safeMessage = errorMessage.length > 200 ? `${errorMessage.slice(0, 200)}...` : errorMessage;
+      const errorDetails = {
+        message: safeMessage,
+        name: error instanceof Error ? error.name : void 0,
+        stack: error instanceof Error ? error.stack : void 0,
+        code: error.code,
+        statusCode: error.statusCode
+      };
+      console.error("[UpdateService] Error:", errorDetails);
+      this.sendStatus({ status: UpdateStatus.ERROR, error: safeMessage });
+    });
+  }
+  sendStatus(data) {
+    windowManager.sendToRenderer(IPC_CHANNELS.EVENTS.UPDATER_STATUS, data);
+  }
+  async checkForUpdates() {
+    this.ensureInitialized();
+    if (!this.initialized) return;
+    if (this.isChecking) return;
+    this.isChecking = true;
+    try {
+      await autoUpdater.checkForUpdates();
+    } finally {
+      this.isChecking = false;
+    }
+  }
+  quitAndInstall() {
+    this.ensureInitialized();
+    autoUpdater.quitAndInstall();
+  }
+}
+const updateService = UpdateService.getInstance();
+function registerUpdaterHandlers() {
+  ipcMain.handle(IPC_CHANNELS.UPDATER.CHECK_FOR_UPDATES, async () => {
+    if (!app.isPackaged) {
+      console.log("[Updater] Skipping update check in development mode");
+      windowManager.sendToRenderer(IPC_CHANNELS.EVENTS.UPDATER_STATUS, {
+        status: UpdateStatus.NOT_AVAILABLE
+      });
+      return;
+    }
+    await updateService.checkForUpdates();
+  });
+  ipcMain.handle(IPC_CHANNELS.UPDATER.QUIT_AND_INSTALL, () => {
+    updateService.quitAndInstall();
+  });
+}
+function registerAllHandlers() {
+  registerProviderHandlers();
+  registerModelHandlers();
+  registerTaskHandlers();
+  registerTaskDetailHandlers();
+  registerFileHandlers();
+  registerCompletionHandlers();
+  registerAuthHandlers();
+  registerCloudHandlers();
+  registerAppHandlers();
+  registerUpdaterHandlers();
+  console.log("[IPC] All handlers registered successfully");
+}
+function registerIpcHandlers() {
+  registerAllHandlers();
+}
+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();
+if (!app.isPackaged) {
+  app.setName("MarkPDFdown");
+  const userDataPath = app.getPath("userData");
+  if (userDataPath.endsWith("Electron")) {
+    const newPath = userDataPath.replace(/Electron$/, "MarkPDFdown");
+    app.setPath("userData", newPath);
+  }
+}
+function getIconPath() {
+  let iconName;
+  if (app.isPackaged) {
+    iconName = process.platform === "darwin" ? "icons/mac/icon.icns" : process.platform === "win32" ? "icons/win/icon.ico" : "icons/png/512x512.png";
+  } else {
+    iconName = process.platform === "darwin" ? "icons/mac/png/512x512.png" : "icons/png/512x512.png";
+  }
+  if (process.env.ELECTRON_RENDERER_URL) {
+    return path.join(process.cwd(), "public", iconName);
+  }
+  if (app.isPackaged) {
+    return path.join(process.resourcesPath, iconName);
+  }
+  const appPath = app.getAppPath();
+  const possiblePaths = [
+    path.join(appPath, "..", "..", "public", iconName),
+    // dist/main -> 根目录
+    path.join(appPath, "..", "public", iconName),
+    // dist -> 根目录
+    path.join(appPath, "public", iconName),
+    // 当前目录
+    path.join(process.cwd(), "public", iconName)
+    // 工作目录
+  ];
+  for (const iconPath of possiblePaths) {
+    if (fs.existsSync(iconPath)) {
+      return iconPath;
     }
   }
   return possiblePaths[0];
 }
+const PROTOCOL_NAME = "markpdfdown";
 protocol.registerSchemesAsPrivileged([
   {
     scheme: "local-file",
@@ -3948,6 +5505,65 @@ protocol.registerSchemesAsPrivileged([
     }
   }
 ]);
+if (process.defaultApp) {
+  if (process.argv.length >= 2) {
+    app.setAsDefaultProtocolClient(PROTOCOL_NAME, process.execPath, [path.resolve(process.argv[1])]);
+  }
+} else {
+  app.setAsDefaultProtocolClient(PROTOCOL_NAME);
+}
+function handleProtocolUrl(url) {
+  console.log("[Main] Received protocol URL");
+  if (!url.startsWith(`${PROTOCOL_NAME}://`)) {
+    console.warn("[Main] Ignoring URL with unexpected scheme");
+    return;
+  }
+  try {
+    const parsed = new URL(url);
+    const host = parsed.host.toLowerCase();
+    const 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 === "";
+    if (!isAllowed) {
+      console.warn(`[Main] Ignoring protocol URL with unexpected path: ${host}${pathname}`);
+      return;
+    }
+  } catch {
+    console.warn("[Main] Ignoring malformed protocol URL");
+    return;
+  }
+  if (mainWindow) {
+    if (mainWindow.isMinimized()) {
+      mainWindow.restore();
+    }
+    mainWindow.focus();
+  }
+  authManager.checkDeviceTokenStatus();
+}
+app.on("open-url", (event, url) => {
+  event.preventDefault();
+  handleProtocolUrl(url);
+});
+const gotTheLock = app.requestSingleInstanceLock();
+if (!gotTheLock) {
+  app.quit();
+} else {
+  app.on("second-instance", (_event, commandLine) => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) {
+        mainWindow.restore();
+      }
+      mainWindow.focus();
+    }
+    const url = commandLine.find((arg) => arg.startsWith(`${PROTOCOL_NAME}://`));
+    if (url) {
+      handleProtocolUrl(url);
+    }
+  });
+}
 let mainWindow;
 function registerLocalFileProtocol() {
   protocol.registerFileProtocol("local-file", (request, callback) => {
@@ -4096,6 +5712,10 @@ async function initializeBackgroundServices() {
     console.log("[Main] Initializing database in background...");
     await initDatabase();
     console.log(`[Main] Database initialized in ${Date.now() - startTime}ms`);
+    console.log("[Main] Restoring auth session...");
+    const authStartTime = Date.now();
+    await authManager.initialize();
+    console.log(`[Main] Auth session restored in ${Date.now() - authStartTime}ms`);
     console.log("[Main] Injecting preset providers...");
     const presetStartTime = Date.now();
     await presetProviderService.initialize();