@e-xi/xion 0.0.6

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

@@ -0,0 +1,841 @@
+import {
+  JwtAuthSessionChangedError,
+  RemoteServiceAllowedRequestMethods
+} from "./chunk-J34MOWJP.js";
+import {
+  RemoteServiceChannels
+} from "./chunk-RN7AI33H.js";
+import {
+  AppMode
+} from "./chunk-GN2FNR3Z.js";
+
+// src/main/remote-service/remote-service-manager-abstract.ts
+import { BrowserWindow, session as electronSession } from "electron";
+var safeHeaderNames = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-refresh-token",
+  "x-device-id",
+  "cookie",
+  "host",
+  "content-length",
+  "connection"
+]);
+var RemoteServiceManagerAbstract = class {
+  /** Xion 应用 */
+  xoApp;
+  /** 是否已初始化 */
+  initialized = false;
+  /** 远程服务状态 */
+  state = {
+    status: "idle",
+    reconnectCount: 0
+  };
+  /** 心跳定时器 */
+  heartbeatTimer;
+  /** 重试定时器 */
+  retryTimer;
+  /** 快速重试耗尽后的低频探测定时器 */
+  lowFrequencyProbeTimer;
+  /** 当前探测请求的取消控制器 */
+  abortController;
+  /** 会话序号，用于忽略旧会话的异步结果 */
+  sessionId = 0;
+  /** 当前进行中探测所属的会话序号 */
+  probeSessionId = 0;
+  /** 本次运行期间连续失败次数 */
+  retryCount = 0;
+  /** 是否已手动停止连接 */
+  manualStopped = false;
+  /** 是否正在探测 */
+  probing = false;
+  /** 当前探测任务，用于合并并发探测请求 */
+  probePromise;
+  /** 主进程远程服务状态监听器 */
+  stateListeners = /* @__PURE__ */ new Set();
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 获取 Electron 默认会话
+   * @returns {Electron.Session}
+   * @private
+   */
+  electronSession() {
+    return electronSession.defaultSession;
+  }
+  /**
+   * 获取远程服务配置
+   * @returns {XoRemoteService.Config}
+   * @protected
+   */
+  config() {
+    return this.xoApp.getRemoteServiceConfig() ?? {};
+  }
+  /**
+   * 获取远程服务用户设置
+   * @returns {XoRemoteService.UserSettings}
+   * @private
+   */
+  getUserSettings() {
+    return { ...this.xoApp.getAppStore().getRemoteServiceSettings() };
+  }
+  /**
+   * 获取实际生效的远程服务设置
+   * <p>用户设置优先于配置</p>
+   * @returns {XoRemoteService.EffectiveSettings}
+   */
+  getEffectiveSettings() {
+    const config = this.config();
+    const user = this.getUserSettings();
+    return {
+      enabled: user.enabled ?? config.enabled ?? false,
+      serviceUrl: (user.serviceUrl ?? config.serviceUrl ?? "").trim(),
+      connectionTimeout: user.connectionTimeout ?? config.connectionTimeout ?? 1e4,
+      retryCount: user.retryCount ?? config.retryCount ?? 3,
+      retryDelay: user.retryDelay ?? config.retryDelay ?? 3e3,
+      lowFrequencyProbeInterval: user.lowFrequencyProbeInterval ?? config.lowFrequencyProbeInterval ?? 3e4,
+      heartbeatInterval: user.heartbeatInterval ?? config.heartbeatInterval ?? 5e3,
+      heartbeatPath: (user.heartbeatPath ?? config.heartbeatPath)?.trim() || "/health",
+      requestCredentials: config.requestCredentials ?? "include",
+      requestRedirect: config.requestRedirect ?? "error"
+    };
+  }
+  /**
+   * 设置远程服务用户设置
+   * @param {XoRemoteService.UserSettings} settings 远程服务用户设置
+   */
+  setSettings(settings) {
+    this.validateUserSettings(settings);
+    this.xoApp.getAppStore().setRemoteServiceSettings(settings);
+    this.reconnect();
+    this.syncSettingsToAllWindows();
+  }
+  /**
+   * 重置远程服务用户设置
+   */
+  resetSettings() {
+    this.xoApp.getAppStore().resetRemoteServiceSettings();
+    this.reconnect();
+    this.syncSettingsToAllWindows();
+  }
+  /**
+   * 请求远程服务 API
+   * <p>当前接口面向 JSON 或文本请求；文件和流式数据使用渲染进程协议</p>
+   * <p>仅在远程服务连接成功后发起请求</p>
+   * @template T 响应数据类型
+   * @param {XoRemoteService.Request}     request       请求参数
+   * @param {Session}                     targetSession 发起请求的渲染进程 Session，主进程调用时默认使用 defaultSession
+   * @param {RemoteServiceRequestOptions} options       主进程请求选项
+   * @returns {Promise<XoRemoteService.Response<T>>}
+   */
+  async request(request, targetSession, options = {}) {
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled || !settings.serviceUrl) {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u672A\u542F\u7528\u6216\u672A\u914D\u7F6E\u670D\u52A1\u5730\u5740");
+    }
+    const authManager = this.xoApp.getAuthManager();
+    const authRevision = options.authentication === "none" ? void 0 : authManager.getAuthRevision();
+    targetSession ??= this.electronSession();
+    await this.ensureConnected();
+    this.requireAuthenticationRevision(authRevision);
+    const method = request.method.toUpperCase();
+    if (!RemoteServiceAllowedRequestMethods.has(method)) {
+      throw new Error(`\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u65B9\u6CD5\u4E0D\u53D7\u652F\u6301: ${request.method}`);
+    }
+    const targetUrl = this.resolveRequestUrl(settings.serviceUrl, request);
+    let authorization = options.authentication === "none" ? void 0 : await authManager.getAuthorizationContext();
+    this.requireAuthenticationRevision(authRevision);
+    const authenticationHeaders = {
+      ...options.authenticationHeaders,
+      ...authManager.getDeviceIdHeaders()
+    };
+    let response = await this.executeRequest(
+      request,
+      targetSession,
+      settings,
+      method,
+      targetUrl,
+      authorization,
+      authenticationHeaders
+    );
+    this.requireAuthenticationRevision(authRevision);
+    if (response.status === 401 && authorization && options.retryUnauthorized !== false) {
+      authorization = await authManager.refreshAfterUnauthorized(authorization);
+      this.requireAuthenticationRevision(authRevision);
+      if (authorization) {
+        response = await this.executeRequest(
+          request,
+          targetSession,
+          settings,
+          method,
+          targetUrl,
+          authorization,
+          authenticationHeaders
+        );
+        this.requireAuthenticationRevision(authRevision);
+      }
+    }
+    return response;
+  }
+  /**
+   * 校验请求所属认证会话未发生变化
+   * @param {number} expectedRevision 请求开始时的认证操作版本，未认证请求不传入
+   * @returns {void}
+   * @private
+   */
+  requireAuthenticationRevision(expectedRevision) {
+    if (expectedRevision !== void 0 && this.xoApp.getAuthManager().getAuthRevision() !== expectedRevision) {
+      throw new JwtAuthSessionChangedError();
+    }
+  }
+  /**
+   * 执行一次远程服务请求
+   * @template T 响应数据类型
+   * @param {XoRemoteService.Request}           request               请求参数
+   * @param {Session}                           targetSession         发起请求的 Session
+   * @param {XoRemoteService.EffectiveSettings} settings              生效设置
+   * @param {XoRemoteService.Method}            method                请求方法
+   * @param {URL}                               targetUrl             请求地址
+   * @param {JwtAuthorizationContext}           authorization         访问令牌请求头上下文
+   * @param {Readonly<Record<string, string>>}  authenticationHeaders 主进程内部认证请求头
+   * @returns {Promise<XoRemoteService.Response<T>>}
+   * @private
+   */
+  async executeRequest(request, targetSession, settings, method, targetUrl, authorization, authenticationHeaders) {
+    const controller = new AbortController();
+    const body = this.buildRequestBody(request.body);
+    const timeout = setTimeout(() => controller.abort(), settings.connectionTimeout);
+    const headers = this.buildRequestHeaders(request, authorization, authenticationHeaders);
+    this.forceUserAgent(headers, targetSession);
+    try {
+      const upstream = await targetSession.fetch(targetUrl.toString(), {
+        method,
+        headers,
+        body: method === "GET" || method === "HEAD" ? void 0 : body,
+        credentials: settings.requestCredentials,
+        redirect: settings.requestRedirect,
+        signal: controller.signal
+      });
+      const responseHeaders = this.buildResponseHeaders(upstream.headers);
+      const contentType = upstream.headers.get("content-type")?.toLowerCase() ?? "";
+      const responseText = await upstream.text();
+      let data = responseText || void 0;
+      if (responseText && contentType.includes("application/json")) {
+        try {
+          data = JSON.parse(responseText);
+        } catch {
+          data = responseText;
+        }
+      }
+      return {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: responseHeaders,
+        data
+      };
+    } catch (error) {
+      throw this.toRequestError(error);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * 构建远程服务请求地址
+   * @param {string}                  serviceUrl 服务基础地址
+   * @param {XoRemoteService.Request} request    请求参数
+   * @returns {URL}
+   * @private
+   */
+  resolveRequestUrl(serviceUrl, request) {
+    const path = request.path.trim();
+    if (!path.startsWith("/") || path.startsWith("//")) {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u8DEF\u5F84\u5FC5\u987B\u662F\u4EE5 / \u5F00\u5934\u7684\u76F8\u5BF9\u8DEF\u5F84");
+    }
+    const baseUrl = new URL(serviceUrl);
+    if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\u53EA\u652F\u6301 HTTP \u6216 HTTPS");
+    }
+    baseUrl.hash = "";
+    baseUrl.search = "";
+    baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, "")}/`;
+    const targetUrl = new URL(path.replace(/^\/+/, ""), baseUrl);
+    if (targetUrl.origin !== baseUrl.origin || !targetUrl.pathname.startsWith(baseUrl.pathname)) {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u8DEF\u5F84\u8D85\u51FA\u670D\u52A1\u5730\u5740\u8303\u56F4");
+    }
+    for (const [key, value] of Object.entries(request.query ?? {})) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        targetUrl.searchParams.append(key, String(item));
+      }
+    }
+    return targetUrl;
+  }
+  /**
+   * 构建请求头
+   * @param {XoRemoteService.Request}          request               渲染进程请求
+   * @param {JwtAuthorizationContext}          authorization         主进程管理的访问令牌请求头上下文
+   * @param {Readonly<Record<string, string>>} authenticationHeaders 主进程内部认证请求头
+   * @returns {Headers}
+   * @private
+   */
+  buildRequestHeaders(request, authorization, authenticationHeaders) {
+    const refuseHeaderNames = /* @__PURE__ */ new Set([
+      // 主进程内部管理的请求头
+      ...safeHeaderNames,
+      // 按远程服务认证策略管理的请求头
+      ...this.xoApp.getAuthManager().getAuthenticationHeaderNames()
+    ]);
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(request.headers ?? {})) {
+      if (refuseHeaderNames.has(name.toLowerCase())) {
+        continue;
+      }
+      headers.set(name, value);
+    }
+    if (request.body !== void 0 && !headers.has("content-type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    for (const [name, value] of Object.entries(authenticationHeaders ?? {})) {
+      headers.set(name, value);
+    }
+    if (authorization) {
+      headers.set(authorization.headerName, authorization.header);
+    }
+    return headers;
+  }
+  /**
+   * 强制设置 User-Agent 为当前 Session 的 User-Agent
+   * @param {Headers}          headers       请求头
+   * @param {Electron.Session} targetSession 目标 Session
+   * @private
+   */
+  forceUserAgent(headers, targetSession) {
+    headers.set("user-agent", targetSession.getUserAgent());
+  }
+  /**
+   * 构建请求体
+   * @param {unknown} body 请求体
+   * @returns {string | undefined}
+   * @private
+   */
+  buildRequestBody(body) {
+    if (body === void 0 || body === null) {
+      return void 0;
+    }
+    if (typeof body === "string") {
+      return body;
+    }
+    try {
+      return JSON.stringify(body);
+    } catch {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u4F53\u65E0\u6CD5\u5E8F\u5217\u5316\u4E3A JSON");
+    }
+  }
+  /**
+   * 构建可返回到渲染进程的响应头
+   * @param {Headers} headers 远程响应头
+   * @returns {Record<string, string>}
+   * @private
+   */
+  buildResponseHeaders(headers) {
+    const result = {};
+    for (const [name, value] of headers.entries()) {
+      const normalizedName = name.toLowerCase();
+      if (["set-cookie", "set-cookie2", "authorization"].includes(normalizedName)) {
+        continue;
+      }
+      result[name] = value;
+    }
+    return result;
+  }
+  /**
+   * 验证远程服务用户设置
+   * @param {XoRemoteService.UserSettings} settings 远程服务用户设置
+   * @private
+   */
+  validateUserSettings(settings) {
+    if (settings.serviceUrl?.trim()) {
+      this.validateServiceUrl(settings.serviceUrl);
+    }
+    if (settings.connectionTimeout !== void 0 && (!Number.isFinite(settings.connectionTimeout) || settings.connectionTimeout < 3e3)) {
+      settings.connectionTimeout = 3e3;
+    }
+    if (settings.retryCount !== void 0 && (!Number.isFinite(settings.retryCount) || settings.retryCount < 1)) {
+      settings.retryCount = 1;
+    }
+    if (settings.retryDelay !== void 0 && (!Number.isFinite(settings.retryDelay) || settings.retryDelay < 3e3)) {
+      settings.retryDelay = 3e3;
+    }
+    if (settings.lowFrequencyProbeInterval !== void 0 && (!Number.isFinite(settings.lowFrequencyProbeInterval) || settings.lowFrequencyProbeInterval < 3e4)) {
+      settings.lowFrequencyProbeInterval = 3e4;
+    }
+    if (settings.heartbeatInterval !== void 0 && (!Number.isFinite(settings.heartbeatInterval) || settings.heartbeatInterval < 5e3)) {
+      settings.heartbeatInterval = 5e3;
+    }
+    if (settings.enabled === true && !settings.serviceUrl?.trim()) {
+      throw new Error("\u5FC5\u987B\u914D\u7F6E\u670D\u52A1\u5730\u5740");
+    }
+    if (!settings.heartbeatPath?.trim()) {
+      throw new Error("\u5FC5\u987B\u914D\u7F6E\u5FC3\u8DF3\u63A2\u6D4B\u8DEF\u5F84");
+    }
+  }
+  /**
+   * 验证服务地址
+   * <p>仅支持 http/https，生产环境仅允许 https，且必须是合法地址</p>
+   * @param {string} url 服务地址
+   * @private
+   */
+  validateServiceUrl(url) {
+    const trimmed = url.trim();
+    const scheme = trimmed.match(/^([a-z][a-z0-9+.-]*):\/\//i)?.[1]?.toLowerCase();
+    if (scheme === "http" && !AppMode.isDev()) {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\u534F\u8BAE\u65E0\u6548\uFF0C\u4EC5\u652F\u6301 https");
+    }
+    if (scheme !== "http" && scheme !== "https") {
+      throw new Error(`\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\u534F\u8BAE\u65E0\u6548\uFF0C\u4EC5\u652F\u6301 http/https`);
+    }
+    try {
+      const parsed = new URL(trimmed);
+      if (!parsed.hostname) {
+        throw new Error();
+      }
+    } catch {
+      throw new Error(`\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\u65E0\u6548`);
+    }
+  }
+  /**
+   * 重新发起探测连接
+   * @private
+   */
+  reconnect() {
+    this.stopConnection();
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled) {
+      this.updateState({ status: "idle", error: void 0 });
+      return;
+    }
+    void this.connect();
+  }
+  /**
+   * 是否启用远程服务
+   * @returns {boolean}
+   */
+  enabled() {
+    return this.getEffectiveSettings().enabled;
+  }
+  /**
+   * 初始化远程服务模块
+   * <p>未启用时不发起连接和心跳；启用但未配置服务地址时报错</p>
+   * @returns {boolean}
+   */
+  initialize() {
+    if (this.initialized) {
+      return false;
+    }
+    this.initialized = true;
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled) {
+      this.xoApp.remoteServiceLog.info("\u8FDC\u7A0B\u670D\u52A1\u672A\u542F\u7528\uFF0C\u8DF3\u8FC7\u8FDE\u63A5");
+      return false;
+    }
+    if (!settings.serviceUrl) {
+      this.xoApp.remoteServiceLog.warn("\u8FDC\u7A0B\u670D\u52A1\u5DF2\u542F\u7528\uFF0C\u4F46\u672A\u914D\u7F6E\u670D\u52A1\u5730\u5740 serviceUrl");
+      return false;
+    }
+    void this.connect();
+    return true;
+  }
+  /**
+   * 确保远程服务已连接
+   * <p>未连接时立即执行一次探测；并发调用复用当前探测任务</p>
+   * @returns {Promise<void>}
+   * @private
+   */
+  async ensureConnected() {
+    if (this.state.status === "connected") {
+      return;
+    }
+    const connected = await this.probe(true);
+    const status = this.getState().status;
+    if (connected || status === "connected") {
+      return;
+    }
+    if (status === "disconnected") {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    }
+    if (status === "error") {
+      throw new Error("\u8FDC\u7A0B\u670D\u52A1\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u8BBE\u7F6E");
+    }
+    throw new Error("\u8FDC\u7A0B\u670D\u52A1\u672A\u8FDE\u63A5");
+  }
+  /**
+   * 发起连接（执行一次连接探测）
+   * @returns {Promise<void>}
+   */
+  async connect() {
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled || !settings.serviceUrl) {
+      return;
+    }
+    this.sessionId++;
+    if (this.probing && this.probeSessionId === this.sessionId) {
+      return;
+    }
+    if (this.heartbeatTimer || this.retryTimer || this.lowFrequencyProbeTimer) {
+      return;
+    }
+    this.manualStopped = false;
+    this.retryCount = 0;
+    this.clearTimers();
+    await this.probe(true);
+  }
+  /**
+   * 执行一次连接探测
+   * <p>HTTP 请求服务地址，仅 200 视为服务可达，其他状态码或网络错误视为失败</p>
+   * @param {boolean} initial 是否为首次连接探测（true 时状态显示为连接中）
+   * @returns {Promise<boolean>} 是否探测成功
+   * @private
+   */
+  async probe(initial) {
+    if (this.manualStopped) {
+      return false;
+    }
+    const session = this.sessionId;
+    if (this.probing) {
+      if (this.probeSessionId === session && this.probePromise) {
+        return await this.probePromise;
+      }
+      if (this.probePromise) {
+        await this.probePromise;
+        return await this.probe(initial);
+      }
+      return false;
+    }
+    this.clearReconnectTimers();
+    this.probing = true;
+    this.probeSessionId = session;
+    const probePromise = this.executeProbe(initial, session);
+    this.probePromise = probePromise;
+    try {
+      return await probePromise;
+    } finally {
+      if (this.probeSessionId === session && this.probePromise === probePromise) {
+        this.probing = false;
+        this.probePromise = void 0;
+      }
+    }
+  }
+  /**
+   * 执行远程服务探测请求
+   * @param {boolean} initial 是否为首次连接探测
+   * @param {number}  session 当前会话序号
+   * @returns {Promise<boolean>} 是否探测成功
+   * @private
+   */
+  async executeProbe(initial, session) {
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled) {
+      return false;
+    }
+    const controller = new AbortController();
+    this.abortController = controller;
+    const timeout = setTimeout(() => controller.abort(), settings.connectionTimeout);
+    try {
+      if (initial) {
+        this.updateState({ status: "connecting", error: void 0 });
+      }
+      const headers = new Headers();
+      const targetSession = this.electronSession();
+      const heartbeatUrl = this.buildHeartbeatUrl(settings);
+      this.forceUserAgent(headers, targetSession);
+      const response = await targetSession.fetch(heartbeatUrl, {
+        headers,
+        method: "GET",
+        credentials: "omit",
+        redirect: "error",
+        cache: "no-store",
+        signal: controller.signal
+      });
+      const status = response.status;
+      await response.body?.cancel().catch(() => void 0);
+      this.xoApp.mainLog.debug("\u53D1\u8D77\u8FDC\u7A0B\u670D\u52A1\u63A2\u6D4B", heartbeatUrl);
+      if (session !== this.sessionId) {
+        return false;
+      }
+      if (status !== 200) {
+        this.onProbeFailure(`\u54CD\u5E94\u5F02\u5E38\uFF08HTTP ${status}\uFF09`);
+        return false;
+      }
+      this.onProbeSuccess();
+      return true;
+    } catch (error) {
+      if (session !== this.sessionId) {
+        return false;
+      }
+      this.onProbeFailure(this.toErrorMessage(error));
+      return false;
+    } finally {
+      if (this.abortController === controller) {
+        this.abortController = void 0;
+      }
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * 探测成功
+   * @private
+   */
+  onProbeSuccess() {
+    this.retryCount = 0;
+    this.clearReconnectTimers();
+    this.updateState({ status: "connected", error: void 0, connectedAt: Date.now() });
+    this.startHeartbeat();
+  }
+  /**
+   * 探测失败
+   * @param {string} message 失败原因
+   * @private
+   */
+  onProbeFailure(message) {
+    this.stopHeartbeat();
+    if (this.manualStopped) {
+      this.updateState({ status: "idle", error: void 0 });
+      return;
+    }
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled) {
+      this.updateState({ status: "idle", error: void 0 });
+      return;
+    }
+    if (this.retryCount < settings.retryCount) {
+      this.retryCount++;
+      this.updateState({ status: "disconnected", error: `\u8FDC\u7A0B\u670D\u52A1 ${message}` });
+      this.xoApp.remoteServiceLog.warn(`\u8FDC\u7A0B\u670D\u52A1 ${message}\uFF0C${settings.retryDelay}ms \u540E\u91CD\u8BD5\uFF08${this.retryCount}/${settings.retryCount}\uFF09`);
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = void 0;
+        void this.probe(true);
+      }, settings.retryDelay);
+      return;
+    }
+    const enteringLowFrequencyProbe = this.state.status !== "error";
+    this.updateState({ status: "error", error: `\u8FDC\u7A0B\u670D\u52A1 ${message}` });
+    if (enteringLowFrequencyProbe) {
+      this.xoApp.remoteServiceLog.error(
+        `\u8FDC\u7A0B\u670D\u52A1 ${message}\uFF0C\u5DF2\u91CD\u8BD5 ${settings.retryCount} \u6B21\uFF0C\u8FDB\u5165\u4F4E\u9891\u63A2\u6D4B`
+      );
+    } else {
+      this.xoApp.remoteServiceLog.warn(
+        `\u8FDC\u7A0B\u670D\u52A1 ${message}\uFF0C${settings.lowFrequencyProbeInterval}ms \u540E\u7EE7\u7EED\u4F4E\u9891\u63A2\u6D4B`
+      );
+    }
+    this.scheduleLowFrequencyProbe(settings.lowFrequencyProbeInterval);
+  }
+  /**
+   * 安排下一次低频探测
+   * @param {number} interval 探测间隔（毫秒）
+   * @private
+   */
+  scheduleLowFrequencyProbe(interval) {
+    if (this.lowFrequencyProbeTimer) {
+      return;
+    }
+    this.lowFrequencyProbeTimer = setTimeout(() => {
+      this.lowFrequencyProbeTimer = void 0;
+      void this.probe(false);
+    }, interval);
+  }
+  /**
+   * 转换探测错误信息
+   * @param {unknown} error 错误对象
+   * @returns {string}
+   * @private
+   */
+  toErrorMessage(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return "\u8FDE\u63A5\u8D85\u65F6";
+    }
+    return error instanceof Error ? error.message : "\u8FDE\u63A5\u5931\u8D25";
+  }
+  /**
+   * 转换远程服务请求错误
+   * @param {unknown} error 原始错误
+   * @returns {Error}
+   * @private
+   */
+  toRequestError(error) {
+    const value = error && typeof error === "object" ? error : void 0;
+    const cause = value?.cause && typeof value.cause === "object" ? value.cause : void 0;
+    const name = typeof value?.name === "string" ? value.name : "";
+    const message = error instanceof Error ? error.message : typeof value?.message === "string" ? value.message : String(error);
+    const causeMessage = typeof cause?.message === "string" ? cause.message : "";
+    const code = [value?.code, cause?.code].find((item) => typeof item === "string");
+    const diagnostic = [code, message, causeMessage].filter(Boolean).join(" ");
+    if (name === "AbortError") {
+      return new Error("\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u8D85\u65F6");
+    }
+    if (/ECONNREFUSED|ERR_CONNECTION_REFUSED/i.test(diagnostic)) {
+      return new Error("\u65E0\u6CD5\u8FDE\u63A5\u8FDC\u7A0B\u670D\u52A1\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u5730\u5740\u6216\u786E\u8BA4\u670D\u52A1\u5DF2\u542F\u52A8");
+    }
+    if (/ENOTFOUND|EAI_AGAIN|ERR_NAME_NOT_RESOLVED/i.test(diagnostic)) {
+      return new Error("\u65E0\u6CD5\u89E3\u6790\u8FDC\u7A0B\u670D\u52A1\u5730\u5740\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u5730\u5740\u6216\u7F51\u7EDC\u8FDE\u63A5");
+    }
+    if (/ETIMEDOUT|ESOCKETTIMEDOUT|ERR_TIMED_OUT/i.test(diagnostic)) {
+      return new Error("\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u8D85\u65F6");
+    }
+    if (/ECONNRESET|EPIPE|ERR_CONNECTION_RESET/i.test(diagnostic)) {
+      return new Error("\u8FDC\u7A0B\u670D\u52A1\u8FDE\u63A5\u5DF2\u4E2D\u65AD\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    }
+    if (/ERR_CERT_|ERR_SSL_|ERR_TLS_|CERT_HAS_EXPIRED|DEPTH_ZERO_SELF_SIGNED_CERT|UNABLE_TO_VERIFY_LEAF_SIGNATURE/i.test(diagnostic)) {
+      return new Error("\u8FDC\u7A0B\u670D\u52A1\u8BC1\u4E66\u9A8C\u8BC1\u5931\u8D25");
+    }
+    return new Error(message || "\u8FDC\u7A0B\u670D\u52A1\u8BF7\u6C42\u5931\u8D25");
+  }
+  /**
+   * 构建心跳请求地址
+   * <p>未配置心跳路径时直接请求服务地址</p>
+   * @param {XoRemoteService.EffectiveSettings} settings 生效设置
+   * @returns {string}
+   * @private
+   */
+  buildHeartbeatUrl(settings) {
+    const path = settings.heartbeatPath?.trim() || "";
+    if (!path) {
+      return settings.serviceUrl;
+    }
+    return `${settings.serviceUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+  }
+  /**
+   * 停止当前连接探测
+   * @private
+   */
+  stopConnection() {
+    this.manualStopped = true;
+    this.sessionId++;
+    this.clearTimers();
+    this.abortController?.abort();
+    this.abortController = void 0;
+  }
+  /**
+   * 启动心跳
+   * <p>按间隔周期探测服务地址，失败时进入断开与重试流程</p>
+   * @private
+   */
+  startHeartbeat() {
+    const settings = this.getEffectiveSettings();
+    if (!settings.enabled) {
+      return;
+    }
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      void this.probe(false);
+    }, settings.heartbeatInterval);
+  }
+  /**
+   * 停止心跳
+   * @private
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+  /**
+   * 获取远程服务状态
+   * @returns {XoRemoteService.State}
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * 监听主进程远程服务状态
+   * @param {XoRemoteService.StateListener} listener 状态监听器
+   * @returns {() => void} 移除监听器
+   */
+  addStateListener(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  /**
+   * 更新远程服务状态
+   * @param {Partial<XoRemoteService.State>} state 状态
+   * @protected
+   */
+  updateState(state) {
+    this.state = {
+      ...this.state,
+      ...state
+    };
+    for (const listener of this.stateListeners) {
+      listener(this.getState());
+    }
+    this.syncToAllWindows();
+  }
+  /**
+   * 通知远程服务状态到全部渲染进程
+   */
+  syncToAllWindows() {
+    BrowserWindow.getAllWindows().forEach((window) => this.syncToWindow(window));
+  }
+  /**
+   * 通知远程服务状态到渲染进程
+   * @param {Electron.BrowserWindow} window 窗口
+   */
+  syncToWindow(window) {
+    if (window.isDestroyed() || window.webContents.isDestroyed()) {
+      return;
+    }
+    window.webContents.send(RemoteServiceChannels.onState, this.getState());
+  }
+  /**
+   * 通知远程服务设置到全部渲染进程
+   */
+  syncSettingsToAllWindows() {
+    BrowserWindow.getAllWindows().forEach((window) => this.syncSettingsToWindow(window));
+  }
+  /**
+   * 通知远程服务设置到渲染进程
+   * @param {Electron.BrowserWindow} window 窗口
+   */
+  syncSettingsToWindow(window) {
+    if (window.isDestroyed() || window.webContents.isDestroyed()) {
+      return;
+    }
+    window.webContents.send(RemoteServiceChannels.onSettings, this.getEffectiveSettings());
+  }
+  /**
+   * 清理全部定时器
+   * @private
+   */
+  clearTimers() {
+    this.stopHeartbeat();
+    this.clearReconnectTimers();
+  }
+  /**
+   * 清理快速重试和低频探测定时器
+   * @private
+   */
+  clearReconnectTimers() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    if (this.lowFrequencyProbeTimer) {
+      clearTimeout(this.lowFrequencyProbeTimer);
+      this.lowFrequencyProbeTimer = void 0;
+    }
+  }
+};
+
+// src/main/remote-service/remote-service-manager.ts
+var RemoteServiceManager = class extends RemoteServiceManagerAbstract {
+};
+
+export {
+  RemoteServiceManagerAbstract,
+  RemoteServiceManager
+};