markpdfdown 0.1.8-beta.6 → 0.2.0

package/dist/main/index.js

@@ -12,6 +12,7 @@ import sharp from "sharp";
 import fs$1 from "fs/promises";
 import { v4 } from "uuid";
 import { createRequire } from "module";
+import pkg$1 from "electron-updater";
 import __cjs_mod__ from "node:module";
 const __filename = import.meta.filename;
 const __dirname = import.meta.dirname;
@@ -248,6 +249,16 @@ var PageStatus = /* @__PURE__ */ ((PageStatus2) => {
   PageStatus2[PageStatus2["RETRYING"] = 3] = "RETRYING";
   return PageStatus2;
 })(PageStatus || {});
+var UpdateStatus = /* @__PURE__ */ ((UpdateStatus2) => {
+  UpdateStatus2["IDLE"] = "idle";
+  UpdateStatus2["CHECKING"] = "checking";
+  UpdateStatus2["AVAILABLE"] = "available";
+  UpdateStatus2["NOT_AVAILABLE"] = "not_available";
+  UpdateStatus2["DOWNLOADING"] = "downloading";
+  UpdateStatus2["DOWNLOADED"] = "downloaded";
+  UpdateStatus2["ERROR"] = "error";
+  return UpdateStatus2;
+})(UpdateStatus || {});
 var TaskEventType = /* @__PURE__ */ ((TaskEventType2) => {
   TaskEventType2["TASK_UPDATED"] = "task:updated";
   TaskEventType2["TASK_STATUS_CHANGED"] = "task:status_changed";
@@ -2439,6 +2450,151 @@ class WorkerOrchestrator {
   }
 }
 const workerOrchestrator = new WorkerOrchestrator();
+const providerPresets = [
+  {
+    name: "OpenAI",
+    type: "openai-responses",
+    apiBase: "https://api.openai.com/v1",
+    modelListApi: "/models",
+    modelNameField: "id",
+    modelIdField: "id",
+    defaultModels: []
+  },
+  {
+    name: "Anthropic",
+    type: "anthropic",
+    apiBase: "https://api.anthropic.com/v1",
+    modelListApi: "/models",
+    modelNameField: "display_name",
+    modelIdField: "id",
+    capabilityField: "input_modalities",
+    capabilityFilter: "image",
+    defaultModels: []
+  },
+  {
+    name: "Gemini",
+    type: "gemini",
+    apiBase: "https://generativelanguage.googleapis.com/v1beta",
+    modelListApi: "/models",
+    modelNameField: "displayName",
+    modelIdField: "name",
+    defaultModels: []
+  },
+  {
+    name: "ZenMux",
+    type: "anthropic",
+    apiBase: "https://zenmux.ai/api/anthropic/v1",
+    modelListApi: "/models",
+    modelNameField: "display_name",
+    modelIdField: "id",
+    capabilityField: "input_modalities",
+    capabilityFilter: "image",
+    defaultModels: []
+  },
+  {
+    name: "OpenRouter",
+    type: "openai",
+    apiBase: "https://openrouter.ai/api/v1",
+    modelListApi: "/models",
+    modelNameField: "name",
+    modelIdField: "id",
+    capabilityField: "architecture.input_modalities",
+    capabilityFilter: "image",
+    defaultModels: []
+  },
+  {
+    name: "SiliconFlow",
+    type: "openai",
+    apiBase: "https://api.siliconflow.cn/v1",
+    modelListApi: "/models",
+    modelNameField: "id",
+    modelIdField: "id",
+    defaultModels: []
+  },
+  {
+    name: "Ollama",
+    type: "ollama",
+    apiBase: "http://localhost:11434/api",
+    modelListApi: "/tags",
+    modelNameField: "name",
+    modelIdField: "name",
+    defaultModels: []
+  }
+];
+function findProviderPreset(type, name) {
+  return providerPresets.find(
+    (preset) => preset.type === type && preset.name === name
+  );
+}
+function getProviderPresetKey(type, name) {
+  return `${type}:${name}`;
+}
+class PresetProviderService {
+  static instance;
+  initialized = false;
+  constructor() {
+  }
+  static getInstance() {
+    if (!PresetProviderService.instance) {
+      PresetProviderService.instance = new PresetProviderService();
+    }
+    return PresetProviderService.instance;
+  }
+  /**
+   * 初始化预设供应商
+   * 使用 type + name 去重，若不存在则插入，status = -1（禁用）
+   */
+  async initialize() {
+    if (this.initialized) {
+      console.log("[PresetProviderService] Already initialized, skipping...");
+      return;
+    }
+    try {
+      console.log("[PresetProviderService] Starting preset provider injection...");
+      const existingProviders = await providerRepository.findAllIncludeDisabled();
+      const existingKeys = new Set(
+        existingProviders.map((p) => getProviderPresetKey(p.type, p.name))
+      );
+      let insertedCount = 0;
+      for (const preset of providerPresets) {
+        const key = getProviderPresetKey(preset.type, preset.name);
+        if (!existingKeys.has(key)) {
+          await providerRepository.create({
+            name: preset.name,
+            type: preset.type,
+            api_key: "",
+            base_url: preset.apiBase,
+            suffix: "",
+            status: -1
+            // 默认禁用
+          });
+          console.log(
+            `[PresetProviderService] Inserted preset provider: ${preset.name} (${preset.type})`
+          );
+          insertedCount++;
+        } else {
+          console.log(
+            `[PresetProviderService] Preset provider already exists: ${preset.name} (${preset.type})`
+          );
+        }
+      }
+      console.log(
+        `[PresetProviderService] Preset provider injection completed. Inserted: ${insertedCount}`
+      );
+      this.initialized = true;
+    } catch (error) {
+      console.error("[PresetProviderService] Failed to initialize preset providers:", error);
+      throw error;
+    }
+  }
+  /**
+   * 重置初始化状态（主要用于测试）
+   */
+  reset() {
+    this.initialized = false;
+  }
+}
+const presetProviderService = PresetProviderService.getInstance();
 const IPC_CHANNELS = {
   // Provider channels
   PROVIDER: {
@@ -2447,7 +2603,9 @@ const IPC_CHANNELS = {
     CREATE: "provider:create",
     UPDATE: "provider:update",
     DELETE: "provider:delete",
-    UPDATE_STATUS: "provider:updateStatus"
+    UPDATE_STATUS: "provider:updateStatus",
+    GET_PRESETS: "provider:getPresets",
+    FETCH_MODEL_LIST: "provider:fetchModelList"
   },
   // Model channels
   MODEL: {
@@ -2485,6 +2643,15 @@ const IPC_CHANNELS = {
   COMPLETION: {
     MARK_IMAGEDOWN: "completion:markImagedown",
     TEST_CONNECTION: "completion:testConnection"
+  },
+  // Event channels (for event bridge)
+  EVENTS: {
+    UPDATER_STATUS: "updater:status"
+  },
+  // Updater channels
+  UPDATER: {
+    CHECK_FOR_UPDATES: "updater:checkForUpdates",
+    QUIT_AND_INSTALL: "updater:quitAndInstall"
   }
 };
 function registerProviderHandlers() {
@@ -2590,8 +2757,135 @@ function registerProviderHandlers() {
       }
     }
   );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.GET_PRESETS,
+    async () => {
+      try {
+        return { success: true, data: providerPresets };
+      } catch (error) {
+        console.error("[IPC] provider:getPresets error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
+  ipcMain.handle(
+    IPC_CHANNELS.PROVIDER.FETCH_MODEL_LIST,
+    async (_, providerId) => {
+      try {
+        const provider = await providerRepository.findById(providerId);
+        if (!provider) {
+          return { success: false, error: "Provider not found" };
+        }
+        const preset = findProviderPreset(provider.type, provider.name);
+        const baseUrl = provider.base_url || preset?.apiBase;
+        if (!baseUrl) {
+          return {
+            success: false,
+            error: "No API base URL configured for this provider"
+          };
+        }
+        const modelListApi = preset?.modelListApi ?? "/models";
+        const modelListUrl = `${baseUrl}${modelListApi}`;
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (provider.api_key) {
+          switch (provider.type) {
+            case "anthropic":
+              headers["x-api-key"] = provider.api_key;
+              headers["anthropic-version"] = "2023-06-01";
+              break;
+            case "gemini":
+              headers["x-goog-api-key"] = provider.api_key;
+              break;
+            default:
+              headers["Authorization"] = `Bearer ${provider.api_key}`;
+              break;
+          }
+        }
+        const response = await fetch(modelListUrl, {
+          method: "GET",
+          headers
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          console.error(
+            `[IPC] provider:fetchModelList HTTP error: ${response.status}`,
+            errorText
+          );
+          return {
+            success: false,
+            error: `Failed to fetch models: HTTP ${response.status}`
+          };
+        }
+        const data = await response.json();
+        const filterByCapability = (items) => {
+          if (!preset?.capabilityField || !preset?.capabilityFilter) return items;
+          return items.filter((item) => {
+            const value = getNestedValue(item, preset.capabilityField);
+            if (!Array.isArray(value)) return true;
+            return value.includes(preset.capabilityFilter);
+          });
+        };
+        let models = [];
+        const modelIdField = preset?.modelIdField ?? "id";
+        const modelNameField = preset?.modelNameField ?? "id";
+        switch (provider.type) {
+          case "openai":
+          case "openai-responses":
+            if (data.data && Array.isArray(data.data)) {
+              models = filterByCapability(data.data).map((item) => ({
+                id: item[modelIdField] || item.id,
+                name: item[modelNameField] || item.id
+              }));
+            }
+            break;
+          case "anthropic":
+            if (data.data && Array.isArray(data.data)) {
+              models = filterByCapability(data.data).map((item) => ({
+                id: item[modelIdField] || item.id,
+                name: item[modelNameField] || item.id
+              }));
+            }
+            break;
+          case "gemini":
+            if (data.models && Array.isArray(data.models)) {
+              models = filterByCapability(data.models).map((item) => ({
+                id: item[modelIdField]?.replace("models/", "") || item.name,
+                name: item[modelNameField] || item.name
+              }));
+            }
+            break;
+          case "ollama":
+            if (data.models && Array.isArray(data.models)) {
+              models = filterByCapability(data.models).map((item) => ({
+                id: item[modelIdField] || item.name,
+                name: item[modelNameField] || item.name
+              }));
+            }
+            break;
+          default: {
+            const modelArray = data.data || data.models || [];
+            if (Array.isArray(modelArray)) {
+              models = filterByCapability(modelArray).map((item) => ({
+                id: getNestedValue(item, modelIdField) || item.id || item.name,
+                name: getNestedValue(item, modelNameField) || item.id || item.name
+              }));
+            }
+          }
+        }
+        return { success: true, data: models };
+      } catch (error) {
+        console.error("[IPC] provider:fetchModelList error:", error);
+        return { success: false, error: error.message };
+      }
+    }
+  );
   console.log("[IPC] Provider handlers registered");
 }
+function getNestedValue(obj, path2) {
+  return path2.split(".").reduce((acc, part) => acc?.[part], obj);
+}
 const findAll$1 = async () => {
   return await prisma.model.findMany({
     orderBy: [{ createdAt: "desc" }]
@@ -3429,19 +3723,6 @@ function registerAppHandlers() {
     return getAppVersion();
   });
 }
-function registerAllHandlers() {
-  registerProviderHandlers();
-  registerModelHandlers();
-  registerTaskHandlers();
-  registerTaskDetailHandlers();
-  registerFileHandlers();
-  registerCompletionHandlers();
-  registerAppHandlers();
-  console.log("[IPC] All handlers registered successfully");
-}
-function registerIpcHandlers() {
-  registerAllHandlers();
-}
 class WindowManager {
   static instance;
   mainWindow = null;
@@ -3476,6 +3757,100 @@ class WindowManager {
   }
 }
 const windowManager = WindowManager.getInstance();
+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) => {
+      console.error("[UpdateService] Error:", error.message);
+      this.sendStatus({ status: UpdateStatus.ERROR, error: error.message });
+    });
+  }
+  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");
+      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() {
@@ -3709,6 +4084,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] Injecting preset providers...");
+    const presetStartTime = Date.now();
+    await presetProviderService.initialize();
+    console.log(`[Main] Preset providers injected in ${Date.now() - presetStartTime}ms`);
     console.log("[Main] Starting task logic in background...");
     const taskStartTime = Date.now();
     await startTask();
@@ -3719,6 +4098,11 @@ async function initializeBackgroundServices() {
     if (mainWindow) {
       mainWindow.webContents.send("app:ready");
     }
+    if (app.isPackaged) {
+      updateService.checkForUpdates().catch(
+        (err) => console.error("[Main] Auto-update check failed:", err)
+      );
+    }
   } catch (error) {
     console.error("[Main] Background services initialization error:", error);
     throw error;

package/dist/preload/index.js

@@ -8,7 +8,9 @@ electron.contextBridge.exposeInMainWorld("api", {
     create: (data) => electron.ipcRenderer.invoke("provider:create", data),
     update: (id, data) => electron.ipcRenderer.invoke("provider:update", id, data),
     delete: (id) => electron.ipcRenderer.invoke("provider:delete", id),
-    updateStatus: (id, status) => electron.ipcRenderer.invoke("provider:updateStatus", id, status)
+    updateStatus: (id, status) => electron.ipcRenderer.invoke("provider:updateStatus", id, status),
+    getPresets: () => electron.ipcRenderer.invoke("provider:getPresets"),
+    fetchModelList: (providerId) => electron.ipcRenderer.invoke("provider:fetchModelList", providerId)
   },
   // ==================== Model APIs ====================
   model: {
@@ -56,6 +58,11 @@ electron.contextBridge.exposeInMainWorld("api", {
     maximize: () => electron.ipcRenderer.send("window:maximize"),
     close: () => electron.ipcRenderer.send("window:close")
   },
+  // ==================== Updater APIs ====================
+  updater: {
+    checkForUpdates: () => electron.ipcRenderer.invoke("updater:checkForUpdates"),
+    quitAndInstall: () => electron.ipcRenderer.invoke("updater:quitAndInstall")
+  },
   // ==================== Event APIs ====================
   events: {
     /**
@@ -81,6 +88,18 @@ electron.contextBridge.exposeInMainWorld("api", {
       return () => {
         electron.ipcRenderer.removeListener("taskDetail:event", handler);
       };
+    },
+    /**
+     * 监听更新状态事件
+     * @param callback 事件回调函数
+     * @returns 清理函数
+     */
+    onUpdaterStatus: (callback) => {
+      const handler = (_event, data) => callback(data);
+      electron.ipcRenderer.on("updater:status", handler);
+      return () => {
+        electron.ipcRenderer.removeListener("updater:status", handler);
+      };
     }
   },
   // ==================== Platform APIs ====================

package/dist/renderer/assets/{index-yTU2skrN.css → index-B_JfRqwM.css}

@@ -95,6 +95,60 @@ body {
   overflow: hidden !important;
 }
 
+/* Model Service Tabs 内容区域滚动 - 仅滚动时显示滚动条 */
+.model-service-tabs .ant-tabs-content-holder {
+  overflow-y: auto;
+  scrollbar-gutter: stable;
+}
+
+.model-service-tabs .ant-tabs-content-holder::-webkit-scrollbar {
+  width: 6px;
+}
+
+.model-service-tabs .ant-tabs-content-holder::-webkit-scrollbar-thumb {
+  background-color: transparent;
+  border-radius: 3px;
+}
+
+.model-service-tabs .ant-tabs-content-holder:hover::-webkit-scrollbar-thumb,
+.model-service-tabs .ant-tabs-content-holder:active::-webkit-scrollbar-thumb {
+  background-color: rgba(0, 0, 0, 0.2);
+}
+
+.model-service-tabs .ant-tabs-content-holder::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+/* Provider 状态呼吸灯 */
+.provider-status-light {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.provider-status-light--enabled {
+  background-color: #52c41a;
+  box-shadow: 0 0 6px rgba(82, 196, 26, 0.6);
+  animation: breathing-green 2s ease-in-out infinite;
+}
+
+.provider-status-light--disabled {
+  background-color: #bfbfbf;
+}
+
+@keyframes breathing-green {
+  0%, 100% {
+    box-shadow: 0 0 4px rgba(82, 196, 26, 0.4);
+    opacity: 1;
+  }
+  50% {
+    box-shadow: 0 0 10px rgba(82, 196, 26, 0.8);
+    opacity: 0.8;
+  }
+}
+
 /* Markdown 预览面板滚动 */
 .ant-splitter-panel:last-child {
   overflow: auto !important;