@e-xi/xion 0.0.6

package/dist/chunk-files/chunk-UCMR6V67.js

@@ -0,0 +1,746 @@
+import {
+  RendererProtocolKeys
+} from "./chunk-WOJ2UKI7.js";
+import {
+  AppMode,
+  RuntimeConfigUtil
+} from "./chunk-GN2FNR3Z.js";
+
+// src/main/renderer-protocol/renderer-protocol-handlers-abstract.ts
+var RendererProtocolHandlersAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+};
+
+// src/main/renderer-protocol/handlers/renderer-remote-service-protocol-handlers.ts
+var refuseRequestHeaders = /* @__PURE__ */ new Set([
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "authorization",
+  "connection",
+  "content-length",
+  "cookie",
+  "forwarded",
+  "host",
+  "keep-alive",
+  "origin",
+  "proxy-authorization",
+  "proxy-connection",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-port",
+  "x-forwarded-proto",
+  "x-real-ip",
+  "x-refresh-token",
+  "x-device-id"
+]);
+var ignoredResponseHeaders = /* @__PURE__ */ new Set([
+  "authorization",
+  "clear-site-data",
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "set-cookie",
+  "set-cookie2",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var exposedResponseHeaders = [
+  "Accept-Ranges",
+  "Content-Disposition",
+  "Content-Length",
+  "Content-Range",
+  "Cache-Control",
+  "Content-Type",
+  "ETag",
+  "Expires",
+  "Last-Modified",
+  "Retry-After",
+  "X-Request-ID",
+  "X-Trace-ID",
+  "X-RateLimit-Limit",
+  "X-RateLimit-Remaining",
+  "X-RateLimit-Reset"
+];
+var allowedMethods = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS"
+]);
+var RendererRemoteServiceProtocolHandlers = class extends RendererProtocolHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoRendererProtocol.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      /** 代理远程服务请求 */
+      [RendererProtocolKeys.remoteService]: this.handleRemoteService.bind(this)
+    };
+  }
+  /**
+   * 代理远程服务请求
+   * @param {XoRendererProtocol.Context} context 协议处理上下文
+   * @returns {Promise<Response>}
+   * @private
+   */
+  async handleRemoteService(context) {
+    const requestOrigin = context.request.headers.get("Origin");
+    const allowedOrigin = this.resolveAllowedOrigin(requestOrigin);
+    if (requestOrigin && !allowedOrigin) {
+      return this.response(403, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u62D2\u7EDD\u5F53\u524D\u8BF7\u6C42\u6765\u6E90");
+    }
+    const method = context.request.method.toUpperCase();
+    if (!allowedMethods.has(method)) {
+      const headers2 = this.corsHeaders(allowedOrigin);
+      headers2.set("Allow", [...allowedMethods].join(", "));
+      return this.response(405, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u4E0D\u652F\u6301\u5F53\u524D\u8BF7\u6C42\u65B9\u6CD5", headers2);
+    }
+    if (method === "OPTIONS") {
+      return this.preflightResponse(context.request, allowedOrigin);
+    }
+    const settings = this.xoApp.getRemoteServiceManager().getEffectiveSettings();
+    if (!settings.enabled || !settings.serviceUrl) {
+      return this.response(503, "\u8FDC\u7A0B\u670D\u52A1\u672A\u542F\u7528\u6216\u672A\u914D\u7F6E\u670D\u52A1\u5730\u5740", this.corsHeaders(allowedOrigin));
+    }
+    const targetUrl = this.resolveTargetUrl(settings.serviceUrl, context.url);
+    if (!targetUrl) {
+      return this.response(503, "\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\u65E0\u6548", this.corsHeaders(allowedOrigin));
+    }
+    const headers = this.requestHeaders(context.request.headers);
+    for (const [name, value] of Object.entries(this.xoApp.getAuthManager().getDeviceIdHeaders() ?? {})) {
+      headers.set(name, value);
+    }
+    this.forceUserAgent(headers, context.session);
+    try {
+      const requestInit = {
+        method,
+        headers,
+        body: this.hasRequestBody(method) ? context.request.body : void 0,
+        credentials: settings.requestCredentials,
+        redirect: settings.requestRedirect,
+        signal: context.request.signal
+      };
+      if (requestInit.body) {
+        requestInit.duplex = "half";
+      }
+      const upstream = await context.session.fetch(targetUrl.toString(), requestInit);
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: this.responseHeaders(upstream.headers, allowedOrigin)
+      });
+    } catch (error) {
+      await this.xoApp.dispatchAppError({ source: "RendererRemoteServiceProtocolHandler", error });
+      return this.response(502, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u8BF7\u6C42\u5931\u8D25", this.corsHeaders(allowedOrigin));
+    }
+  }
+  /**
+   * 创建 CORS 预检响应
+   * @param {Request} request       原始请求
+   * @param {string}  allowedOrigin 已允许的请求来源
+   * @returns {Response}
+   * @private
+   */
+  preflightResponse(request, allowedOrigin) {
+    if (!allowedOrigin) {
+      return this.response(403, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u62D2\u7EDD\u5F53\u524D\u9884\u68C0\u8BF7\u6C42");
+    }
+    const requestedMethod = request.headers.get("Access-Control-Request-Method")?.toUpperCase();
+    if (requestedMethod && !allowedMethods.has(requestedMethod)) {
+      return this.response(405, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u4E0D\u652F\u6301\u9884\u68C0\u8BF7\u6C42\u65B9\u6CD5", this.corsHeaders(allowedOrigin));
+    }
+    const requestedHeaders = request.headers.get("Access-Control-Request-Headers")?.split(",").map((name) => name.trim().toLowerCase()).filter(Boolean) ?? [];
+    const refusedHeaderNames = this.refusedRequestHeaderNames();
+    if (requestedHeaders.some((name) => this.isRefusedRequestHeader(name, refusedHeaderNames))) {
+      return this.response(403, "\u8FDC\u7A0B\u670D\u52A1\u4EE3\u7406\u62D2\u7EDD\u5F53\u524D\u9884\u68C0\u8BF7\u6C42\u5934", this.corsHeaders(allowedOrigin));
+    }
+    const headers = this.corsHeaders(allowedOrigin);
+    headers.set("Access-Control-Allow-Methods", [...allowedMethods].join(", "));
+    headers.set(
+      "Access-Control-Allow-Headers",
+      requestedHeaders.length > 0 ? requestedHeaders.join(", ") : "Accept, Content-Type, Range"
+    );
+    headers.set("Access-Control-Max-Age", "600");
+    return new Response(null, { status: 204, headers });
+  }
+  /**
+   * 将协议请求地址映射到远程服务地址
+   * @param {string} serviceUrl 远程服务基础地址
+   * @param {URL}    requestUrl 协议请求地址
+   * @returns {URL | undefined}
+   * @private
+   */
+  resolveTargetUrl(serviceUrl, requestUrl) {
+    try {
+      const baseUrl = new URL(serviceUrl);
+      if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+        return void 0;
+      }
+      baseUrl.hash = "";
+      baseUrl.search = "";
+      baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, "")}/`;
+      const relativePath = requestUrl.pathname.replace(/^[/\\]+/, "");
+      const targetUrl = new URL(relativePath, baseUrl);
+      targetUrl.search = requestUrl.search;
+      if (targetUrl.origin !== baseUrl.origin || !targetUrl.pathname.startsWith(baseUrl.pathname)) {
+        return void 0;
+      }
+      return targetUrl;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 创建远程服务请求头
+   * @param {Headers} source 原始请求头
+   * @returns {Headers}
+   * @private
+   */
+  requestHeaders(source) {
+    const headers = new Headers(source);
+    const connectionHeaderNames = this.connectionHeaderNames(source);
+    const refusedHeaderNames = this.refusedRequestHeaderNames();
+    for (const name of [...headers.keys()]) {
+      if (connectionHeaderNames.has(name) || this.isRefusedRequestHeader(name, refusedHeaderNames)) {
+        headers.delete(name);
+      }
+    }
+    return headers;
+  }
+  /**
+   * 创建返回渲染进程的响应头
+   * @param {Headers} source        远程服务响应头
+   * @param {string}  allowedOrigin 已允许的请求来源
+   * @returns {Headers}
+   * @private
+   */
+  responseHeaders(source, allowedOrigin) {
+    const headers = new Headers(source);
+    const connectionHeaderNames = this.connectionHeaderNames(source);
+    const ignoredHeaderNames = /* @__PURE__ */ new Set([
+      ...ignoredResponseHeaders,
+      ...this.xoApp.getAuthManager().getAuthenticationHeaderNames()
+    ]);
+    for (const name of [...headers.keys()]) {
+      if (connectionHeaderNames.has(name) || ignoredHeaderNames.has(name) || name.startsWith("access-control-")) {
+        headers.delete(name);
+      }
+    }
+    if (headers.has("content-encoding")) {
+      headers.delete("content-encoding");
+      headers.delete("content-length");
+    }
+    headers.set("Cross-Origin-Resource-Policy", "cross-origin");
+    this.applyCorsHeaders(headers, allowedOrigin);
+    return headers;
+  }
+  /**
+   * 获取不允许渲染进程传入的请求头名称
+   * @returns {Set<string>}
+   * @private
+   */
+  refusedRequestHeaderNames() {
+    return /* @__PURE__ */ new Set([
+      ...refuseRequestHeaders,
+      ...this.xoApp.getAuthManager().getAuthenticationHeaderNames()
+    ]);
+  }
+  /**
+   * 判断是否拒绝渲染进程传入指定请求头
+   * @param {string}      name               请求头名称
+   * @param {Set<string>} refusedHeaderNames 拒绝的请求头名称
+   * @returns {boolean}
+   * @private
+   */
+  isRefusedRequestHeader(name, refusedHeaderNames) {
+    const normalizedName = name.trim().toLowerCase();
+    return refusedHeaderNames.has(normalizedName) || normalizedName.startsWith("proxy-") || normalizedName.startsWith("sec-");
+  }
+  /**
+   * 强制设置 User-Agent 为当前 Session 的 User-Agent
+   * @param {Headers}          headers       请求头
+   * @param {Electron.Session} targetSession 目标 Session
+   * @private
+   */
+  forceUserAgent(headers, targetSession) {
+    headers.set("user-agent", targetSession.getUserAgent());
+  }
+  /**
+   * 获取 Connection 请求头声明的逐跳头名称
+   * @param {Headers} source 请求头或响应头
+   * @returns {Set<string>}
+   * @private
+   */
+  connectionHeaderNames(source) {
+    return new Set(
+      source.get("connection")?.split(",").map((name) => name.trim().toLowerCase()).filter(Boolean) ?? []
+    );
+  }
+  /**
+   * 创建 CORS 响应头
+   * @param {string} allowedOrigin 已允许的请求来源
+   * @returns {Headers}
+   * @private
+   */
+  corsHeaders(allowedOrigin) {
+    const headers = new Headers();
+    this.applyCorsHeaders(headers, allowedOrigin);
+    return headers;
+  }
+  /**
+   * 应用 CORS 响应头
+   * @param {Headers} headers       响应头
+   * @param {string}  allowedOrigin 已允许的请求来源
+   * @returns {void}
+   * @private
+   */
+  applyCorsHeaders(headers, allowedOrigin) {
+    if (!allowedOrigin) {
+      return;
+    }
+    headers.set("Access-Control-Allow-Origin", allowedOrigin);
+    headers.set("Access-Control-Allow-Credentials", "true");
+    headers.set("Access-Control-Expose-Headers", exposedResponseHeaders.join(", "));
+    headers.set("Vary", this.appendVary(headers.get("Vary"), "Origin"));
+  }
+  /**
+   * 获取允许返回的请求来源
+   * @param {string} origin 请求来源
+   * @returns {string | undefined}
+   * @private
+   */
+  resolveAllowedOrigin(origin) {
+    if (!origin) {
+      return void 0;
+    }
+    return this.allowedOrigins().has(origin) ? origin : void 0;
+  }
+  /**
+   * 获取允许访问远程服务代理的渲染进程来源
+   * @returns {Set<string>}
+   * @private
+   */
+  allowedOrigins() {
+    const origins = /* @__PURE__ */ new Set();
+    const scheme = this.xoApp.getAppConfig()?.eletronAppConfig?.rendererProtocol;
+    if (scheme) {
+      origins.add(`${scheme}://${RendererProtocolKeys.root}`);
+    }
+    const rendererUrl = process.env.ELECTRON_RENDERER_URL;
+    if (rendererUrl) {
+      try {
+        origins.add(new URL(rendererUrl).origin);
+      } catch {
+      }
+    }
+    return origins;
+  }
+  /**
+   * 判断请求方法是否可以携带请求体
+   * @param {string} method 请求方法
+   * @returns {boolean}
+   * @private
+   */
+  hasRequestBody(method) {
+    return method !== "GET" && method !== "HEAD";
+  }
+  /**
+   * 追加 Vary 响应头值
+   * @param {string} value 当前 Vary 响应头
+   * @param {string} name  响应头名称
+   * @returns {string}
+   * @private
+   */
+  appendVary(value, name) {
+    const values = value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+    if (!values.some((item) => item.toLowerCase() === name.toLowerCase())) {
+      values.push(name);
+    }
+    return values.join(", ");
+  }
+  /**
+   * 创建文本响应
+   * @param {number}      status  状态码
+   * @param {string}      message 响应消息
+   * @param {HeadersInit} headers 响应头
+   * @returns {Response}
+   * @private
+   */
+  response(status, message, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("Content-Type", "text/plain; charset=utf-8");
+    return new Response(message, { status, headers: responseHeaders });
+  }
+};
+
+// src/main/renderer-protocol/handlers/renderer-root-protocol-handlers.ts
+import { app, net } from "electron";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var RendererRootProtocolHandlers = class extends RendererProtocolHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoRendererProtocol.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      /** 加载应用渲染根目录资源 */
+      [RendererProtocolKeys.root]: this.handleRoot.bind(this)
+    };
+  }
+  /**
+   * 加载应用渲染根目录资源
+   * @param {XoRendererProtocol.Context} context 协议处理上下文
+   * @returns {Promise<Response>}
+   * @private
+   */
+  async handleRoot(context) {
+    if (context.request.method !== "GET") {
+      return this.response(405, "\u6E32\u67D3\u8FDB\u7A0B\u6839\u76EE\u5F55\u8D44\u6E90\u4EC5\u5141\u8BB8 GET \u8BF7\u6C42", { "Allow": "GET" });
+    }
+    if (AppMode.isDev()) {
+      return this.handleDevResource(context);
+    }
+    const rootDir = this.resolveRendererRoot();
+    if (!rootDir) {
+      return this.response(500, "\u6E32\u67D3\u8FDB\u7A0B\u672A\u83B7\u53D6\u5230\u751F\u4EA7\u9875\u9762\u8DEF\u5F84");
+    }
+    const filePath = this.resolveFilePath(rootDir, context.url);
+    if (!filePath) {
+      return this.response(403, "\u7981\u6B62\u8BBF\u95EE\u6E32\u67D3\u8FDB\u7A0B\u53D1\u5E03\u76EE\u5F55\u4E4B\u5916\u7684\u6587\u4EF6");
+    }
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+      return this.response(404, "\u6E32\u67D3\u8FDB\u7A0B\u8D44\u6E90\u4E0D\u5B58\u5728");
+    }
+    if (!this.isInside(fs.realpathSync(rootDir), fs.realpathSync(filePath))) {
+      return this.response(403, "\u7981\u6B62\u901A\u8FC7\u7B26\u53F7\u94FE\u63A5\u8BBF\u95EE\u6E32\u67D3\u8FDB\u7A0B\u53D1\u5E03\u76EE\u5F55\u4E4B\u5916\u7684\u6587\u4EF6");
+    }
+    return net.fetch(pathToFileURL(filePath).toString());
+  }
+  /**
+   * 从 Vite 开发服务器获取渲染资源
+   * @param {XoRendererProtocol.Context} context 协议处理上下文
+   * @returns {Promise<Response>}
+   * @private
+   */
+  async handleDevResource(context) {
+    const rendererUrl = process.env.ELECTRON_RENDERER_URL;
+    if (!rendererUrl) {
+      return this.response(500, "\u672A\u83B7\u53D6\u5230 Vite \u6E32\u67D3\u5F00\u53D1\u670D\u52A1\u5730\u5740");
+    }
+    const targetUrl = this.resolveDevTargetUrl(rendererUrl, context.url);
+    if (!targetUrl) {
+      return this.response(400, "\u6E32\u67D3\u8FDB\u7A0B\u5F00\u53D1\u8D44\u6E90\u5730\u5740\u65E0\u6548");
+    }
+    try {
+      return await context.session.fetch(targetUrl.toString(), {
+        method: "GET",
+        redirect: "error",
+        signal: context.request.signal
+      });
+    } catch (error) {
+      await this.xoApp.dispatchAppError({ source: "RendererRootProtocolDevHandler", error });
+      return this.response(502, "\u6E32\u67D3\u8FDB\u7A0B\u5F00\u53D1\u8D44\u6E90\u8BF7\u6C42\u5931\u8D25");
+    }
+  }
+  /**
+   * 将自定义协议地址解析为 Vite 地址（开发环境）
+   * @param {string} rendererUrl Vite 开发服务基础地址
+   * @param {URL}    requestUrl  自定义协议地址
+   * @returns {URL | undefined}
+   * @private
+   */
+  resolveDevTargetUrl(rendererUrl, requestUrl) {
+    try {
+      const baseUrl = new URL(rendererUrl);
+      if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+        return void 0;
+      }
+      baseUrl.hash = "";
+      baseUrl.search = "";
+      baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, "")}/`;
+      const relativePath = requestUrl.pathname.replace(/^[/\\]+/, "");
+      const targetUrl = new URL(relativePath, baseUrl);
+      targetUrl.search = requestUrl.search;
+      return targetUrl.origin === baseUrl.origin && targetUrl.pathname.startsWith(baseUrl.pathname) ? targetUrl : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * 解析渲染进程发布目录（生产环境）
+   * @returns {string | undefined}
+   * @private
+   */
+  resolveRendererRoot() {
+    const rendererOutDir = RuntimeConfigUtil.rendererOutDir;
+    if (!rendererOutDir) {
+      return void 0;
+    }
+    const outDir = path.isAbsolute(rendererOutDir) ? rendererOutDir : path.resolve(app.getAppPath(), rendererOutDir);
+    return path.resolve(outDir);
+  }
+  /**
+   * 将协议地址解析为发布目录内的文件路径
+   * @param {string} rootDir 渲染进程发布目录
+   * @param {URL}    url     协议地址
+   * @returns {string | undefined}
+   * @private
+   */
+  resolveFilePath(rootDir, url) {
+    let pathname;
+    try {
+      pathname = decodeURIComponent(url.pathname);
+    } catch {
+      return void 0;
+    }
+    const relativePath = pathname.replace(/^[/\\]+/, "") || "index.html";
+    const filePath = path.resolve(rootDir, relativePath);
+    const relative = path.relative(rootDir, filePath);
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative) ? filePath : void 0;
+  }
+  /**
+   * 判断文件是否位于指定目录内
+   * @param {string} parent 父目录
+   * @param {string} child  文件路径
+   * @returns {boolean}
+   * @private
+   */
+  isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  }
+  /**
+   * 创建文本响应
+   * @param {number}                 status  状态码
+   * @param {string}                 message 响应消息
+   * @param {Record<string, string>} headers 响应头
+   * @returns {Response}
+   * @private
+   */
+  response(status, message, headers = {}) {
+    return new Response(message, {
+      status,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        ...headers
+      }
+    });
+  }
+};
+
+// src/main/renderer-protocol/renderer-protocol-manager-abstract.ts
+import { app as app2, protocol, session } from "electron";
+var RendererProtocolManagerAbstract = class {
+  /** 是否已注册特权协议 */
+  schemeRegistered = false;
+  /** 是否已初始化处理器 */
+  handlersInitialized = false;
+  /** 已接管协议请求的 Session */
+  initializedSessions = /* @__PURE__ */ new WeakSet();
+  /** 已注册处理器类 */
+  registeredHandlerClasses = /* @__PURE__ */ new Set();
+  /** 已注册处理器键 */
+  registeredHandlerKeys = /* @__PURE__ */ new Set();
+  /** 协议处理器映射 */
+  handlerMap = /* @__PURE__ */ new Map();
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   * <p>构造阶段会直接注册特权协议，因此必须在 Electron ready 事件前创建管理器。</p>
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+    this.registerScheme();
+  }
+  /**
+   * 在 Electron 就绪前注册特权协议
+   * @returns {boolean} 是否完成注册
+   */
+  registerScheme() {
+    const scheme = this.getScheme();
+    if (!scheme || this.schemeRegistered) {
+      return false;
+    }
+    if (app2.isReady()) {
+      throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5FC5\u987B\u5728 Electron \u5C31\u7EEA\u524D\u6CE8\u518C: ${scheme}`);
+    }
+    protocol.registerSchemesAsPrivileged([{
+      scheme,
+      privileges: {
+        standard: true,
+        secure: true,
+        supportFetchAPI: true,
+        corsEnabled: true,
+        stream: true,
+        codeCache: true
+      }
+    }]);
+    this.schemeRegistered = true;
+    return true;
+  }
+  /**
+   * 初始化处理器并接管默认 Session 的渲染进程协议请求
+   * @returns {boolean} 是否完成初始化
+   */
+  initialize() {
+    return this.initializeSession(session.defaultSession);
+  }
+  /**
+   * 接管指定 Session 的渲染进程协议请求
+   * @param {Electron.Session} targetSession Electron Session
+   * @returns {boolean} 是否完成初始化
+   */
+  initializeSession(targetSession) {
+    const scheme = this.getScheme();
+    if (!scheme || this.initializedSessions.has(targetSession)) {
+      return false;
+    }
+    if (!this.schemeRegistered) {
+      throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u672A\u6CE8\u518C\u7279\u6743 Scheme: ${scheme}`);
+    }
+    if (!this.handlersInitialized) {
+      this.registerHandlers();
+      this.handlersInitialized = true;
+    }
+    if (targetSession.protocol.isProtocolHandled(scheme)) {
+      throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5DF2\u6CE8\u518C\u5904\u7406\u5668: ${scheme}`);
+    }
+    targetSession.protocol.handle(scheme, (request) => this.handle(request, targetSession));
+    this.initializedSessions.add(targetSession);
+    return true;
+  }
+  /**
+   * 获取渲染进程入口地址，即 window.loadURL() 的地址
+   * @param {string} pathname 页面路径
+   * @returns {string | undefined}
+   */
+  entryUrl(pathname) {
+    const scheme = this.getScheme();
+    if (!scheme) {
+      return void 0;
+    }
+    const normalizedPath = `/${pathname.replace(/^\/+/, "")}`;
+    return new URL(normalizedPath, `${scheme}://${RendererProtocolKeys.root}/`).toString();
+  }
+  /**
+   * 处理渲染进程协议请求
+   * @param {Request}          request       协议请求
+   * @param {Electron.Session} targetSession 当前协议请求所属 Session
+   * @returns {Promise<Response>}
+   */
+  async handle(request, targetSession) {
+    let url;
+    try {
+      url = new URL(request.url);
+    } catch {
+      return new Response("\u65E0\u6548\u7684\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5730\u5740", { status: 400 });
+    }
+    const handler = this.handlerMap.get(url.hostname.toLowerCase());
+    if (!handler) {
+      return new Response("\u672A\u627E\u5230\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5904\u7406\u5668", { status: 404 });
+    }
+    try {
+      return await handler({ request, url, session: targetSession });
+    } catch (error) {
+      await this.xoApp.dispatchAppError({ source: `RendererProtocolHandler:${url.hostname}`, error });
+      return new Response("\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5904\u7406\u5931\u8D25", { status: 500 });
+    }
+  }
+  /**
+   * 注册全部处理器
+   * @private
+   */
+  registerHandlers() {
+    const handlerClasses = [
+      // 内置渲染根目录处理器
+      RendererRootProtocolHandlers,
+      // 内置远程服务代理处理器
+      RendererRemoteServiceProtocolHandlers,
+      // 自定义处理器
+      ...this.handlers()
+    ];
+    for (const HandlerClass of handlerClasses) {
+      if (this.registeredHandlerClasses.has(HandlerClass)) {
+        throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5904\u7406\u5668\u91CD\u590D\u6CE8\u518C: ${HandlerClass.name}`);
+      }
+      this.registeredHandlerClasses.add(HandlerClass);
+      const handlers = new HandlerClass(this.xoApp).handlerMap();
+      for (const [key, handler] of Object.entries(handlers)) {
+        if (!handler) {
+          continue;
+        }
+        const normalizedKey = key.trim().toLowerCase();
+        if (!normalizedKey) {
+          throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5904\u7406\u5668\u952E\u4E0D\u80FD\u4E3A\u7A7A: ${HandlerClass.name}`);
+        }
+        if (this.registeredHandlerKeys.has(normalizedKey)) {
+          throw new Error(`\u6E32\u67D3\u8FDB\u7A0B\u534F\u8BAE\u5904\u7406\u5668\u952E\u91CD\u590D\u6CE8\u518C: ${normalizedKey}`);
+        }
+        this.registeredHandlerKeys.add(normalizedKey);
+        this.handlerMap.set(normalizedKey, handler);
+      }
+    }
+  }
+  /**
+   * 获取渲染进程协议名
+   * @returns {string | undefined}
+   * @private
+   */
+  getScheme() {
+    return this.xoApp.getAppConfig()?.eletronAppConfig?.rendererProtocol;
+  }
+};
+
+// src/main/renderer-protocol/renderer-protocol-manager.ts
+var RendererProtocolManager = class extends RendererProtocolManagerAbstract {
+  /**
+   * 自定义处理器列表
+   * @returns {XoRendererProtocol.HandlersConstructor[]}
+   * @protected
+   */
+  handlers() {
+    return [];
+  }
+};
+
+export {
+  RendererProtocolHandlersAbstract,
+  RendererRemoteServiceProtocolHandlers,
+  RendererRootProtocolHandlers,
+  RendererProtocolManagerAbstract,
+  RendererProtocolManager
+};