@e-xi/xion 0.0.6

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

@@ -0,0 +1,703 @@
+import {
+  JwtAuthSessionChangedError
+} from "./chunk-J34MOWJP.js";
+import {
+  JwtAuthStore
+} from "./chunk-B7DTBTWQ.js";
+import {
+  AuthChannels
+} from "./chunk-T3QCAOCO.js";
+
+// src/main/auth/jwt-auth-refresh-rejected-error.ts
+var JwtAuthRefreshRejectedError = class extends Error {
+  /**
+   * 构造函数
+   * @param {string} message 错误信息
+   */
+  constructor(message = "\u5237\u65B0\u4EE4\u724C\u5DF2\u5931\u6548") {
+    super(message);
+    this.name = "JwtAuthRefreshRejectedError";
+  }
+};
+
+// src/main/auth/jwt-auth-manager.ts
+import { BrowserWindow, powerMonitor, session as electronSession } from "electron";
+var JwtAuthManager = class {
+  /** Xion 应用 */
+  xoApp;
+  /** 业务 JWT Provider */
+  provider;
+  /** JWT 加密存储 */
+  store;
+  /** 是否已初始化 */
+  initialized = false;
+  /** 当前认证状态 */
+  state = { status: "unauthenticated" };
+  /** 访问令牌（内存中管理） */
+  accessToken;
+  /** 访问令牌绝对过期时间戳（内存中管理） */
+  accessTokenExpiresAt;
+  /** 内存中的刷新会话 */
+  storedRefreshSession;
+  /** 自动刷新定时器 */
+  refreshTimer;
+  /** 当前刷新任务，用于合并并发刷新 */
+  refreshPromise;
+  /** 当前退出任务，用于合并并发退出并阻止登录与退出交错执行 */
+  logoutPromise;
+  /** 认证操作版本号，用于阻止旧登录或刷新请求回写新会话 */
+  authRevision = 0;
+  /** 上一次观察到的远程服务连接状态 */
+  remoteConnected = false;
+  /** 是否已输出安全存储不可用警告 */
+  encryptionWarningLogged = false;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract}      xoApp    Xion 应用
+   * @param {AnyJwtAuthProvider} provider 业务 JWT Provider
+   */
+  constructor(xoApp, provider) {
+    this.xoApp = xoApp;
+    this.provider = provider;
+    this.store = new JwtAuthStore();
+  }
+  /**
+   * 是否已配置 JWT 认证
+   * @returns {boolean}
+   */
+  enabled() {
+    return this.provider !== void 0;
+  }
+  /**
+   * 获取当前认证操作版本
+   * @returns {number}
+   */
+  getAuthRevision() {
+    return this.authRevision;
+  }
+  /**
+   * 获取由主进程管理的认证请求头名称
+   * <p>远程服务层使用这些名称阻止渲染进程伪造认证请求头</p>
+   * @returns {readonly string[]}
+   */
+  getAuthenticationHeaderNames() {
+    const authorizationHeaderName = this.provider?.authorizationHeaderName ?? "Authorization";
+    const refreshTokenHeaderName = this.provider?.refreshTokenHeaderName ?? "X-Refresh-Token";
+    const deviceIdHeaderName = this.provider?.deviceIdHeaderName ?? "x-device-id";
+    return [...new Set([
+      // 兜底
+      "authorization",
+      "x-refresh-token",
+      "x-device-id",
+      // 业务设置
+      authorizationHeaderName,
+      refreshTokenHeaderName,
+      deviceIdHeaderName
+    ].map((name) => name.trim().toLowerCase()))];
+  }
+  /**
+   * 获取远程服务管理器
+   * @returns {RemoteServiceManagerAbstract}
+   * @private
+   */
+  getRemoteService() {
+    return this.xoApp.getRemoteServiceManager();
+  }
+  /**
+   * 获取 Electron 默认会话
+   * @returns {Electron.Session}
+   * @private
+   */
+  electronSession() {
+    return electronSession.defaultSession;
+  }
+  /**
+   * 初始化认证模块
+   * <p>启动时存在有效刷新会话则自动刷新；远程服务暂不可用时保留会话并等待恢复</p>
+   * @returns {boolean} 是否启动了认证模块
+   */
+  initialize() {
+    if (this.initialized || !this.provider) {
+      return false;
+    }
+    this.provider.requireValidate();
+    this.initialized = true;
+    this.getRemoteService().addStateListener((state) => {
+      const connected = state.status === "connected";
+      const becameConnected = connected && !this.remoteConnected;
+      this.remoteConnected = connected;
+      if (becameConnected) {
+        void this.refreshAccessTokenIfNeeded().catch((error) => {
+          this.xoApp.authLog.warn("\u8FDC\u7A0B\u670D\u52A1\u6062\u590D\u65F6\u5237\u65B0\u8BBF\u95EE\u4EE4\u724C\u5931\u8D25", this.errorMessage(error));
+        });
+      }
+    });
+    powerMonitor.on("resume", () => {
+      void this.refreshAccessTokenIfNeeded().catch((error) => {
+        this.xoApp.authLog.warn("\u7CFB\u7EDF\u6062\u590D\u65F6\u5237\u65B0\u8BBF\u95EE\u4EE4\u724C\u5931\u8D25", this.errorMessage(error));
+      });
+    });
+    void this.restoreRefreshSession();
+    return true;
+  }
+  /**
+   * 获取可暴露给渲染进程的认证状态
+   * @returns {XoAuth.State}
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * 登录
+   * @param {XoAuth.LoginRequest} request 登录请求
+   * @returns {Promise<XoAuth.State>}
+   */
+  async login(request) {
+    if (this.logoutPromise) {
+      try {
+        await this.logoutPromise;
+      } catch {
+      }
+    }
+    const provider = this.requireProvider();
+    this.clearSession();
+    const authRevision = this.authRevision;
+    this.updateStateAuthenticating();
+    try {
+      const response = await this.getRemoteService().request(
+        {
+          ...provider.loginRequest(request),
+          method: provider.loginMethod,
+          path: provider.loginPath
+        },
+        this.electronSession(),
+        { authentication: "none", retryUnauthorized: false }
+      );
+      if (this.authRevision !== authRevision) {
+        throw new Error("\u767B\u5F55\u8BF7\u6C42\u5DF2\u5931\u6548");
+      }
+      const authResult = provider.loginResponse(response);
+      this.requireResponseStatusOK(response, "\u767B\u5F55");
+      this.applyAuthResult(authResult);
+      return this.getState();
+    } catch (error) {
+      if (this.authRevision === authRevision) {
+        this.updateStateUnauthenticated(this.errorMessage(error));
+      }
+      throw error;
+    }
+  }
+  /**
+   * 退出登录
+   * <p>无论服务端退出是否成功，都会清除本地令牌</p>
+   * @returns {Promise<XoAuth.State>}
+   */
+  async logout() {
+    if (this.logoutPromise) {
+      return this.logoutPromise;
+    }
+    const promise = this.executeLogout();
+    this.logoutPromise = promise;
+    try {
+      return await promise;
+    } finally {
+      if (this.logoutPromise === promise) {
+        this.logoutPromise = void 0;
+      }
+    }
+  }
+  /**
+   * 执行一次退出登录请求
+   * @returns {Promise<XoAuth.State>}
+   * @private
+   */
+  async executeLogout() {
+    const provider = this.requireProvider();
+    try {
+      if (this.storedRefreshSession) {
+        const response = await this.getRemoteService().request(
+          {
+            ...provider.logoutRequest(),
+            method: provider.logoutMethod,
+            path: provider.logoutPath
+          },
+          this.electronSession(),
+          { retryUnauthorized: false }
+        );
+        provider.logoutResponse(response);
+        this.requireResponseStatusOK(response, "\u9000\u51FA\u767B\u5F55");
+      }
+    } finally {
+      this.clearSession();
+    }
+    return this.getState();
+  }
+  /**
+   * 使用刷新令牌更新令牌对（强制刷新，即使访问令牌未过期也刷新）
+   * @returns {Promise<void>}
+   */
+  async refreshAccessToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    const promise = this.executeRefresh();
+    this.refreshPromise = promise;
+    try {
+      await promise;
+    } finally {
+      if (this.refreshPromise === promise) {
+        this.refreshPromise = void 0;
+      }
+    }
+  }
+  /**
+   * 在存在刷新会话且访问令牌需要刷新时更新令牌对
+   * @returns {Promise<void>}
+   */
+  async refreshAccessTokenIfNeeded() {
+    if (!this.storedRefreshSession || !this.shouldRefreshAccessToken()) {
+      return;
+    }
+    await this.refreshAccessToken();
+  }
+  /**
+   * 执行一次刷新请求
+   * @returns {Promise<void>}
+   * @private
+   */
+  async executeRefresh() {
+    const provider = this.requireProvider();
+    const session = this.storedRefreshSession;
+    const authRevision = this.authRevision;
+    if (!session) {
+      throw new Error("\u6CA1\u6709\u53EF\u7528\u7684\u5237\u65B0\u4EE4\u724C");
+    }
+    if (session.refreshTokenExpiresAt <= Date.now()) {
+      this.clearSession("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+      throw new JwtAuthRefreshRejectedError("\u5237\u65B0\u4EE4\u724C\u5DF2\u8FC7\u671F");
+    }
+    const previousState = this.state.status;
+    this.updateStateRefreshing();
+    try {
+      const response = await this.getRemoteService().request(
+        {
+          ...provider.refreshRequest(),
+          method: provider.refreshMethod,
+          path: provider.refreshPath
+        },
+        this.electronSession(),
+        {
+          authentication: "none",
+          retryUnauthorized: false,
+          // 注入刷新令牌请求头名称和值
+          authenticationHeaders: { [provider.refreshTokenHeaderName.trim()]: session.refreshToken }
+        }
+      );
+      if (this.authRevision !== authRevision) {
+        return;
+      }
+      let authResult;
+      try {
+        authResult = provider.refreshResponse(response);
+      } catch (error) {
+        if (response.status === 401 || response.status === 403) {
+          throw new JwtAuthRefreshRejectedError(this.errorMessage(error));
+        }
+        throw error;
+      }
+      this.requireRefreshResponseStatusOK(response);
+      this.applyAuthResult(authResult);
+    } catch (error) {
+      if (this.authRevision !== authRevision) {
+        return;
+      }
+      if (error instanceof JwtAuthRefreshRejectedError) {
+        this.clearSession(error.message);
+        throw error;
+      }
+      if (session.refreshTokenExpiresAt <= Date.now()) {
+        this.clearSession("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+        throw error;
+      }
+      const refreshError = this.errorMessage(error);
+      if (this.hasValidAccessToken() || previousState === "authenticated") {
+        this.updateStateAuthenticated(this.storedRefreshSession?.user, refreshError);
+      } else {
+        this.updateStateError(refreshError);
+      }
+      this.scheduleRefreshRetry();
+      throw error;
+    }
+  }
+  /**
+   * 获取请求使用的 Authorization 上下文
+   * <p>访问令牌即将过期时先自动刷新；刷新暂时失败但旧令牌仍有效时继续使用旧令牌</p>
+   * @returns {Promise<JwtAuthorizationContext | undefined>}
+   */
+  async getAuthorizationContext() {
+    if (!this.provider || !this.storedRefreshSession) {
+      return void 0;
+    }
+    const authRevision = this.authRevision;
+    const accessExpiresAt = this.accessTokenExpiresAt ?? 0;
+    try {
+      await this.refreshAccessTokenIfNeeded();
+    } catch (error) {
+      if (!this.accessToken || accessExpiresAt <= Date.now()) {
+        throw error;
+      }
+    }
+    if (this.authRevision !== authRevision) {
+      throw new JwtAuthSessionChangedError();
+    }
+    return this.hasValidAccessToken() ? this.buildAuthorizationContext(authRevision) : void 0;
+  }
+  /**
+   * 处理携带访问令牌的请求返回 401
+   * <p>若其他并发请求已经完成令牌轮换，则直接返回新令牌，不重复刷新</p>
+   * @param {JwtAuthorizationContext} failedAuthorization 失败请求使用的 Authorization 上下文
+   * @returns {Promise<JwtAuthorizationContext | undefined>}
+   */
+  async refreshAfterUnauthorized(failedAuthorization) {
+    if (this.authRevision !== failedAuthorization.revision) {
+      throw new JwtAuthSessionChangedError();
+    }
+    const currentAuthorization = this.hasValidAccessToken() ? this.buildAuthorizationHeader(this.accessToken) : void 0;
+    if (currentAuthorization && currentAuthorization !== failedAuthorization.header) {
+      return this.buildAuthorizationContext(failedAuthorization.revision, currentAuthorization);
+    }
+    await this.refreshAccessToken();
+    if (this.authRevision !== failedAuthorization.revision) {
+      throw new JwtAuthSessionChangedError();
+    }
+    return this.hasValidAccessToken() ? this.buildAuthorizationContext(failedAuthorization.revision) : void 0;
+  }
+  /**
+   * 恢复磁盘中的加密刷新会话
+   * @returns {Promise<void>}
+   * @private
+   */
+  async restoreRefreshSession() {
+    this.updateStateInitializing();
+    try {
+      const session = this.store.getSession();
+      if (!session) {
+        if (!this.store.isEncryptionAvailable()) {
+          this.onceLogEncryptionWarning();
+        }
+        this.updateStateUnauthenticated();
+        return;
+      }
+      if (session.refreshTokenExpiresAt <= Date.now()) {
+        this.clearSession("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+        return;
+      }
+      this.storedRefreshSession = session;
+      this.updateStateInitializing(session.user);
+      await this.refreshAccessTokenIfNeeded();
+    } catch (error) {
+      if (!this.storedRefreshSession) {
+        this.updateStateUnauthenticated(this.errorMessage(error));
+      }
+    }
+  }
+  /**
+   * 应用并保存服务端返回的认证结果
+   * @param {XoAuth.AuthResult} authResult 认证结果
+   * @returns {void}
+   * @private
+   */
+  applyAuthResult(authResult) {
+    this.validateTokenPair(authResult);
+    const storedSession = {
+      refreshToken: authResult.refreshToken,
+      refreshTokenExpiresAt: authResult.refreshTokenExpiresAt,
+      user: authResult.user ?? this.storedRefreshSession?.user
+    };
+    this.accessToken = authResult.accessToken;
+    this.accessTokenExpiresAt = authResult.accessTokenExpiresAt;
+    this.storedRefreshSession = storedSession;
+    this.persistRefreshSession(storedSession);
+    this.updateStateAuthenticated(storedSession.user);
+    this.scheduleRefresh();
+  }
+  /**
+   * 校验令牌对
+   * @param {XoAuth.TokenPair} tokenPair 令牌对
+   * @returns {void}
+   * @private
+   */
+  validateTokenPair(tokenPair) {
+    const now = Date.now();
+    if (!tokenPair.accessToken?.trim() || !Number.isFinite(tokenPair.accessTokenExpiresAt) || tokenPair.accessTokenExpiresAt <= now) {
+      throw new Error("\u670D\u52A1\u7AEF\u8FD4\u56DE\u7684\u8BBF\u95EE\u4EE4\u724C\u65E0\u6548");
+    }
+    if (!tokenPair.refreshToken?.trim() || !Number.isFinite(tokenPair.refreshTokenExpiresAt) || tokenPair.refreshTokenExpiresAt <= now) {
+      throw new Error("\u670D\u52A1\u7AEF\u8FD4\u56DE\u7684\u5237\u65B0\u4EE4\u724C\u65E0\u6548");
+    }
+  }
+  /**
+   * 持久化刷新会话
+   * <p>持久化失败时保留内存会话，避免将服务端已经成功的登录误判为失败</p>
+   * @param {XoAuth.StoredRefreshSession} session 刷新会话
+   * @returns {void}
+   * @private
+   */
+  persistRefreshSession(session) {
+    try {
+      if (!this.store.setSession(session)) {
+        this.onceLogEncryptionWarning();
+      }
+    } catch (error) {
+      this.xoApp.authLog.error("JWT \u767B\u5F55\u4F1A\u8BDD\u52A0\u5BC6\u5B58\u50A8\u5931\u8D25", error);
+    }
+  }
+  /**
+   * 安排访问令牌到期前自动刷新
+   * @returns {void}
+   * @private
+   */
+  scheduleRefresh() {
+    this.clearRefreshTimer();
+    if (!this.accessTokenExpiresAt || !this.storedRefreshSession) {
+      return;
+    }
+    const refreshBeforeExpiration = this.provider?.refreshBeforeExpiration ?? 0;
+    const delay = Math.max(1e3, this.accessTokenExpiresAt - Date.now() - refreshBeforeExpiration);
+    this.refreshTimer = setTimeout(() => {
+      void this.refreshAccessTokenIfNeeded().catch((error) => {
+        this.xoApp.authLog.warn("\u8BBF\u95EE\u4EE4\u724C\u81EA\u52A8\u5237\u65B0\u5931\u8D25", this.errorMessage(error));
+      });
+    }, delay);
+  }
+  /**
+   * 安排刷新失败后的重试
+   * @returns {void}
+   * @private
+   */
+  scheduleRefreshRetry() {
+    this.clearRefreshTimer();
+    if (!this.storedRefreshSession || this.storedRefreshSession.refreshTokenExpiresAt <= Date.now()) {
+      return;
+    }
+    const remaining = this.storedRefreshSession.refreshTokenExpiresAt - Date.now();
+    const retryDelay = this.provider?.refreshRetryDelay ?? remaining;
+    const delay = Math.max(1e3, Math.min(retryDelay, remaining));
+    this.refreshTimer = setTimeout(() => {
+      void this.refreshAccessToken().catch((error) => {
+        this.xoApp.authLog.warn("\u8BBF\u95EE\u4EE4\u724C\u91CD\u8BD5\u5237\u65B0\u5931\u8D25", this.errorMessage(error));
+      });
+    }, delay);
+  }
+  /**
+   * 清除本地会话
+   * @param {string} error 可选状态提示
+   * @returns {void}
+   * @private
+   */
+  clearSession(error) {
+    this.authRevision++;
+    this.refreshPromise = void 0;
+    this.clearRefreshTimer();
+    this.accessToken = void 0;
+    this.accessTokenExpiresAt = void 0;
+    this.storedRefreshSession = void 0;
+    this.store.clear();
+    this.updateStateUnauthenticated(error);
+  }
+  /**
+   * 清除自动刷新定时器
+   * @returns {void}
+   * @private
+   */
+  clearRefreshTimer() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+  }
+  /**
+   * 当前访问令牌是否有效
+   * @returns {boolean}
+   * @private
+   */
+  hasValidAccessToken() {
+    return Boolean(this.accessToken && this.accessTokenExpiresAt && this.accessTokenExpiresAt > Date.now());
+  }
+  /**
+   * 判断访问令牌是否需要刷新
+   * <p>访问令牌缺失、已经过期或进入 Provider 配置的提前刷新窗口时返回 true</p>
+   * @returns {boolean}
+   * @private
+   */
+  shouldRefreshAccessToken() {
+    const accessExpiresAt = this.accessTokenExpiresAt ?? 0;
+    const refreshBeforeExpiration = this.provider?.refreshBeforeExpiration ?? 0;
+    return !this.accessToken || accessExpiresAt <= Date.now() + refreshBeforeExpiration;
+  }
+  /**
+   * 构建 Authorization 请求头
+   * @param {string} accessToken 访问令牌
+   * @returns {string}
+   * @private
+   */
+  buildAuthorizationHeader(accessToken) {
+    const scheme = this.provider?.authorizationScheme.trim() || "Bearer";
+    return `${scheme} ${accessToken}`;
+  }
+  /**
+   * 构建设备标识请求头
+   * @returns {Readonly<Record<string, string>> | undefined}
+   * @private
+   */
+  getDeviceIdHeaders() {
+    if (!this.provider?.useDeviceIdHeader) {
+      return void 0;
+    }
+    return {
+      [this.provider.deviceIdHeaderName.trim()]: this.xoApp.getAppStore().getDeviceId()
+    };
+  }
+  /**
+   * 构建访问令牌请求头上下文
+   * @param {number} revision     认证操作版本
+   * @param {string} accessHeader 可选访问令牌请求头值
+   * @returns {JwtAuthorizationContext}
+   * @private
+   */
+  buildAuthorizationContext(revision, accessHeader) {
+    return {
+      headerName: this.provider?.authorizationHeaderName.trim() || "Authorization",
+      header: accessHeader ?? this.buildAuthorizationHeader(this.accessToken),
+      revision
+    };
+  }
+  /**
+   * 获取业务 Provider，未配置时抛出错误
+   * @returns {AnyJwtAuthProvider}
+   * @private
+   */
+  requireProvider() {
+    if (!this.provider) {
+      throw new Error("\u672A\u914D\u7F6E JWT \u8BA4\u8BC1 Provider");
+    }
+    return this.provider;
+  }
+  /**
+   * 校验刷新接口响应状态，确保 HTTP 状态码为 200
+   * @param {XoRemoteService.Response} response 响应
+   * @returns {void}
+   * @private
+   */
+  requireRefreshResponseStatusOK(response) {
+    if (response.status === 401 || response.status === 403) {
+      throw new JwtAuthRefreshRejectedError("\u5237\u65B0\u4EE4\u724C\u5DF2\u88AB\u670D\u52A1\u7AEF\u62D2\u7EDD");
+    }
+    this.requireResponseStatusOK(response, "\u5237\u65B0\u4EE4\u724C");
+  }
+  /**
+   * 更新状态并同步全部窗口
+   * @param {Partial<XoAuth.State>} state 状态变更
+   * @returns {void}
+   * @private
+   */
+  updateState(state) {
+    this.state = { ...this.state, ...state };
+    BrowserWindow.getAllWindows().forEach((window) => {
+      if (!window.isDestroyed() && !window.webContents.isDestroyed()) {
+        window.webContents.send(AuthChannels.onState, this.getState());
+      }
+    });
+  }
+  /**
+   * 更新为初始化状态
+   * @param {XoAuth.User} user 持久化的用户快照
+   * @returns {void}
+   * @private
+   */
+  updateStateInitializing(user) {
+    this.updateState({ status: "initializing", user, error: void 0 });
+  }
+  /**
+   * 更新为认证中状态
+   * @returns {void}
+   * @private
+   */
+  updateStateAuthenticating() {
+    this.updateState({ status: "authenticating", error: void 0 });
+  }
+  /**
+   * 更新为刷新中状态
+   * @returns {void}
+   * @private
+   */
+  updateStateRefreshing() {
+    this.updateState({ status: "refreshing", error: void 0 });
+  }
+  /**
+   * 更新为已认证状态
+   * @param {XoAuth.User} user 认证用户
+   * @param {string}      error 可选错误信息
+   * @returns {void}
+   * @private
+   */
+  updateStateAuthenticated(user, error) {
+    this.updateState({ status: "authenticated", user, error });
+  }
+  /**
+   * 更新为未认证状态
+   * @param {string} error 可选错误信息
+   * @returns {void}
+   * @private
+   */
+  updateStateUnauthenticated(error) {
+    this.updateState({ status: "unauthenticated", user: void 0, error });
+  }
+  /**
+   * 更新为错误状态
+   * @param {string} error 错误信息
+   * @returns {void}
+   * @private
+   */
+  updateStateError(error) {
+    this.updateState({ status: "error", error });
+  }
+  /**
+   * 校验接口响应状态，确保 HTTP 状态码为 200
+   * @param {XoRemoteService.Response} response 响应
+   * @param {string}                   action   操作名称
+   * @returns {void}
+   * @private
+   */
+  requireResponseStatusOK(response, action) {
+    if (response.status !== 200) {
+      throw new Error(`${action}\u5931\u8D25\uFF0CHTTP \u72B6\u6001\u7801 ${response.status}`);
+    }
+  }
+  /**
+   * 仅输出一次安全存储不可用警告
+   * @returns {void}
+   * @private
+   */
+  onceLogEncryptionWarning() {
+    if (this.encryptionWarningLogged) {
+      return;
+    }
+    this.encryptionWarningLogged = true;
+    this.xoApp.authLog.warn("safeStorage \u4E0D\u53EF\u7528\uFF0C\u5237\u65B0\u4EE4\u724C\u4EC5\u5728\u672C\u6B21\u8FD0\u884C\u671F\u95F4\u4FDD\u5B58\u5728\u5185\u5B58\u4E2D");
+  }
+  /**
+   * 获取错误信息
+   * @param {unknown} error 错误
+   * @returns {string}
+   * @private
+   */
+  errorMessage(error) {
+    return error instanceof Error ? error.message : String(error || "JWT \u8BA4\u8BC1\u5931\u8D25");
+  }
+};
+
+export {
+  JwtAuthRefreshRejectedError,
+  JwtAuthManager
+};