moonbridge-ts 0.1.0

package/src/moonbridge-ipc/general/transport/websocket/websocket_server.ts

@@ -0,0 +1,205 @@
+/**
+ * WebSocket 服务端，基于 HttpServer 升级为 WebSocket。
+ *
+ * 每收到一次 WebSocket 升级请求即生成一个 [SerialMessageChannel]（[WebSocketMessageChannel]），
+ * 通过 [onClientConnected] 交给上层，与 [SocketServer] 产出的 [SerialMessageSocket] 契约一致。
+ */
+
+import { SerialMessageChannel } from '../interface/serial_message_channel';
+import { WebSocketMessageChannel } from './websocket_message_channel';
+import { isNodeEnv } from '../../../utils/env';
+import { logger } from '../../../utils/logger';
+
+/**
+ * 封装服务器的 IP 地址和端口号信息
+ *
+ * 该类用于存储和展示服务器的 IP 地址和端口号信息。
+ */
+export class ServerAddressInfo {
+  /** 服务器的 IP 地址 */
+  readonly ip: string;
+  /** 服务器的端口号 */
+  readonly port: number;
+
+  constructor(ip: string, port: number) {
+    this.ip = ip;
+    this.port = port;
+  }
+
+  toString(): string {
+    return `IP: ${this.ip}, Port: ${this.port}`;
+  }
+}
+
+/**
+ * SocketServer 类用于处理服务器端的 TCP 通信。
+ *
+ * 它可以启动服务器并监听来自客户端的连接。
+ */
+export abstract class SocketServer {
+  /// 表示绑定到所有 IPv4 地址的常量
+  static readonly anyIPv4 = 'anyIPv4';
+
+  /// 表示绑定到所有 IPv6 地址的常量
+  static readonly anyIPv6 = 'anyIPv6';
+}
+
+
+/** 解析 address 为 Node http.listen 可用的地址 */
+function resolveAddress(address: string): string {
+  if (address === SocketServer.anyIPv4) return '0.0.0.0';
+  if (address === SocketServer.anyIPv6) return '::';
+  return address;
+}
+
+/** 校验 path 是否匹配（含 path 与 path/） */
+function isPathMatch(requestPath: string, expectedPath: string): boolean {
+  const pathname = requestPath.split('?')[0];
+  return pathname === expectedPath || pathname === `${expectedPath}/`;
+}
+
+/**
+ * WebSocket 服务端，基于 HttpServer 升级为 WebSocket。
+ * 仅支持 Node 环境，使用 ws + Node http。
+ */
+export class WebSocketServer {
+  /** 绑定地址，同 [SocketServer] 语义（如 `anyIPv4`） */
+  readonly address: string;
+  /** 监听端口（建议与 Socket 端口不同） */
+  readonly port: number;
+  /** 升级路径，如 `/` 或 `/ws` */
+  readonly path: string;
+
+  private _httpServer?: import('http').Server;
+  private _isServerRunning = false;
+  private _resolvedAddress: string = '';
+
+  /**
+   * 构造 WebSocket 服务端。
+   * @param address 绑定地址
+   * @param port 监听端口
+   * @param options.path 升级路径，默认 `'/'`
+   */
+  constructor(address: string, port: number, options?: { path?: string }) {
+    this.address = address;
+    this.port = port;
+    this.path = options?.path ?? '/';
+  }
+
+  /**
+   * 启动 HTTP 服务并处理 WebSocket 升级；每建立一个 WebSocket 连接即调用 [onClientConnected]。
+   * @param onClientConnected 客户端连接回调
+   * @returns true 表示启动成功，false 表示失败
+   */
+  async startServer(
+    onClientConnected: (channel: SerialMessageChannel) => void,
+  ): Promise<boolean> {
+    if (!isNodeEnv()) {
+      logger.fatal('WebSocketServer 仅支持 Node 环境');
+      return false;
+    }
+
+    try {
+      const http = await import('http');
+      const ws = await import('ws');
+
+      this._resolvedAddress = resolveAddress(this.address);
+      const server = http.createServer();
+
+      const wss = new ws.WebSocketServer({ noServer: true });
+
+      wss.on('connection', (wsSocket: import('ws').WebSocket, request: import('http').IncomingMessage) => {
+        const socket = request.socket;
+        const localAddress = this._resolvedAddress;
+        const localPort = this.port;
+        const remoteAddress = socket.remoteAddress ?? '127.0.0.1';
+        const remotePort = socket.remotePort ?? 0;
+
+        const channel = new WebSocketMessageChannel(wsSocket as unknown as WebSocket, {
+          address: localAddress,
+          port: localPort,
+          remoteAddress,
+          remotePort,
+          logger,
+        });
+        onClientConnected(channel);
+      });
+
+      server.on('upgrade', (request, socket, head) => {
+        const pathname = request.url?.split('?')[0] ?? '/';
+        if (!isPathMatch(pathname, this.path)) {
+          socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+        const upgradeHeader = request.headers.upgrade?.toLowerCase();
+        if (upgradeHeader !== 'websocket') {
+          socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+        wss.handleUpgrade(request, socket, head, (wsSocket: import('ws').WebSocket) => {
+          wss.emit('connection', wsSocket, request);
+        });
+      });
+
+      server.on('request', (request, response) => {
+        const pathname = request.url?.split('?')[0] ?? '/';
+        if (!isPathMatch(pathname, this.path)) {
+          response.writeHead(404);
+          response.end();
+          return;
+        }
+        response.writeHead(400);
+        response.end();
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        server.listen(this.port, this._resolvedAddress, () => resolve());
+        server.on('error', reject);
+      });
+
+      this._httpServer = server;
+      this._isServerRunning = true;
+
+      const addr = this._httpServer.address();
+      const host = typeof addr === 'object' && addr ? addr.address : this._resolvedAddress;
+      const port = typeof addr === 'object' && addr ? addr.port : this.port;
+      logger.info(`服务端 websocket 启动: ${host}:${port}`);
+
+      return true;
+    } catch (e) {
+      logger.fatal(`服务端 websocket 启动异常: ${e}`);
+      return false;
+    }
+  }
+
+  /**
+   * 关闭 HTTP 服务并停止接受新连接
+   */
+  async close(): Promise<void> {
+    if (this._httpServer) {
+      await new Promise<void>((resolve) => {
+        this._httpServer!.close(() => resolve());
+      });
+      this._httpServer = undefined;
+    }
+    this._isServerRunning = false;
+  }
+
+  /** 是否正在运行 */
+  get isServerRunning(): boolean {
+    return this._isServerRunning;
+  }
+
+  /** 本机地址与端口（若已启动） */
+  get serverAddressInfo(): ServerAddressInfo | undefined {
+    if (this._httpServer) {
+      const addr = this._httpServer.address();
+      if (addr && typeof addr === 'object') {
+        return new ServerAddressInfo(addr.address, addr.port);
+      }
+    }
+    return undefined;
+  }
+}

package/src/moonbridge-ipc/index.ts

@@ -0,0 +1,9 @@
+export * from './client/moonbridge_ipc_client';
+export * from './general';
+export * from './server/moonbridge_ipc_server';
+export * from './server/credential/client_identity';
+export * from './client/types/ipc_messenger';
+export * from './client/types/ipc_event_bus';
+export * from './client/types/ipc_message_strategy';
+export * from './client/types/ipc_types';
+export * from './extension/bridge_extension';

package/src/moonbridge-ipc/server/credential/client_identity.ts

@@ -0,0 +1,54 @@
+/**
+ * IPC 客户端身份信息类
+ *
+ * 该类用于封装 IPC 客户端的身份信息，包括客户端名称、应用路径和启动标识符。
+ *
+ * 适用于需要通过跨平台（如 Windows、macOS、iOS 和 Android）的应用身份管理和操作场景。
+ *
+ * - **clientName**: 客户端的名称，用于标识特定的客户端应用。
+ * - **appInstallationPath**: 表示应用在不同平台上的安装路径，可选。
+ * - **appLaunchIdentifier**: 应用的启动标识符信息，用于唤醒或启动应用程序，可选。
+ */
+
+import type { AppInstallationPath, AppLaunchIdentifier } from '../../general/app_launch/model/app_info';
+
+/** 提供客户端身份信息的函数类型 */
+export type ClientIdentityProvider = (clientName: string) => ClientIdentity | undefined;
+
+export class ClientIdentity {
+  /** 客户端名称 */
+  readonly clientName: string;
+
+  /** 应用的安装路径信息 */
+  readonly appInstallationPath?: AppInstallationPath;
+
+  /** 应用的启动标识符信息 */
+  readonly appLaunchIdentifier?: AppLaunchIdentifier;
+
+  /**
+   * 构造函数
+   *
+   * @param clientName 客户端名称，用于标识特定的 IPC 客户端
+   * @param options.appInstallationPath 客户端的安装路径信息，默认为空
+   * @param options.appLaunchIdentifier 客户端的启动标识符信息，默认为空
+   */
+  constructor(
+    clientName: string,
+    options?: {
+      appInstallationPath?: AppInstallationPath;
+      appLaunchIdentifier?: AppLaunchIdentifier;
+    },
+  ) {
+    this.clientName = clientName;
+    this.appInstallationPath = options?.appInstallationPath;
+    this.appLaunchIdentifier = options?.appLaunchIdentifier;
+  }
+
+  toString(): string {
+    return `ClientIdentity(
+  clientName: ${this.clientName}, 
+  appInstallationPath: ${this.appInstallationPath}, 
+  appLaunchIdentifier: ${this.appLaunchIdentifier}
+)`;
+  }
+}

package/src/moonbridge-ipc/server/internal/identity/client_identity_manager.ts

@@ -0,0 +1,42 @@
+/**
+ * IPC 客户端身份验证管理器类
+ *
+ * 该类用于管理和验证 IPC 客户端的身份信息。它通过维护一个客户端身份信息的映射表
+ * 和多个身份信息提供者来提供身份验证功能。
+ */
+
+import type { ClientIdentity, ClientIdentityProvider } from '../../credential/client_identity';
+
+export class ClientIdentityManager {
+  /** 客户端身份信息提供者列表 */
+  private readonly _providers: ClientIdentityProvider[] = [];
+
+  /**
+   * 添加客户端身份信息提供者
+   *
+   * 该方法用于添加一个客户端身份信息提供者到提供者列表中。
+   *
+   * @param provider 一个 [ClientIdentityProvider] 类型的函数，用于提供客户端身份信息
+   */
+  addClientIdentityProvider(provider: ClientIdentityProvider): void {
+    this._providers.push(provider);
+  }
+
+  /**
+   * 获取 IPC 客户端身份信息
+   *
+   * 该方法用于根据客户端名称获取对应的客户端身份信息。
+   *
+   * @param clientName 客户端名称
+   * @returns 对应的 [ClientIdentity] 对象，如果未找到则返回 null
+   */
+  getClientIdentity(clientName: string): ClientIdentity | undefined {
+    for (const provider of this._providers) {
+      const clientIdentity = provider(clientName);
+      if (clientIdentity != null) {
+        return clientIdentity;
+      }
+    }
+    return undefined;
+  }
+}