moonbridge-ts 0.1.0

package/src/moonbridge-ipc/server/internal/moonbridge_ipc_server.internal.ts

@@ -0,0 +1,441 @@
+/**
+ * MoonBridge IPC 服务器实现类
+ *
+ * 该类用于管理 IPC 服务器，包括启动服务器、处理客户端连接和消息等功能。
+ */
+
+import type { SerialMessageChannel } from '../../general/transport/interface/serial_message_channel';
+import {
+  sendResponse,
+  sendRequest,
+  sendEvent,
+  sendError,
+  sendPing,
+  sendHandshake,
+  sendSessionSetupResponse,
+} from '../../general/transport/interface/serial_message_channel_extension';
+import { WebSocketServer } from '../../general/transport/websocket/websocket_server';
+import { IpcMessageDecoder } from '../../general/encode/ipc_message_decoder';
+import { MessageType } from '../../general/message/constants/message_types';
+import { Handshake } from '../../general/message/handshake';
+import { IpcSessionSetupRequest, IpcSessionSetupResponse } from '../../general/message/session_setup';
+import { PlatformAppLauncherFactory } from '../../general/app_launch/platform_app_launcher';
+import type { WebSocketServerEndpoint } from '../../general/config/websocket_server_endpoint';
+import type {
+  MoonBridgeIpcServer,
+  WakeAppInterceptor,
+  DisconnectedCallback,
+  MessagePreprocessor,
+  OnMessageReceived,
+} from '../moonbridge_ipc_server';
+import type { ClientIdentity, ClientIdentityProvider } from '../credential/client_identity';
+import { ClientIdentityManager } from './identity/client_identity_manager';
+import type { Registration } from '../../general/message/registration';
+import type { Unregistration } from '../../general/message/unregistration';
+import type { Event } from '../../general/message/event';
+import type { Error } from '../../general/message/error';
+import type { Request } from '../../general/message/request';
+import type { Response } from '../../general/message/response';
+import { Ping } from '../../general/message/ping';
+import { logger } from '../../utils/logger';
+
+export class RealMoonBridgeIpcServer implements MoonBridgeIpcServer {
+  private readonly _serverName: string;
+  private readonly _wakeAppInterceptor?: WakeAppInterceptor;
+  private readonly _onClientDisconnected?: DisconnectedCallback;
+  private readonly _messagePreprocessor?: MessagePreprocessor;
+  private readonly _onMessageReceived?: OnMessageReceived;
+  private readonly _webSocketServerEndpoint?: WebSocketServerEndpoint;
+
+  private readonly _clientSocketMap = new Map<string, SerialMessageChannel>();
+  private readonly _addressToClientNameMap = new Map<string, string>();
+  private readonly _clientIdentityManager = new ClientIdentityManager();
+  private readonly _timerMap = new Map<string, ReturnType<typeof setTimeout>>();
+  private readonly _sessionSetupRequests = new Map<string, IpcSessionSetupRequest[]>();
+
+  private _webSocketServer?: WebSocketServer;
+
+  constructor(
+    serverName: string,
+    webSocketServerEndpoint?: WebSocketServerEndpoint,
+    wakeAppInterceptor?: WakeAppInterceptor,
+    clientIdentityProviders?: ClientIdentityProvider[],
+    onClientDisconnected?: DisconnectedCallback,
+    messagePreprocessor?: MessagePreprocessor,
+    onMessageReceived?: OnMessageReceived,
+  ) {
+    this._serverName = serverName;
+    this._webSocketServerEndpoint = webSocketServerEndpoint;
+    this._wakeAppInterceptor = wakeAppInterceptor;
+    this._onClientDisconnected = onClientDisconnected;
+    this._messagePreprocessor = messagePreprocessor;
+    this._onMessageReceived = onMessageReceived;
+
+    const providers = clientIdentityProviders ?? [];
+    for (const p of providers) {
+      this._clientIdentityManager.addClientIdentityProvider(p);
+    }
+  }
+
+  get serverName(): string {
+    return this._serverName;
+  }
+
+  async start(): Promise<boolean> {
+    const onClientConnected = (client: SerialMessageChannel) => {
+      let clientName = this._getClientName(client) ?? '';
+      client.subscribe(
+        (message: string) => {
+          this._onMessage(client, message);
+          if (clientName === '') {
+            clientName = this._getClientName(client) ?? '';
+          }
+        },
+        {
+          onError: (err) => {
+            logger.error(`客户端错误: ${String(err)}`);
+          },
+          onDone: () => {
+            logger.error(`客户端 ${clientName} 断开连接`);
+            this._removeClient(client);
+            this._onClientDisconnected?.(clientName);
+          },
+          cancelOnError: false,
+        },
+      );
+    };
+
+    if (this._webSocketServerEndpoint != null) {
+      const ep = this._webSocketServerEndpoint;
+      const portList =
+        ep.portCandidateRule != null
+          ? ep.portCandidateRule.toOrderedPortList()
+          : [ep.port];
+
+      for (const port of portList) {
+        const server = new WebSocketServer(ep.address, port, { path: ep.path });
+        if (await server.startServer(onClientConnected)) {
+          this._webSocketServer = server;
+          return true;
+        }
+      }
+    }
+
+    this._webSocketServer = undefined;
+    return false;
+  }
+
+  async stop(): Promise<void> {
+    if (this._webSocketServer != undefined) {
+      await this._webSocketServer.close();
+      this._webSocketServer = undefined;
+    }
+  }
+
+  get serverAddress(): string | undefined {
+    return this._webSocketServer?.serverAddressInfo?.ip ?? undefined;
+  }
+
+  get serverPort(): number | undefined {
+    return this._webSocketServer?.serverAddressInfo?.port ?? undefined;
+  }
+
+  private _addClient(clientIdentity: ClientIdentity, client: SerialMessageChannel): void {
+    const clientName = clientIdentity.clientName;
+    const clientAddress = this._getClientAddress(client);
+    this._clientSocketMap.set(clientName, client);
+    this._addressToClientNameMap.set(clientAddress, clientName);
+    logger.info(`客户端已连接: ${clientName}`);
+  }
+
+  private _removeClient(client: SerialMessageChannel): void {
+    const clientAddress = this._getClientAddress(client);
+    const clientName = this._addressToClientNameMap.get(clientAddress);
+    this._addressToClientNameMap.delete(clientAddress);
+    if (clientName != null) {
+      this._clientSocketMap.delete(clientName);
+    }
+    logger.info(`客户端已断开: ${clientName}`);
+  }
+
+  private _getClientName(client: SerialMessageChannel): string | undefined {
+    const clientAddress = this._getClientAddress(client);
+    return this._addressToClientNameMap.get(clientAddress);
+  }
+
+  private _getClientAddress(client: SerialMessageChannel): string {
+    return `${client.remoteAddress}:${client.remotePort}`;
+  }
+
+  private _onMessage(client: SerialMessageChannel, message: string): void {
+    logger.info(`服务端接收到消息，message: ${message}`);
+
+    const reply: (msg: string) => Promise<boolean> = (msg) => client.sendMessage(msg);
+    if (this._messagePreprocessor?.(reply, message) === true) {
+      return;
+    }
+
+    let messageType = MessageType.UNKNOWN;
+
+    if (message.includes(MessageType.REGISTRATION)) {
+      messageType = MessageType.REGISTRATION;
+      this._onRegistration(client, IpcMessageDecoder.decodeRegistration(message));
+    } else if (message.includes(MessageType.UNREGISTRATION)) {
+      messageType = MessageType.UNREGISTRATION;
+      this._onUnregistration(IpcMessageDecoder.decodeUnregistration(message));
+    } else if (message.includes(MessageType.EVENT)) {
+      messageType = MessageType.EVENT;
+      this._onEvent(IpcMessageDecoder.decodeEvent(message));
+    } else if (message.includes(MessageType.ERROR)) {
+      messageType = MessageType.ERROR;
+      this._onError(IpcMessageDecoder.decodeError(message));
+    } else if (message.includes(MessageType.REQUEST)) {
+      messageType = MessageType.REQUEST;
+      this._onRequest(IpcMessageDecoder.decodeRequest(message));
+    } else if (message.includes(MessageType.RESPONSE)) {
+      messageType = MessageType.RESPONSE;
+      this._onResponse(IpcMessageDecoder.decodeResponse(message));
+    } else if (message.includes(MessageType.SESSION_SETUP_REQUEST)) {
+      messageType = MessageType.SESSION_SETUP_REQUEST;
+      this._onSessionSetupRequest(IpcMessageDecoder.decodeSessionSetupRequest(message));
+    } else if (message.includes(MessageType.HANDSHAKE)) {
+      messageType = MessageType.HANDSHAKE;
+      this._onHandshake(IpcMessageDecoder.decodeHandshake(message), client);
+    } else if (message.includes(MessageType.PING)) {
+      messageType = MessageType.PING;
+      this._onPing(IpcMessageDecoder.decodePing(message));
+    } else {
+      logger.error(`无法识别的消息类型: ${message}`);
+    }
+
+    const clientName = this._getClientName(client) ?? '';
+    this._onMessageReceived?.(clientName, messageType, message);
+  }
+
+  private _onRegistration(client: SerialMessageChannel, registration: Registration): void {
+    const clientName = registration.clientName;
+    if (!this._validateClientIdentity(clientName)) {
+      logger.error(`客户端（${clientName}）不在白名单中，注册失败.`);
+      return;
+    }
+    const identity = this._clientIdentityManager.getClientIdentity(clientName)!;
+    this._addClient(identity, client);
+    this._cancelClientTimer(clientName);
+    this._processSessionSetupRequests(clientName);
+    logger.info(`客户端（${clientName}）注册成功.`);
+  }
+
+  private _onUnregistration(unregistration: Unregistration): void {
+    const clientName = unregistration.clientName;
+    this._clientSocketMap.delete(clientName);
+    this._sessionSetupRequests.delete(clientName);
+    const timer = this._timerMap.get(clientName);
+    if (timer != null) {
+      clearTimeout(timer);
+      this._timerMap.delete(clientName);
+    }
+    logger.info(`客户端（${clientName}）注销.`);
+  }
+
+  private _onEvent(event: Event): void {
+    const allClients = [...this._clientSocketMap.values()];
+    for (const client of allClients) {
+      sendEvent(client, event);
+    }
+    logger.info(`接收到 EventBus 事件，并转发给处于连接状态的所有客户端，event: ${event}.`);
+  }
+
+  private _onError(error: Error): void {
+    logger.info(`接收到错误消息，并转发给请求客户端，error: ${error}.`);
+    const fromClient = this._clientSocketMap.get(error.fromClient);
+    if (fromClient != null) {
+      sendError(fromClient, error);
+    }
+  }
+
+  private _onRequest(request: Request): void {
+    logger.info(`接收到请求消息，并转发给目标客户端，request: ${request}.`);
+    const toClient = this._clientSocketMap.get(request.toClient);
+    if (toClient != null) {
+      sendRequest(toClient, request);
+    }
+  }
+
+  private _onResponse(response: Response): void {
+    logger.info(`接收到响应消息，并转发给请求客户端，response: ${response}.`);
+    const fromClient = this._clientSocketMap.get(response.fromClient);
+    if (fromClient != null) {
+      sendResponse(fromClient, response);
+    }
+  }
+
+  private _onSessionSetupRequest(request: IpcSessionSetupRequest): void {
+    const targetClient = request.targetClient;
+    if (!this._validateClientIdentity(targetClient)) {
+      logger.error(`目标客户端(${targetClient})不在白名单内!`);
+      this._sendSessionSetupResponse(request, IpcSessionSetupResponse.failure, `Match target client(${targetClient}) failed!`);
+      return;
+    }
+    if (this._handleExistingTargetClient(request, targetClient)) {
+      logger.info(`与目标客户端(${targetClient})会话连接中.`);
+      return;
+    }
+    let queue = this._sessionSetupRequests.get(targetClient);
+    if (queue == null) {
+      queue = [];
+      this._sessionSetupRequests.set(targetClient, queue);
+    }
+    queue.push(request);
+    logger.info(`缓存目标客户端(${targetClient})唤醒动作至队列.`);
+    if (queue.length > 1) {
+      logger.info(`正在尝试唤醒目标客户端进程，追加回调至队列中，targetClient: ${targetClient}.`);
+      return;
+    }
+    if (request.autoLaunch) {
+      logger.info(`尝试唤醒目标客户端(${targetClient}).`);
+      this._wakeUpTargetClient(targetClient);
+    } else {
+      logger.info(`不尝试唤醒目标客户端(${targetClient})，直接返回失败.`);
+      this._sendSessionSetupResponse(request, IpcSessionSetupResponse.failure, `Target client(${targetClient}) was dead, and wake up is disabled!`);
+    }
+  }
+
+  private _onPing(_ping: Ping): void {
+    logger.info('接收到 Ping 消息');
+  }
+
+  private _onHandshake(handshake: Handshake, client: SerialMessageChannel): void {
+    if (handshake.magic !== Handshake.ipcMagic) {
+      logger.warn(`收到未知握手魔数(${handshake.magic})，忽略本次握手请求，可能是其他服务误连.`);
+      return;
+    }
+    if (handshake.role !== Handshake.clientRole) {
+      logger.warn(`收到非 client 角色的握手(${handshake.role})，忽略本次握手请求.`);
+      return;
+    }
+    const ack = new Handshake(
+      handshake.clientName,
+      Handshake.ipcMagic,
+      Handshake.serverRole,
+      Handshake.ipcVersion,
+    );
+    sendHandshake(client, ack);
+    logger.info(`完成与客户端的握手确认，clientName: ${ack.clientName}, magic: ${ack.magic}, version: ${ack.version}`);
+  }
+
+  private _validateClientIdentity(clientName: string): boolean {
+    const isValid = this._clientIdentityManager.getClientIdentity(clientName) != null;
+    if (!isValid) {
+      logger.fatal(`客户端(${clientName})不在白名单中，可能存在非法访问!`);
+    }
+    return isValid;
+  }
+
+  private _handleExistingTargetClient(request: IpcSessionSetupRequest, targetClient: string): boolean {
+    const targetSocket = this._clientSocketMap.get(targetClient);
+    if (targetSocket != null) {
+      try {
+        sendPing(targetSocket, new Ping(request.sourceClient));
+        this._sendSessionSetupResponse(request, IpcSessionSetupResponse.success, `Connecting with target client(${targetClient})!`);
+        return true;
+      } catch (e) {
+        logger.error(`Ping target client(${targetClient}) 失败!`);
+      }
+    }
+    return false;
+  }
+
+  private async _wakeUpTargetClient(targetClient: string): Promise<void> {
+    const clientIdentity = this._clientIdentityManager.getClientIdentity(targetClient);
+    if (clientIdentity == null) {
+      logger.fatal('唤醒目标客户端，白名单校验失败!');
+      return;
+    }
+    if (this._wakeAppInterceptor != null && this._wakeAppInterceptor(clientIdentity) === true) {
+      logger.info(`自定义方式唤醒目标客户端(${targetClient}).`);
+    } else {
+      logger.info(`默认方式唤醒目标客户端(${targetClient}).`);
+      try {
+        const appLauncher = PlatformAppLauncherFactory.create({
+          appIdentifier: clientIdentity.appLaunchIdentifier,
+          appInstallationPath: clientIdentity.appInstallationPath,
+        });
+        if (await appLauncher.isAppRunning()) {
+          logger.warn(`目标客户端(${targetClient})处于存活态，等待注册!`);
+        } else {
+          logger.info(`尝试唤醒目标客户端(${targetClient})!`);
+          await appLauncher.launchApp();
+        }
+      } catch (e) {
+        logger.fatal(`唤醒目标客户端发生异常：${String(e)}!`);
+      }
+    }
+    let timer = this._timerMap.get(targetClient);
+    if (timer == null) {
+      timer = setTimeout(() => {
+        logger.error(`唤醒目标客户端(${targetClient})超时`);
+        const queue = this._sessionSetupRequests.get(targetClient);
+        this._sessionSetupRequests.delete(targetClient);
+        this._timerMap.delete(targetClient);
+        if (queue != null) {
+          for (const req of queue) {
+            this._sendSessionSetupResponse(req, IpcSessionSetupResponse.failure, `Target client(${targetClient}) register time out!`);
+          }
+        } else {
+          logger.error('需要与目标客户端建立会话的发起端队列为空!');
+        }
+      }, 20_000);
+      this._timerMap.set(targetClient, timer);
+    }
+  }
+
+  private _sendSessionSetupResponse(request: IpcSessionSetupRequest, result: number, message: string): void {
+    const response = new IpcSessionSetupResponse(
+      request.sourceClient,
+      request.targetClient,
+      request.callbackId,
+      result,
+      message,
+      undefined,
+    );
+    const sourceSocket = this._clientSocketMap.get(request.sourceClient);
+    if (sourceSocket != null) {
+      logger.info(`通知请求发起端(${request.sourceClient})会话构建结果${result === IpcSessionSetupResponse.success ? '成功.' : '失败!'}`);
+      sendSessionSetupResponse(sourceSocket, response);
+    } else {
+      logger.error(`未匹配到通信发起端（${request.sourceClient}），检查是否已经关闭!`);
+    }
+  }
+
+  private _cancelClientTimer(clientName: string): void {
+    const timer = this._timerMap.get(clientName);
+    if (timer != null) {
+      clearTimeout(timer);
+      this._timerMap.delete(clientName);
+    }
+  }
+
+  private _processSessionSetupRequests(clientName: string): void {
+    const queue = this._sessionSetupRequests.get(clientName);
+    this._sessionSetupRequests.delete(clientName);
+    if (queue != null) {
+      for (const request of queue) {
+        const response = new IpcSessionSetupResponse(
+          request.sourceClient,
+          request.targetClient,
+          request.callbackId,
+          IpcSessionSetupResponse.success,
+          'Target client register success!',
+          undefined,
+        );
+        const sourceClient = this._clientSocketMap.get(request.sourceClient);
+        if (sourceClient != null) {
+          logger.info(`通知请求发起端(${request.sourceClient})会话构建成功.`);
+          sendSessionSetupResponse(sourceClient, response);
+        } else {
+          logger.error(`未匹配到通信发起端（${request.sourceClient}），检查是否已经关闭!`);
+        }
+      }
+    }
+  }
+}

package/src/moonbridge-ipc/server/moonbridge_ipc_server.ts

@@ -0,0 +1,149 @@
+/**
+ * MoonBridge IPC 服务器入口类
+ */
+
+import { SocketServer } from '../general/transport/websocket/websocket_server';
+import type { WebSocketServerEndpoint } from '../general/config/websocket_server_endpoint';
+import type { ClientIdentity, ClientIdentityProvider } from './credential/client_identity';
+import { RealMoonBridgeIpcServer } from './internal/moonbridge_ipc_server.internal';
+
+/** 消息回复函数，用于向客户端发送响应消息 */
+export type IpcMessageReply = (message: string) => Promise<boolean>;
+
+/** 唤醒客户端应用拦截器 */
+export type WakeAppInterceptor = (clientIdentity: ClientIdentity) => boolean;
+
+/** 客户端断开连接的回调函数 */
+export type DisconnectedCallback = (clientName: string) => void;
+
+/** 消息预处理器 */
+export type MessagePreprocessor = (reply: IpcMessageReply, message: string) => boolean;
+
+/** 消息接收回调 */
+export type OnMessageReceived = (clientName: string, type: string, message: string) => void;
+
+/**
+ * MoonBridge IPC 服务器抽象类
+ */
+export abstract class MoonBridgeIpcServer {
+  static readonly anyIPv4 = SocketServer.anyIPv4;
+  static readonly anyIPv6 = SocketServer.anyIPv6;
+
+  static builder(): MoonBridgeIpcServerBuilder {
+    return new MoonBridgeIpcServerBuilder();
+  }
+
+  abstract readonly serverName: string;
+  abstract start(): Promise<boolean>;
+  abstract stop(): Promise<void>;
+  abstract get serverAddress(): string | undefined;
+  abstract get serverPort(): number | undefined;
+}
+
+/**
+ * MoonBridge IPC 服务器构造器
+ */
+export class MoonBridgeIpcServerBuilder {
+  private _serverName = '';
+  private _webSocketServerEndpoint?: WebSocketServerEndpoint;
+  private _clientIdentityProviders?: ClientIdentityProvider[];
+  private _wakeAppInterceptor?: WakeAppInterceptor;
+  private _onClientDisconnected?: DisconnectedCallback;
+  private _messagePreprocessor?: MessagePreprocessor;
+  private _onMessageReceived?: OnMessageReceived;
+
+  /** 设置服务器名称 */
+  serverName(name: string): this {
+    this._serverName = name;
+    return this;
+  }
+
+  /** 设置 WebSocket 服务端通道监听配置；null 表示不启动 WebSocket。 */
+  useWebSocketChannel(endpoint: WebSocketServerEndpoint): this {
+    this._webSocketServerEndpoint = endpoint;
+    return this;
+  }
+
+  /** 设置客户端身份信息提供者列表 */
+  clientIdentityProviders(providers: ClientIdentityProvider[]): this {
+    this._clientIdentityProviders = providers;
+    return this;
+  }
+
+  /** 设置唤醒客户端应用的拦截器 */
+  wakeAppInterceptor(interceptor: WakeAppInterceptor): this {
+    this._wakeAppInterceptor = interceptor;
+    return this;
+  }
+
+  /** 设置客户端断开连接的回调函数 */
+  onClientDisconnected(callback: DisconnectedCallback): this {
+    this._onClientDisconnected = callback;
+    return this;
+  }
+
+  /** 设置消息预处理器 */
+  messagePreprocessor(preprocessor: MessagePreprocessor): this {
+    this._messagePreprocessor = preprocessor;
+    return this;
+  }
+
+  /** 设置消息接收回调 */
+  onMessageReceived(callback: OnMessageReceived): this {
+    this._onMessageReceived = callback;
+    return this;
+  }
+
+  /**
+   * 构建并返回配置完成的服务器实例
+   * @param makeDefault 是否将该服务器实例设置为默认服务器，默认为 false
+   */
+  build(makeDefault = false): MoonBridgeIpcServer {
+    if (this._webSocketServerEndpoint == null) {
+      throw new Error(
+        'TS 端仅支持 WebSocket 通道，请使用 useWebSocketChannel 设置传输配置。',
+      );
+    }
+
+    const server = new RealMoonBridgeIpcServer(
+      this._serverName,
+      this._webSocketServerEndpoint,
+      this._wakeAppInterceptor,
+      this._clientIdentityProviders,
+      this._onClientDisconnected,
+      this._messagePreprocessor,
+      this._onMessageReceived,
+    );
+
+    MoonBridgeIpcServerRegistry.instance.register(server);
+
+    if (makeDefault) {
+      MoonBridgeIpcServerRegistry.instance.setDefault(server);
+    }
+    return server;
+  }
+}
+
+/**
+ * MoonBridge IPC 服务端注册器
+ */
+export class MoonBridgeIpcServerRegistry {
+  private static _instance?: MoonBridgeIpcServerRegistry;
+  private readonly _serverMap = new Map<string, MoonBridgeIpcServer>();
+
+  static get instance(): MoonBridgeIpcServerRegistry {
+    return MoonBridgeIpcServerRegistry._instance ??= new MoonBridgeIpcServerRegistry();
+  }
+
+  setDefault(server: MoonBridgeIpcServer): void {
+    this._serverMap.set('__default__', server);
+  }
+
+  register(server: MoonBridgeIpcServer): void {
+    this._serverMap.set(server.serverName, server);
+  }
+
+  get(serverName?: string): MoonBridgeIpcServer | undefined {
+    return this._serverMap.get(serverName ?? '__default__');
+  }
+}

package/src/moonbridge-ipc/utils/env.ts

@@ -0,0 +1,7 @@
+/**
+ * 判断当前是否为 Node.js 环境。
+ * @returns true 表示 Node 环境，false 表示浏览器环境
+ */
+export function isNodeEnv(): boolean {
+  return typeof window === 'undefined' && typeof process !== 'undefined';
+}

package/src/moonbridge-ipc/utils/logger.ts

@@ -0,0 +1,6 @@
+/**
+ * moonbridge-ipc 模块共享 logger 实例，tag 为 moonbridge-ipc。
+ */
+import { Logger } from '../../moonbridge/logger/logger';
+
+export const logger = Logger.get('moonbridge-ipc');

package/src/moonbridge-ipc/utils/string_utils.ts

@@ -0,0 +1,21 @@
+/**
+ * 字符串工具，对应 Flutter lib/general/utils/string_utils.dart StringExtension.generateRandomString。
+ */
+
+// CONSTANTS
+
+const CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+// PUBLIC METHODS
+
+/**
+ * 生成指定长度的随机字符串。
+ * @param length - 长度，默认 8
+ */
+export function generateRandomString(length: number = 8): string {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += CHARACTERS.charAt(Math.floor(Math.random() * CHARACTERS.length));
+  }
+  return result;
+}

package/src/wps-launcher/index.ts

@@ -0,0 +1,4 @@
+/**
+ * wps-launcher 入口：导出 createWpsAppLauncher。
+ */
+export * from './launcher/wps_app_launcher';