egos-transfer 0.2.4 → 0.2.6

package/src/interfaces.ts

@@ -188,6 +188,11 @@ export interface MiddlewareItem {
   errorHandler?: (error: Error) => void;
 }
 
+export enum MessageRole {
+  Agent = 'agent',
+  User = 'user',
+}
+
 export type DataMessage = {
   id: string;
   src: string;
@@ -204,6 +209,8 @@ export type DataMessage = {
   priority?: TransferPriority;
   retryCount?: number;
   metadata?: Record<string, any>;
+  sessionId?: string;
+  role?: MessageRole;
 };
 
 export interface MetaData {

package/src/peer-transfer.ts

@@ -0,0 +1,671 @@
+import {
+  CONNECTION_DUPLICATED,
+  CONNECTION_LIMIT_EXCEED,
+  CONNECTION_PEER_CONFLICT,
+  CONNECTION_TIMEOUT,
+  PEER_OPEN_TIMEOUT,
+  PING_TIMEOUT,
+  UNAUTHORIZED,
+} from './constant';
+import { DataConnection, Peer, PeerOptions } from 'peerjs';
+import {
+  IDeviceStatus,
+  IMessage,
+  PeerMessage,
+  PeerRequestPayload,
+  RequestCallbackFn,
+  RouteItem,
+} from './interfaces';
+import { InternalApi, PeerAction, PeerRoutes, PeerScope, REQUEST_TIMEOUT } from './entity';
+
+import { ConnectionManager } from './connection-manager';
+import { PeerRouter } from './router';
+import axios from 'axios';
+import delay from 'delay';
+
+export interface ContentPayload {
+  file: string;
+  parent: string;
+}
+
+type ResponseCb<T = any> = (args: T) => void;
+type PeerTransferOptions = PeerOptions & {
+  turnExpiredAt: number;
+};
+
+const MAX_RECONNECT_BACKOFF = 30000;
+const BASE_RECONNECT_BACKOFF = 1000;
+/** 30 分钟无消息活动则重建 Peer，防止长时间空闲后 signaling 连接僵死 */
+const IDLE_RECREATE_TIMEOUT = 30 * 60 * 1000;
+/** 30 秒未收到服务端 HEARTBEAT 则重连 */
+const HEARTBEAT_TIMEOUT = 30000;
+
+export const PEER_CLOSE_RECONNECT_TIMEOUT = 3000;
+
+export abstract class PeerTransfer {
+  protected peer: Peer | undefined;
+  protected connectionManager: ConnectionManager;
+  protected peerConfig: PeerTransferOptions | undefined;
+  public readonly deviceId: string;
+  public readonly peerId: string;
+  protected requests = new Map<string, ResponseCb>();
+  protected router = new PeerRouter();
+  protected reconnectAttempt = 0;
+  protected destroyed = false;
+
+  /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
+  private connRequests = new Map<string, Set<string>>();
+  private _reconnecting = false;
+  /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
+  private _exited = false;
+  /** 空闲重连定时器：超时无消息活动则重建 Peer */
+  private idleTimer: ReturnType<typeof setTimeout> | null = null;
+  /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
+  private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(deviceId: string, config: PeerTransferOptions) {
+    this.peerConfig = { ...config, key: String(Date.now()) };
+    this.peerId = deviceId;
+    this.deviceId = deviceId;
+    this.connectionManager = new ConnectionManager({
+      getPeer: () => this.peer,
+      peerId: this.peerId,
+      onConnClosed: (conn) => this.onConnClosed(conn),
+      ping: (peerId: string) => this.ping(peerId),
+    });
+  }
+
+  abstract getStore(): any;
+  abstract online(deviceId: string): void;
+  abstract offline(deviceId: string): void;
+  abstract genRequestId(): Promise<string>;
+  abstract getApi(peerId: string): Promise<InternalApi | undefined>;
+  abstract discoverDeviceById(deviceId: string): Promise<void>;
+  abstract onDestroy(): void;
+  abstract requireAuth(): Promise<void>;
+  abstract onConnectLimit(): void;
+  abstract reloadConfig(config?: Record<string, any>): Promise<void>;
+
+  // ── Peer lifecycle ──────────────────────────────────────────────
+
+  async createPeer(force?: boolean): Promise<Peer> {
+    console.info('createPeer##', this.peer?.open, force);
+    this._exited = false;
+    if (this.peer?.open && !force) {
+      return this.peer;
+    }
+    this.destroyPeer();
+    await this.reloadConfig();
+
+    const peer = new Peer(this.peerId, { ...this.peerConfig, pingInterval: 9000 });
+    this.peer = peer;
+
+    await this.waitForOpen(peer);
+    this.destroyed = false;
+    peer.on('close', () => {
+      setTimeout(() => this.destroyed && this.reconnect(), PEER_CLOSE_RECONNECT_TIMEOUT);
+    });
+
+    peer.on('error', (err) => {
+      // 覆盖所有与 signaling server 断连相关的错误类型
+      if (
+        err.type === 'network' ||
+        err.type === 'server-error' ||
+        err.type === 'disconnected' ||
+        err.type === 'socket-error' ||
+        err.type === 'socket-closed'
+      ) {
+        this.reconnect();
+      }
+    });
+
+    peer.on('connection', (conn: DataConnection) => {
+      conn.label = 'incoming';
+      this.onConnect(conn);
+    });
+
+    const socket = peer.socket;
+    socket?.on('message', (message: IMessage) => {
+      this.handleSocketMessage(message);
+    });
+
+    // 启动连接健康检查
+    this.connectionManager.startHealthCheck();
+
+    // 启动空闲重连定时器
+    this.resetIdleTimer();
+
+    // 启动心跳超时定时器
+    this.resetHeartbeatTimer();
+
+    return peer;
+  }
+
+  private waitForOpen(peer: Peer): Promise<void> {
+    return new Promise<void>((resolve) => {
+      const timer = setTimeout(() => resolve(), PEER_OPEN_TIMEOUT);
+
+      peer.on('open', () => {
+        clearTimeout(timer);
+        this.reconnectAttempt = 0;
+        resolve();
+      });
+
+      peer.once('error', (err) => {
+        if (err.message === CONNECTION_DUPLICATED) {
+          clearTimeout(timer);
+          // signaling server 仍持有旧连接，主动 destroy 以清理服务端状态
+          peer.destroy();
+          resolve();
+          return;
+        }
+        clearTimeout(timer);
+        if (err.message === CONNECTION_PEER_CONFLICT) {
+          resolve();
+          return;
+        }
+        if (err.message === CONNECTION_LIMIT_EXCEED) {
+          this.onConnectLimit();
+          resolve();
+          return;
+        }
+        if (err.message === UNAUTHORIZED) {
+          this.requireAuth();
+          resolve();
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  handleSocketMessage(message: IMessage) {
+    switch (message.type) {
+      case 'ONLINE':
+        this.online(message.payload.deviceId);
+        break;
+      case 'OFFLINE':
+        this.ping(message.payload.deviceId);
+        break;
+      case 'HEARTBEAT':
+        this.resetHeartbeatTimer();
+        break;
+      case 'ERROR':
+        if (message.payload?.msg === CONNECTION_PEER_CONFLICT) {
+          this.getStore().dispatch({
+            type: 'global/updateNetworkState',
+            payload: { error: true, code: 'PEER_CONNECTION_CONFLICT', message: 'peer conflict' },
+          });
+        }
+        break;
+    }
+  }
+
+  // ── Connection management ───────────────────────────────────────
+
+  async connectToPeer(peerId: string): Promise<DataConnection | undefined> {
+    if (peerId === this.deviceId) return;
+
+    const existing = this.connectionManager.get(peerId);
+    if (existing) {
+      return existing;
+    }
+
+    return this.createConnection(peerId);
+  }
+
+  private async createConnection(peerId: string): Promise<DataConnection | undefined> {
+    for (let retry = 0; retry < 3; retry++) {
+      if (!this.peer?.open) {
+        try {
+          await this.createPeer();
+        } catch {
+          /* fall through */
+        }
+      }
+      if (!this.peer?.open) continue;
+
+      const pooled = this.connectionManager.get(peerId);
+      if (pooled) {
+        return pooled;
+      }
+
+      const conn = this.peer.connect(peerId, {
+        label: 'outgoing',
+        metadata: { time: Date.now() },
+      });
+      if (!conn) continue;
+
+      const result = await this.onConnect(conn as DataConnection).catch(() => undefined);
+      if (result) {
+        return result;
+      }
+
+      const pooled2 = this.connectionManager.get(peerId);
+      if (pooled2) {
+        return pooled2;
+      }
+    }
+    // 所有重试均失败，强制销毁 peer 以确保下次连接使用全新实例
+    // (peer.open 可能在 signaling socket 已断连的情况下仍返回 true)
+    if (!this.destroyed) {
+      this.destroyPeer();
+    }
+    return undefined;
+  }
+
+  async onConnect(conn: DataConnection): Promise<DataConnection | undefined> {
+    if (!conn) return;
+
+    if (conn.open) {
+      this.setupConnection(conn);
+      return conn;
+    }
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        conn.off('open', onOpen);
+        conn.off('error', onError);
+        conn.off('close', onClose);
+        resolve(this.isValidConnection(conn) ? this.setupConnection(conn) : undefined);
+      }, CONNECTION_TIMEOUT);
+
+      const onOpen = () => {
+        clearTimeout(timer);
+        resolve(this.setupConnection(conn));
+      };
+
+      const onError = () => {
+        clearTimeout(timer);
+        const pooled = this.connectionManager.get(conn.peer);
+        resolve(pooled);
+      };
+
+      const onClose = () => {
+        clearTimeout(timer);
+        resolve(undefined);
+        this.removeConnection(conn.peer, conn.connectionId);
+      };
+
+      conn.once('open', onOpen);
+      conn.once('error', onError);
+      conn.once('close', onClose);
+    });
+  }
+
+  private setupConnection(conn: DataConnection): DataConnection {
+    return this.connectionManager.setup(conn, (message: any) => {
+      switch (message.scope) {
+        case PeerScope.REQUEST:
+          return this.onRequest(conn, message);
+        case PeerScope.RESPONSE:
+          return this.onResponse(conn, message);
+        default:
+          return this.responseFail(conn, message, 'unknown scope');
+      }
+    });
+  }
+
+  private onConnClosed(conn: DataConnection) {
+    const reqIds = this.connRequests.get(conn.connectionId);
+    if (reqIds) {
+      // for (const reqId of reqIds) {
+      //   const cb = this.requests.get(reqId);
+      //   if (cb) {
+      //     cb({ error: { message: 'connection closed', code: 'CONN_CLOSED' } } as any);
+      //     this.requests.delete(reqId);
+      //   }
+      // }
+      this.connRequests.delete(conn.connectionId);
+    }
+  }
+
+  removeConnection(peerId: string, connectionId?: string) {
+    this.connectionManager.remove(peerId, connectionId);
+  }
+
+  isValidConnection(conn?: DataConnection): boolean {
+    return this.connectionManager.isValid(conn);
+  }
+
+  // ── Request / Reply ─────────────────────────────────────────────
+
+  async request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage> {
+    const requestId = payload.requestId || (await this.genRequestId());
+    let res: PeerMessage;
+    for (let attempt = 0; attempt <= 2; payload.route, attempt++) {
+      res = await this.doRequestOnce(peerId, payload, requestId);
+      const code = (res.error as Record<string, any>)?.code;
+      if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED')) {
+        return res;
+      }
+    }
+    return res!;
+  }
+
+  private async doRequestOnce(
+    peerId: string,
+    payload: PeerRequestPayload,
+    requestId: string,
+  ): Promise<PeerMessage> {
+    if (this.destroyed) {
+      return { ...payload, body: {}, error: { message: 'destroyed', code: 'CONN_CLOSED' } } as any;
+    }
+
+    const conn = await this.connectToPeer(peerId);
+    if (!this.isValidConnection(conn)) {
+      return {
+        ...payload,
+        body: {},
+        error: { message: 'connection failed', code: 'CONN_FAILED' },
+      } as any;
+    }
+
+    return new Promise((resolve) => {
+      let timeout: ReturnType<typeof setTimeout> | null = null;
+
+      const cleanup = () => {
+        if (timeout) {
+          clearTimeout(timeout);
+          timeout = null;
+        }
+        this.requests.delete(requestId);
+        const reqs = this.connRequests.get(conn.connectionId);
+        if (reqs) {
+          reqs.delete(requestId);
+          // connection pool cleanup
+          if (reqs.size === 0) {
+            this.connRequests.delete(conn.connectionId);
+          }
+        }
+      };
+
+      timeout = setTimeout(() => {
+        cleanup();
+        if (!this.isValidConnection(conn)) {
+          this.removeConnection(conn.peer, conn.connectionId);
+        }
+
+        resolve({ ...payload, body: {}, error: { message: 'timeout', code: 'TIMEOUT' } } as any);
+      }, payload.timeout || REQUEST_TIMEOUT);
+
+      let reqs = this.connRequests.get(conn.connectionId);
+      if (!reqs) {
+        reqs = new Set();
+        this.connRequests.set(conn.connectionId, reqs);
+      }
+      reqs.add(requestId);
+
+      this.requests.set(requestId, (message: Record<string, any>) => {
+        cleanup();
+        resolve(message as any);
+      });
+
+      this.send(conn, { ...payload, requestId }).catch(() => {
+        cleanup();
+        resolve({
+          ...payload,
+          body: {},
+          error: { message: 'send failed', code: 'CONN_CLOSED' },
+        } as any);
+      });
+    });
+  }
+
+  async reply(
+    conn: DataConnection,
+    oldMessage: PeerMessage,
+    message: {
+      body?: Record<string, any>;
+      headers?: Record<string, string | number>;
+      error?: string | Record<string, any>;
+    },
+  ) {
+    const data = {
+      ...this.inheritMessage(oldMessage),
+      ...message,
+      dest: conn.peer,
+      scope: PeerScope.RESPONSE,
+      updatedAt: Date.now(),
+    };
+    if (!this.isValidConnection(conn)) {
+      const c = await this.connectToPeer(conn.peer);
+      return c?.send(data);
+    }
+    return conn.send(data);
+  }
+
+  async send(conn: DataConnection, message: PeerRequestPayload) {
+    const internalApi = await this.getApi(conn.peer);
+    let connection = conn;
+    if (!this.isValidConnection(conn)) {
+      const c = await this.connectToPeer(conn.peer);
+      if (!c)
+        return this.responseFail(conn, message as PeerMessage, 'send with invalid connection');
+      connection = c;
+    }
+    const requestId = message.requestId || (await this.genRequestId());
+    return connection.send(
+      {
+        ...message,
+        requestId,
+        headers: { ...message.headers, ['x-device-token']: internalApi?.token },
+        scope: PeerScope.REQUEST,
+        action: PeerAction.SEND,
+        src: this.peerId,
+        dest: conn.peer,
+        createdAt: Date.now(),
+      },
+      false,
+    );
+  }
+
+  // ── Ping ────────────────────────────────────────────────────────
+
+  async ping(peerId: string): Promise<boolean> {
+    if (this.deviceId === peerId) {
+      return false;
+    }
+    const conn = this.connectionManager.get(peerId);
+    if (!conn) {
+      return false;
+    }
+    try {
+      const requestId = await this.genRequestId();
+      return new Promise<boolean>((resolve) => {
+        const timer = setTimeout(() => {
+          this.requests.delete(requestId);
+          resolve(false);
+        }, PING_TIMEOUT);
+        this.requests.set(requestId, () => {
+          clearTimeout(timer);
+          resolve(true);
+        });
+        conn.send({
+          route: PeerRoutes.HEARTBEAT,
+          method: 'get',
+          body: {},
+          requestId,
+          scope: PeerScope.REQUEST,
+          action: PeerAction.SEND,
+          src: this.peerId,
+          dest: peerId,
+          headers: {},
+          createdAt: Date.now(),
+        });
+      });
+    } catch {
+      return false;
+    }
+  }
+
+  // ── Server helpers ──────────────────────────────────────────────
+
+  getApiHost() {
+    const protocol = this.peerConfig?.secure ? 'https' : 'http';
+    const host = this.peerConfig?.host || 'localhost';
+    const port = this.peerConfig?.port || 9000;
+    return `${protocol}://${host}:${port}`;
+  }
+
+  async getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined> {
+    try {
+      const res = await axios.get(`${this.getApiHost()}/api/v1/devices/${peerId}/status`);
+      if (res.status < 400) return (res.data as { data: IDeviceStatus }).data;
+    } catch {
+      /* ignore */
+    }
+  }
+
+  // ── Reconnection ────────────────────────────────────────────────
+
+  async reconnect(force?: boolean): Promise<Peer | undefined> {
+    if (this._reconnecting || this._exited) return;
+    this._reconnecting = true;
+    try {
+      this.reconnectAttempt++;
+      const backoff = Math.min(
+        BASE_RECONNECT_BACKOFF * Math.pow(2, this.reconnectAttempt - 1),
+        MAX_RECONNECT_BACKOFF,
+      );
+      await delay(backoff);
+      await this.reloadConfig();
+      return await this.createPeer(force);
+    } catch {
+      return this.createPeer(force);
+    } finally {
+      this._reconnecting = false;
+    }
+  }
+
+  // ── Message helpers ─────────────────────────────────────────────
+
+  inheritMessage(receiveMsg: PeerMessage) {
+    return {
+      src: this.peerId,
+      id: receiveMsg.id,
+      requestId: receiveMsg.requestId,
+      route: receiveMsg.route,
+      createdAt: receiveMsg.createdAt,
+      action: PeerAction.RECEIVE,
+    };
+  }
+
+  // ── Router integration ──────────────────────────────────────────
+
+  async onRequest(conn: DataConnection, message: PeerMessage) {
+    this.resetIdleTimer();
+    try {
+      await this.router.run(conn, message);
+    } catch (err: any) {
+      this.responseFail(conn, message, { message: err.message, code: err.code });
+    }
+  }
+
+  async onResponse(_conn: DataConnection, message: PeerMessage) {
+    this.resetIdleTimer();
+    // 优先检查 health check ping 回调
+    const cb = this.requests.get(message.requestId);
+    if (cb) {
+      cb.apply(this, [message]);
+      this.requests.delete(message.requestId);
+    }
+  }
+
+  async responseOk(conn: DataConnection, message: PeerMessage) {
+    return this.reply(conn, message, { body: { ok: true } });
+  }
+
+  async responseFail(
+    conn: DataConnection,
+    message: PeerMessage,
+    err: string | Record<string, any>,
+  ) {
+    return this.reply(conn, message, { body: {}, error: err || 'service error' });
+  }
+
+  use(handler: RequestCallbackFn, prefix = '') {
+    this.router.use(handler, prefix);
+  }
+
+  addRoute(route: Omit<RouteItem, 'scope'>) {
+    this.router.add(route);
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────────────
+
+  private resetIdleTimer(): void {
+    if (this.idleTimer !== null) {
+      clearTimeout(this.idleTimer);
+    }
+    this.idleTimer = setTimeout(() => {
+      if (!this.destroyed) {
+        this.reconnect(true);
+      }
+    }, IDLE_RECREATE_TIMEOUT);
+  }
+
+  private clearIdleTimer(): void {
+    if (this.idleTimer !== null) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+
+  private resetHeartbeatTimer(): void {
+    if (this.heartbeatTimer !== null) {
+      clearTimeout(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setTimeout(() => {
+      if (!this.destroyed) {
+        this.reconnect(true);
+      }
+    }, HEARTBEAT_TIMEOUT);
+  }
+
+  private clearHeartbeatTimer(): void {
+    if (this.heartbeatTimer !== null) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  clearInstance() {
+    this.destroyed = true;
+    this.clearIdleTimer();
+    this.clearHeartbeatTimer();
+
+    this.connectionManager.destroy();
+
+    this.requests.clear();
+    this.connRequests.clear();
+    this.destroyPeer();
+  }
+
+  destroy() {
+    this.clearInstance();
+    this.onDestroy();
+  }
+
+  /**
+   * 退出：关闭 peer 和所有连接，停止自动重连。
+   * 与 destroy   stop 后仍可调用 createPeer 恢复工作。
+   */
+  stop() {
+    this._exited = true;
+    this.clearIdleTimer();
+    this.clearHeartbeatTimer();
+    this.connectionManager.stopHealthCheck();
+    this.connectionManager.clean();
+    this.requests.clear();
+    this.connRequests.clear();
+    this.destroyPeer();
+    this.reconnectAttempt = 0;
+  }
+
+  private destroyPeer() {
+    this.peer?.destroy();
+    this.peer?.removeAllListeners();
+    this.peer = undefined;
+  }
+}

package/src/server.ts

@@ -4,11 +4,6 @@ import { DataConnection } from 'peerjs';
 import { PeerRouter } from './router';
 import { PeerTransfer } from './index';
 
-export interface ContentPayload {
-  file: string;
-  parent: string;
-}
-
 type ResponseCb<T = any> = (args: T) => void;
 
 type SetupServerCB = () => Promise<PeerTransfer>;