@e-xi/xion 0.0.6

package/dist/chunk-files/chunk-4SSGMLEE.js

@@ -0,0 +1,934 @@
+import {
+  IpcResult
+} from "./chunk-W2I3I7U7.js";
+import {
+  XoPathUtil
+} from "./chunk-BPTFUGTP.js";
+import {
+  MainWindowIdentity
+} from "./chunk-KFV4GXVE.js";
+import {
+  AppChannels,
+  ClipboardChannels,
+  DialogChannels,
+  FileChannels,
+  LogChannels,
+  ShellChannels
+} from "./chunk-RAVPJRBA.js";
+import {
+  UpdaterChannels
+} from "./chunk-LQ67F6EY.js";
+import {
+  ContextMenuChannels,
+  WindowChannels
+} from "./chunk-BFD2LHLK.js";
+import {
+  SettingWindowIdentity
+} from "./chunk-PVWRRUOK.js";
+import {
+  LogUtil
+} from "./chunk-BMOLIJ3W.js";
+import {
+  RemoteServiceChannels
+} from "./chunk-RN7AI33H.js";
+import {
+  isLogLevel
+} from "./chunk-WKVLVI6N.js";
+import {
+  AppLaunchMode,
+  WindowCloseBehavior,
+  WindowMaterials
+} from "./chunk-Y3OEXVQ2.js";
+import {
+  ThemeChannels
+} from "./chunk-UIJUY7QZ.js";
+import {
+  AuthChannels
+} from "./chunk-T3QCAOCO.js";
+import {
+  ProtocolUtil
+} from "./chunk-KFK47PDH.js";
+import {
+  AppMode
+} from "./chunk-GN2FNR3Z.js";
+
+// src/main/ipc/ipc-handlers-abstract.ts
+var IpcHandlersAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+};
+
+// src/main/ipc/handlers/app-handlers.ts
+import { app } from "electron";
+var AppHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 获取应用信息 */
+      [AppChannels.getInfo]: async () => {
+        const protocols = ProtocolUtil.getRuntimeProtocols(this.xoApp.getAppConfig()?.eletronAppConfig?.protocols);
+        const info = {
+          appId: this.xoApp.getAppConfig()?.eletronAppConfig?.appId,
+          name: this.xoApp.getAppConfig()?.eletronAppConfig?.productName,
+          version: app.getVersion(),
+          mode: AppMode.getMode(),
+          platform: process.platform,
+          isPackaged: app.isPackaged,
+          protocol: protocols[0] ?? void 0,
+          protocols,
+          rendererProtocol: this.xoApp.getAppConfig()?.eletronAppConfig?.rendererProtocol,
+          locale: app.getLocale()
+        };
+        return IpcResult.success(info);
+      },
+      /** 获取应用目录 */
+      [AppChannels.getPaths]: async () => {
+        const paths = {
+          userData: XoPathUtil.userData(),
+          sessionData: XoPathUtil.sessionData(),
+          logs: XoPathUtil.logs(),
+          crashDumps: XoPathUtil.crashDumps(),
+          temp: XoPathUtil.temp(),
+          updaterCacheDir: XoPathUtil.updaterCacheDir()
+        };
+        return IpcResult.success(paths);
+      },
+      /** 获取通用设置 */
+      [AppChannels.getGeneralSettings]: async () => {
+        const store = this.xoApp.getAppStore();
+        const settings = {
+          opacity: store.getOpacity(),
+          windowMaterial: store.getWindowMaterial() ?? "none",
+          shortcuts: store.getShortcuts(),
+          logLevel: store.getLogLevel(),
+          launchOnStartup: store.getLaunchOnStartup(),
+          appLaunchMode: store.getAppLaunchMode(),
+          windowCloseBehavior: store.getWindowCloseBehavior()
+        };
+        return IpcResult.success(settings);
+      },
+      /** 获取 APP 透明度 */
+      [AppChannels.getOpacity]: async () => {
+        return IpcResult.success(this.xoApp.getAppStore().getOpacity());
+      },
+      /** 设置 APP 透明度 */
+      [AppChannels.setOpacity]: async (_event, opacity) => {
+        const nextOpacity = opacity === void 0 || !Number.isFinite(opacity) ? 1 : Math.max(0, Math.min(1, opacity / 100));
+        this.xoApp.getAppStore().setOpacity(nextOpacity);
+        this.xoApp.getWindowManager().setAllWindowOpacity(nextOpacity);
+        return IpcResult.success();
+      },
+      /** 获取快捷窗口材质 */
+      [AppChannels.getWindowMaterial]: async () => {
+        return IpcResult.success(this.xoApp.getAppStore().getWindowMaterial() ?? this.xoApp.getAppConfig()?.windowMaterial);
+      },
+      /** 设置快捷窗口材质 */
+      [AppChannels.setWindowMaterial]: async (_event, windowMaterial) => {
+        const nextWindowMaterial = windowMaterial && WindowMaterials.includes(windowMaterial) ? windowMaterial : void 0;
+        this.xoApp.getAppStore().setWindowMaterial(nextWindowMaterial);
+        this.xoApp.getWindowManager().setAllWindowMaterial(nextWindowMaterial);
+        return IpcResult.success();
+      },
+      /** 获取应用启动模式 */
+      [AppChannels.getAppLaunchMode]: async () => {
+        return IpcResult.success(this.xoApp.getAppStore().getAppLaunchMode());
+      },
+      /** 设置应用启动模式 */
+      [AppChannels.setAppLaunchMode]: async (_event, appLaunchMode) => {
+        const launchMode = appLaunchMode && AppLaunchMode.includes(appLaunchMode) ? appLaunchMode : "window";
+        this.xoApp.getAppStore().setAppLaunchMode(launchMode);
+        return IpcResult.success();
+      },
+      /** 获取是否开机启动 */
+      [AppChannels.getLaunchOnStartup]: async () => {
+        return IpcResult.success(this.xoApp.getAppStore().getLaunchOnStartup());
+      },
+      /** 设置是否开机启动 */
+      [AppChannels.setLaunchOnStartup]: async (_event, launchOnStartup) => {
+        const openAtLogin = launchOnStartup === true;
+        this.xoApp.getAppStore().setLaunchOnStartup(openAtLogin);
+        app.setLoginItemSettings({ openAtLogin });
+        return IpcResult.success();
+      },
+      /** 获取关闭窗口行为 */
+      [AppChannels.getWindowCloseBehavior]: async () => {
+        return IpcResult.success(this.xoApp.getAppStore().getWindowCloseBehavior());
+      },
+      /** 设置关闭窗口行为 */
+      [AppChannels.setWindowCloseBehavior]: async (_event, windowCloseBehavior) => {
+        const behavior = windowCloseBehavior && WindowCloseBehavior.includes(windowCloseBehavior) ? windowCloseBehavior : "minimize";
+        this.xoApp.getAppStore().setWindowCloseBehavior(behavior);
+        return IpcResult.success();
+      },
+      /** 获取日志等级 */
+      [AppChannels.getLogLevel]: async () => {
+        return IpcResult.success(this.xoApp.getLogLevel());
+      },
+      /** 设置日志等级 */
+      [AppChannels.setLogLevel]: async (_event, logLevel) => {
+        if (isLogLevel(logLevel)) {
+          this.xoApp.setLogLevel(logLevel);
+        }
+        return IpcResult.success();
+      },
+      /** 获取快捷键配置 */
+      [AppChannels.getShortcuts]: async () => {
+        return IpcResult.success(this.xoApp.getShortcutManager().getStoreShortcuts());
+      },
+      /** 设置快捷键配置 */
+      [AppChannels.setShortcuts]: async (_event, shortcuts = {}) => {
+        this.xoApp.getShortcutManager().setShortcuts(shortcuts);
+        return IpcResult.success();
+      },
+      /** 设置单个快捷键配置 */
+      [AppChannels.setShortcut]: async (_event, shortcut) => {
+        this.xoApp.getShortcutManager().setShortcut(shortcut);
+        return IpcResult.success();
+      },
+      /** 删除快捷键配置 */
+      [AppChannels.deleteShortcut]: async (_event, id) => {
+        this.xoApp.getShortcutManager().deleteShortcut(id);
+        return IpcResult.success();
+      },
+      /** 重定向指定窗口路由 */
+      [AppChannels.redirectWindowRoute]: async (_event, request) => {
+        return IpcResult.success(await this.xoApp.getWindowManager().redirectRoute(request));
+      },
+      /** 重定向主窗口路由 */
+      [AppChannels.redirectMainWindowRoute]: async (_event, request) => {
+        return IpcResult.success(await this.xoApp.getWindowManager().redirectRoute({
+          ...request,
+          windowIdentity: MainWindowIdentity
+        }));
+      },
+      /** 重定向设置窗口路由 */
+      [AppChannels.redirectSettingWindowRoute]: async (_event, request) => {
+        return IpcResult.success(await this.xoApp.getWindowManager().redirectRoute({
+          ...request,
+          windowIdentity: SettingWindowIdentity
+        }));
+      },
+      /** 显示主窗口 */
+      [AppChannels.showMainWindow]: async (_event, request) => {
+        await this.xoApp.showMainWindow();
+        if (request?.route || request?.routeName) {
+          await this.xoApp.getWindowManager().redirectRoute({
+            ...request,
+            windowIdentity: MainWindowIdentity
+          });
+        }
+        return IpcResult.success(true);
+      },
+      /** 显示设置窗口 */
+      [AppChannels.showSettingWindow]: async (_event, request) => {
+        await this.xoApp.showSettingWindow();
+        if (request?.route || request?.routeName) {
+          await this.xoApp.getWindowManager().redirectRoute({
+            ...request,
+            windowIdentity: SettingWindowIdentity
+          });
+        }
+        return IpcResult.success(true);
+      },
+      /** 重启应用 */
+      [AppChannels.restart]: async () => {
+        setImmediate(() => this.xoApp.restart());
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/auth-handlers.ts
+var AuthHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      /** 获取认证状态 */
+      [AuthChannels.getState]: async () => {
+        return IpcResult.success(this.xoApp.getAuthManager().getState());
+      },
+      /** 登录 */
+      [AuthChannels.login]: async (_event, request) => {
+        return IpcResult.success(await this.xoApp.getAuthManager().login(request));
+      },
+      /** 退出登录 */
+      [AuthChannels.logout]: async () => {
+        return IpcResult.success(await this.xoApp.getAuthManager().logout());
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/clipboard-handlers.ts
+import { clipboard, nativeImage } from "electron";
+var ClipboardHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 读取文本 */
+      [ClipboardChannels.readText]: async () => {
+        return IpcResult.success(clipboard.readText());
+      },
+      /** 写入文本 */
+      [ClipboardChannels.writeText]: async (_event, text) => {
+        clipboard.writeText(text);
+        return IpcResult.success();
+      },
+      /** 写入图片 */
+      [ClipboardChannels.writeImage]: async (_event, dataURL) => {
+        clipboard.writeImage(nativeImage.createFromDataURL(dataURL));
+        return IpcResult.success();
+      },
+      /** 清空剪切板 */
+      [ClipboardChannels.clear]: async () => {
+        clipboard.clear();
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/contex-menu-handlers.ts
+var ContexMenuHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 执行菜单命令 */
+      [ContextMenuChannels.executeCommand]: async (_event, request) => {
+        const success = await this.xoApp.getMenuManager().executeCommand(request);
+        return IpcResult.success(success);
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/dialog-handlers.ts
+import { BrowserWindow, dialog } from "electron";
+var DialogHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 打开文件 */
+      [DialogChannels.openFile]: async (event) => {
+        const window = BrowserWindow.fromWebContents(event.sender);
+        const options = {
+          properties: ["openFile"]
+        };
+        const result = window ? await dialog.showOpenDialog(window, options) : await dialog.showOpenDialog(options);
+        return IpcResult.success({
+          canceled: result.canceled,
+          filePaths: result.filePaths
+        });
+      },
+      /** 打开目录 */
+      [DialogChannels.openDir]: async (event) => {
+        const window = BrowserWindow.fromWebContents(event.sender);
+        const options = {
+          properties: ["openDirectory"]
+        };
+        const result = window ? await dialog.showOpenDialog(window, options) : await dialog.showOpenDialog(options);
+        return IpcResult.success({
+          canceled: result.canceled,
+          filePaths: result.filePaths
+        });
+      },
+      /** 保存文件 */
+      [DialogChannels.saveFile]: async (event) => {
+        const window = BrowserWindow.fromWebContents(event.sender);
+        const options = {};
+        const result = window ? await dialog.showSaveDialog(window, options) : await dialog.showSaveDialog(options);
+        return IpcResult.success({
+          canceled: result.canceled,
+          filePath: result.filePath ?? null
+        });
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/file-handlers.ts
+import fs from "node:fs/promises";
+var FileHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 读取文本 */
+      [FileChannels.readText]: async (_event, path) => {
+        let text = await fs.readFile(path, "utf8");
+        return IpcResult.success(text);
+      },
+      /** 写入文本 */
+      [FileChannels.writeText]: async (_event, request) => {
+        await fs.writeFile(request.path, request.content, "utf8");
+        return IpcResult.success(true);
+      },
+      /** 文件是否存在 */
+      [FileChannels.exists]: async (_event, path) => {
+        try {
+          await fs.access(path);
+          return IpcResult.success(true);
+        } catch (error) {
+          const code = error instanceof Error ? error.code : void 0;
+          if (code === "ENOENT" || code === "ENOTDIR") {
+            return IpcResult.success(false);
+          }
+          throw error;
+        }
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/log-handlers.ts
+import { BrowserWindow as BrowserWindow2 } from "electron";
+var MaxLogsPerSecond = 20;
+var MaxRequestBytes = 64 * 1024;
+var LogHandlers = class extends IpcHandlersAbstract {
+  /** 每个渲染进程的日志限流记录 */
+  rateLimits = /* @__PURE__ */ new Map();
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      [LogChannels.debug]: async (event, request) => this.write(event, "debug", request),
+      [LogChannels.info]: async (event, request) => this.write(event, "info", request),
+      [LogChannels.warn]: async (event, request) => this.write(event, "warn", request),
+      [LogChannels.error]: async (event, request) => this.write(event, "error", request)
+    };
+  }
+  /**
+   * 写入渲染进程日志
+   * @param {Electron.IpcMainInvokeEvent} event   IPC 事件
+   * @param {XoIpcLogger.Level}           level   日志等级
+   * @param {XoIpcLogger.Request}         request 日志请求
+   * @returns {Promise<XoIpc.Result>}
+   * @private
+   */
+  async write(event, level, request) {
+    if (!this.isAllowedSender(event)) {
+      return IpcResult.fail("\u4E0D\u5141\u8BB8\u7684\u65E5\u5FD7\u8C03\u7528\u6765\u6E90");
+    }
+    if (!this.consumeRateLimit(event.sender.id)) {
+      return IpcResult.fail("\u6E32\u67D3\u8FDB\u7A0B\u65E5\u5FD7\u5199\u5165\u8FC7\u4E8E\u9891\u7E41");
+    }
+    if (!request || typeof request.message !== "string" || !Array.isArray(request.data) || !this.isAllowedRequestSize(request)) {
+      return IpcResult.fail("\u6E32\u67D3\u8FDB\u7A0B\u65E5\u5FD7\u53C2\u6570\u65E0\u6548");
+    }
+    const normalized = LogUtil.normalizeRequest(request.message, request.data);
+    switch (level) {
+      case "debug":
+        this.xoApp.rendererLog.debug(normalized.message, ...normalized.data);
+        break;
+      case "info":
+        this.xoApp.rendererLog.info(normalized.message, ...normalized.data);
+        break;
+      case "warn":
+        this.xoApp.rendererLog.warn(normalized.message, ...normalized.data);
+        break;
+      case "error":
+        this.xoApp.rendererLog.error(normalized.message, ...normalized.data);
+        break;
+    }
+    return IpcResult.success();
+  }
+  /**
+   * 验证 IPC 来源为受管理窗口的主 frame
+   * @param {Electron.IpcMainInvokeEvent} event IPC 事件
+   * @returns {boolean}
+   * @private
+   */
+  isAllowedSender(event) {
+    const window = BrowserWindow2.fromWebContents(event.sender);
+    return Boolean(window && !window.isDestroyed() && event.senderFrame === event.sender.mainFrame);
+  }
+  /**
+   * 检查日志请求序列化大小
+   * @param {XoIpcLogger.Request} request 日志请求
+   * @returns {boolean}
+   * @private
+   */
+  isAllowedRequestSize(request) {
+    try {
+      return Buffer.byteLength(JSON.stringify(request), "utf8") <= MaxRequestBytes;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 消耗一次日志限流额度
+   * @param {number} senderId WebContents ID
+   * @returns {boolean}
+   * @private
+   */
+  consumeRateLimit(senderId) {
+    const now = Date.now();
+    const current = this.rateLimits.get(senderId);
+    if (!current || now - current.startedAt >= 1e3) {
+      this.rateLimits.set(senderId, { startedAt: now, count: 1 });
+      return true;
+    }
+    if (current.count >= MaxLogsPerSecond) {
+      return false;
+    }
+    current.count++;
+    return true;
+  }
+};
+
+// src/main/ipc/handlers/remote-service-handlers.ts
+var RemoteServiceHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 获取远程服务状态 */
+      [RemoteServiceChannels.getState]: async () => {
+        return IpcResult.success(this.xoApp.getRemoteServiceManager().getState());
+      },
+      /** 获取远程服务设置 */
+      [RemoteServiceChannels.getSettings]: async () => {
+        return IpcResult.success(this.xoApp.getRemoteServiceManager().getEffectiveSettings());
+      },
+      /** 设置远程服务用户设置 */
+      [RemoteServiceChannels.setSettings]: async (_event, settings) => {
+        this.xoApp.getRemoteServiceManager().setSettings(settings);
+        return IpcResult.success();
+      },
+      /** 重置远程服务用户设置 */
+      [RemoteServiceChannels.resetSettings]: async () => {
+        this.xoApp.getRemoteServiceManager().resetSettings();
+        return IpcResult.success();
+      },
+      /** 请求远程服务 API */
+      [RemoteServiceChannels.request]: async (event, request) => {
+        const response = await this.xoApp.getRemoteServiceManager().request(request, event.sender.session);
+        return IpcResult.success(response);
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/shell-handlers.ts
+import { shell } from "electron";
+import { access } from "node:fs/promises";
+var ShellHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 使用系统默认程序打开路径 */
+      [ShellChannels.openPath]: async (_event, path) => {
+        try {
+          await access(path);
+        } catch {
+          throw new Error(`\u8DEF\u5F84\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u8BBF\u95EE`);
+        }
+        const error = await shell.openPath(path);
+        if (error) {
+          throw new Error(error);
+        }
+        return IpcResult.success();
+      },
+      /** 在文件管理器中显示路径 */
+      [ShellChannels.showItemInFolder]: async (_event, path) => {
+        shell.showItemInFolder(path);
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/theme-handlers.ts
+import { BrowserWindow as BrowserWindow3 } from "electron";
+var ThemeHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 获取主题状态 */
+      [ThemeChannels.getState]: async (event) => {
+        const window = BrowserWindow3.fromWebContents(event.sender) ?? void 0;
+        const state = this.xoApp.getThemeManager().getState(window);
+        return IpcResult.success(state);
+      },
+      /** 设置主题来源 */
+      [ThemeChannels.setSource]: async (_event, source) => {
+        this.xoApp.getThemeManager().setSource(source ?? "system");
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/updater-handlers.ts
+var UpdaterHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 检查更新 */
+      [UpdaterChannels.checkForUpdates]: async () => {
+        await this.xoApp.getUpdaterManager().checkForUpdates();
+        return IpcResult.success();
+      },
+      /** 下载更新 */
+      [UpdaterChannels.downloadUpdate]: async () => {
+        await this.xoApp.getUpdaterManager().downloadUpdate();
+        return IpcResult.success();
+      },
+      /** 取消下载 */
+      [UpdaterChannels.cancelDownload]: async () => {
+        return IpcResult.success(this.xoApp.getUpdaterManager().cancelDownload());
+      },
+      /** 退出并安装更新 */
+      [UpdaterChannels.quitAndInstall]: async () => {
+        this.xoApp.getUpdaterManager().quitAndInstall();
+        return IpcResult.success();
+      },
+      /** 获取更新器状态 */
+      [UpdaterChannels.getState]: async () => {
+        return IpcResult.success(this.xoApp.getUpdaterManager().getState());
+      },
+      /** 获取更新器设置 */
+      [UpdaterChannels.getSettings]: async () => {
+        return IpcResult.success(this.xoApp.getUpdaterManager().getSettings());
+      },
+      /** 设置更新器用户设置 */
+      [UpdaterChannels.setSettings]: async (_event, settings) => {
+        this.xoApp.getUpdaterManager().setSettings(settings);
+        return IpcResult.success();
+      },
+      /** 重置更新器用户设置 */
+      [UpdaterChannels.resetSettings]: async () => {
+        this.xoApp.getUpdaterManager().resetSettings();
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/handlers/window-handlers.ts
+import { BrowserWindow as BrowserWindow4 } from "electron";
+var WindowHandlers = class extends IpcHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoIpc.HandlerMap}
+   * @constructor
+   */
+  handlerMap() {
+    return {
+      /** 渲染进程首屏渲染完成 */
+      [WindowChannels.ready]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        if (window) {
+          this.xoApp.getWindowManager().rendererReady(window);
+        }
+        return IpcResult.success();
+      },
+      /** 是否等待 Renderer 渲染完成后再显示窗口 */
+      [WindowChannels.shouldShowAfterRendererReady]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        return IpcResult.success(this.xoApp.getWindowManager().shouldShowAfterRendererReady(window ?? void 0));
+      },
+      /** 获取窗口状态 */
+      [WindowChannels.getState]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        return IpcResult.success(this.xoApp.getWindowManager().getWindowState(window));
+      },
+      /** 获取当前已打开窗口标识 */
+      [WindowChannels.getOpenedWindowIdentities]: async () => {
+        return IpcResult.success(this.xoApp.getWindowManager().getOpenedWindowIdentities());
+      },
+      /** 最小化窗口 */
+      [WindowChannels.minimize]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.minimize();
+        return IpcResult.success();
+      },
+      /** 最大化窗口 */
+      [WindowChannels.maximize]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.maximize();
+        return IpcResult.success();
+      },
+      /** 是否已最大化 */
+      [WindowChannels.isMaximized]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        return IpcResult.success(window?.isMaximized() ?? false);
+      },
+      /** 取消最大化窗口 */
+      [WindowChannels.unmaximize]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.unmaximize();
+        return IpcResult.success();
+      },
+      /** 全屏窗口 */
+      [WindowChannels.fullScreen]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.setFullScreen(true);
+        return IpcResult.success();
+      },
+      /** 退出全屏窗口 */
+      [WindowChannels.exitFullScreen]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.setFullScreen(false);
+        return IpcResult.success();
+      },
+      /** 重新加载窗口 */
+      [WindowChannels.reload]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.reload();
+        return IpcResult.success();
+      },
+      /** 居中窗口 */
+      [WindowChannels.center]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.center();
+        return IpcResult.success();
+      },
+      /** 隐藏窗口 */
+      [WindowChannels.hide]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window && this.xoApp.getWindowManager().hideByWindow(window);
+        return IpcResult.success();
+      },
+      /** 还原窗口 */
+      [WindowChannels.restore]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window?.restore();
+        return IpcResult.success();
+      },
+      /** 切换窗口置顶 */
+      [WindowChannels.toggleAlwaysOnTop]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window && this.xoApp.getWindowManager().toggleAlwaysOnTopByWindow(window);
+        return IpcResult.success();
+      },
+      /** 切换侧边栏折叠 */
+      [WindowChannels.toggleSidebarFold]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window && this.xoApp.getWindowManager().toggleSidebarFoldByWindow(window);
+        return IpcResult.success(true);
+      },
+      /** 关闭窗口 */
+      [WindowChannels.close]: async (event) => {
+        const window = BrowserWindow4.fromWebContents(event.sender);
+        window && this.xoApp.getWindowManager().closeByWindow(window);
+        return IpcResult.success();
+      }
+    };
+  }
+};
+
+// src/main/ipc/utils/ipc-handler-util.ts
+var IpcHandlerUtil = class _IpcHandlerUtil {
+  /**
+   * 包装IPC处理器
+   * @param {XoIpc.Handler} handler 原始处理器
+   * @returns {XoIpc.Handler}
+   */
+  static wrap(handler) {
+    return async (event, request) => {
+      try {
+        const result = await handler(event, request);
+        return _IpcHandlerUtil.isResult(result) ? result : IpcResult.success(result);
+      } catch (error) {
+        return IpcResult.fail(_IpcHandlerUtil.toMessage(error));
+      }
+    };
+  }
+  /**
+   * 判断是否为IPC结果
+   * @param {unknown} value 值
+   * @returns {value is XoIpc.Result}
+   */
+  static isResult(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const result = value;
+    return typeof result.success === "boolean" && typeof result.code === "number" && typeof result.message === "string";
+  }
+  /**
+   * 转换错误消息
+   * @param {unknown} error 错误
+   * @returns {string}
+   */
+  static toMessage(error) {
+    if (error instanceof Error) {
+      return error.message || error.name;
+    }
+    return String(error);
+  }
+};
+
+// src/main/ipc/ipc-manager-abstract.ts
+import { ipcMain } from "electron";
+var IpcManagerAbstract = class {
+  /**
+   * 是否已注册
+   * @type {boolean}
+   * @private
+   */
+  registered = false;
+  /**
+   * 已注册处理器类
+   * @type {Set<XoIpc.HandlersConstructor>}
+   * @private
+   */
+  registeredHandlerClasses = /* @__PURE__ */ new Set();
+  /**
+   * 已注册通道
+   * @type {Set<XoIpc.Channel>}
+   * @private
+   */
+  registeredChannels = /* @__PURE__ */ new Set();
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 注册所有处理器
+   */
+  register() {
+    if (this.registered) {
+      return;
+    }
+    this.registered = true;
+    const handlerClasses = [
+      // 内置应用处理器
+      AppHandlers,
+      // 内置 JWT 认证处理器
+      AuthHandlers,
+      // 内置对话框处理器
+      DialogHandlers,
+      // 内置剪切板处理器
+      ClipboardHandlers,
+      // 内置文件处理器
+      FileHandlers,
+      // 内置渲染进程日志处理器
+      LogHandlers,
+      // 内置主题处理器
+      ThemeHandlers,
+      // 内置更新器处理器
+      UpdaterHandlers,
+      // 内置远程服务处理器
+      RemoteServiceHandlers,
+      // 内置菜单处理器
+      ContexMenuHandlers,
+      // 内置 Shell 处理器
+      ShellHandlers,
+      // 内置窗口处理器
+      WindowHandlers,
+      // 自定义处理器
+      ...this.handlers()
+    ];
+    for (const HandlerClass of handlerClasses) {
+      if (this.registeredHandlerClasses.has(HandlerClass)) {
+        throw new Error(`IPC \u5904\u7406\u5668\u91CD\u590D\u6CE8\u518C: ${HandlerClass.name}`);
+      }
+      this.registeredHandlerClasses.add(HandlerClass);
+      const handlerMap = new HandlerClass(this.xoApp).handlerMap();
+      for (const [channel, handler] of Object.entries(handlerMap)) {
+        if (!handler) {
+          continue;
+        }
+        if (this.registeredChannels.has(channel)) {
+          throw new Error(`IPC \u901A\u9053\u91CD\u590D\u6CE8\u518C: ${channel}`);
+        }
+        this.registeredChannels.add(channel);
+        ipcMain.handle(channel, IpcHandlerUtil.wrap(handler));
+      }
+    }
+  }
+};
+
+// src/main/ipc/ipc-manager.ts
+var IpcManager = class extends IpcManagerAbstract {
+  /**
+   * 处理器列表
+   * @returns {XoIpc.HandlersConstructor[]}
+   * @protected
+   */
+  handlers() {
+    return [];
+  }
+};
+
+export {
+  IpcHandlersAbstract,
+  AppHandlers,
+  AuthHandlers,
+  ClipboardHandlers,
+  ContexMenuHandlers,
+  DialogHandlers,
+  FileHandlers,
+  LogHandlers,
+  RemoteServiceHandlers,
+  ShellHandlers,
+  ThemeHandlers,
+  UpdaterHandlers,
+  WindowHandlers,
+  IpcHandlerUtil,
+  IpcManagerAbstract,
+  IpcManager
+};