egos-transfer 0.2.5 → 0.2.7

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run *)"
+    ]
+  }
+}

package/dist/connection-manager.d.ts

@@ -0,0 +1,47 @@
+import { DataConnection, Peer } from 'peerjs';
+export interface ConnectionManagerDeps {
+    /** 获取当前 Peer 实例（PeerTransfer 可能异步重建） */
+    getPeer: () => Peer | undefined;
+    peerId: string;
+    ping: (peerId: string) => Promise<boolean>;
+    /** 连接关闭时回调，由 PeerTransfer 处理未完成的请求结算 */
+    onConnClosed: (conn: DataConnection) => void;
+}
+/**
+ * DataConnection 连接池管理器
+ * - 管理 DataConnection 的生命周期（注册/移除/有效性检查）
+ * - 15 秒定时健康检查：ping 每个连接，不通则丢弃
+ * - 监听 connectionstatechange，终态时自动清理
+ */
+export declare class ConnectionManager {
+    private pool;
+    private healthCheckTimer;
+    private pingRequests;
+    private destroyed;
+    private readonly deps;
+    constructor(deps: ConnectionManagerDeps);
+    get(peerId: string): DataConnection | undefined;
+    has(peerId: string): boolean;
+    get size(): number;
+    getAllPeers(): string[];
+    clean(): void;
+    /**
+     * 注册一个连接：入池、绑定 data/close/error/connectionstatechange 事件
+     * @param conn - 已打开的 DataConnection
+     * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
+     */
+    setup(conn: DataConnection, onData: (message: any) => void): DataConnection;
+    remove(peerId: string, connectionId?: string): void;
+    isValid(conn?: DataConnection): boolean;
+    private handleConnClosed;
+    startHealthCheck(): void;
+    stopHealthCheck(): void;
+    private checkAllConnections;
+    private pingConnection;
+    /**
+     * 由 PeerTransfer.onResponse 调用，优先处理 ping 回调
+     * @returns true 表示该 requestId 是 health check 并已处理
+     */
+    tryResolvePing(requestId: string): boolean;
+    destroy(): void;
+}

package/dist/connection-manager.js

@@ -0,0 +1,206 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const HEALTH_CHECK_INTERVAL = 15000;
+/**
+ * DataConnection 连接池管理器
+ * - 管理 DataConnection 的生命周期（注册/移除/有效性检查）
+ * - 15 秒定时健康检查：ping 每个连接，不通则丢弃
+ * - 监听 connectionstatechange，终态时自动清理
+ */
+class ConnectionManager {
+    constructor(deps) {
+        this.pool = new Map();
+        this.healthCheckTimer = null;
+        this.pingRequests = new Map();
+        this.destroyed = false;
+        this.deps = deps;
+    }
+    // ── Pool access ──────────────────────────────────────────────────
+    get(peerId) {
+        const conn = this.pool.get(peerId);
+        if (!conn) {
+            return;
+        }
+        if (this.isValid(conn)) {
+            return conn;
+        }
+        else {
+            this.remove(peerId);
+            return;
+        }
+    }
+    has(peerId) {
+        return this.pool.has(peerId);
+    }
+    get size() {
+        return this.pool.size;
+    }
+    getAllPeers() {
+        return Array.from(this.pool.keys());
+    }
+    clean() {
+        for (const peerId of this.getAllPeers()) {
+            this.remove(peerId);
+        }
+    }
+    // ── Connection lifecycle ─────────────────────────────────────────
+    /**
+     * 注册一个连接：入池、绑定 data/close/error/connectionstatechange 事件
+     * @param conn - 已打开的 DataConnection
+     * @param onData - 数据事件回调（由 PeerTransfer 提供，路由消息）
+     */
+    setup(conn, onData) {
+        this.pool.set(conn.peer, conn);
+        conn.on('data', onData);
+        conn.on('close', () => this.handleConnClosed(conn));
+        conn.on('error', () => this.handleConnClosed(conn));
+        // 监听底层 RTCPeerConnection 的 connectionstatechange，终态时自动清理
+        const pc = conn.peerConnection;
+        if (pc) {
+            const onStateChange = () => {
+                if (pc.connectionState === 'failed' || pc.connectionState === 'closed') {
+                    this.handleConnClosed(conn);
+                }
+            };
+            pc.addEventListener('connectionstatechange', onStateChange);
+            // 将清理函数挂到 conn 上，remove 时一并移除
+            conn.__cm_stateChangeCleanup = () => {
+                pc.removeEventListener('connectionstatechange', onStateChange);
+            };
+        }
+        return conn;
+    }
+    remove(peerId, connectionId) {
+        var _a, _b;
+        const conn = this.pool.get(peerId);
+        if (conn) {
+            if (connectionId && conn.connectionId !== connectionId)
+                return;
+            this.pool.delete(peerId);
+            // 清理 connectionstatechange listener
+            // (conn as any).__cm_stateChangeCleanup?.();
+            // conn.removeAllListeners();
+            // conn.close();
+            // this.deps.getPeer()?._removeConnection(conn);
+        }
+        else {
+            // 清理 Peer 内部残留的 connection 引用
+            const connections = ((_a = this.deps.getPeer()) === null || _a === void 0 ? void 0 : _a.connections) || {};
+            for (const c of connections[peerId] || []) {
+                c.removeAllListeners();
+                c.close();
+                (_b = this.deps.getPeer()) === null || _b === void 0 ? void 0 : _b._removeConnection(c);
+            }
+        }
+    }
+    isValid(conn) {
+        if (!(conn === null || conn === void 0 ? void 0 : conn.open))
+            return false;
+        if (!(conn === null || conn === void 0 ? void 0 : conn.peerConnection))
+            return false;
+        return ['connected', 'completed'].includes(conn.peerConnection.connectionState);
+    }
+    handleConnClosed(conn) {
+        this.pool.delete(conn.peer);
+        this.deps.onConnClosed(conn);
+    }
+    // ── Health check ─────────────────────────────────────────────────
+    startHealthCheck() {
+        if (this.destroyed)
+            return;
+        this.stopHealthCheck();
+        this.healthCheckTimer = setInterval(() => {
+            this.checkAllConnections();
+        }, HEALTH_CHECK_INTERVAL);
+    }
+    stopHealthCheck() {
+        if (this.healthCheckTimer !== null) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+    }
+    checkAllConnections() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const peers = this.getAllPeers();
+            for (const peerId of peers) {
+                const conn = this.pool.get(peerId);
+                if (!conn)
+                    continue;
+                const alive = yield this.pingConnection(conn);
+                if (!alive) {
+                    this.remove(peerId);
+                }
+            }
+        });
+    }
+    pingConnection(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.isValid(conn)) {
+                    return false;
+                }
+                return yield this.deps.ping(conn.peer);
+                // const requestId = await this.deps.genRequestId();
+                // return new Promise<boolean>((resolve) => {
+                //   const timer = setTimeout(() => {
+                //     this.pingRequests.delete(requestId);
+                //     resolve(false);
+                //   }, PING_TIMEOUT);
+                //   this.pingRequests.set(requestId, () => {
+                //     clearTimeout(timer);
+                //     resolve(true);
+                //   });
+                //   conn.send({
+                //     route: PeerRoutes.HEARTBEAT,
+                //     method: 'get',
+                //     body: {},
+                //     requestId,
+                //     scope: PeerScope.REQUEST,
+                //     action: PeerAction.SEND,
+                //     src: this.deps.peerId,
+                //     dest: conn.peer,
+                //     headers: {},
+                //     createdAt: Date.now(),
+                //   });
+                // });
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    /**
+     * 由 PeerTransfer.onResponse 调用，优先处理 ping 回调
+     * @returns true 表示该 requestId 是 health check 并已处理
+     */
+    tryResolvePing(requestId) {
+        const cb = this.pingRequests.get(requestId);
+        if (cb) {
+            cb({});
+            this.pingRequests.delete(requestId);
+            return true;
+        }
+        return false;
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────
+    destroy() {
+        this.destroyed = true;
+        this.stopHealthCheck();
+        for (const peerId of this.getAllPeers()) {
+            this.remove(peerId);
+        }
+        this.pool.clear();
+        this.pingRequests.clear();
+    }
+}
+exports.ConnectionManager = ConnectionManager;

package/dist/file-transfer.js

@@ -302,7 +302,6 @@ class FileTransfer {
             }
             if (processed.length === totalChunk) {
                 const checksum = yield this.taskService.verifyFile(task.transId);
-                console.log('file verify', checksum);
                 if (checksum) {
                     yield this.done(task);
                     yield this.updateTask(task.transId, {

package/dist/index.d.ts

@@ -1,119 +1,4 @@
-import { DataConnection, Peer, PeerOptions } from 'peerjs';
-import { IDeviceStatus, IMessage, PeerMessage, PeerRequestPayload, RequestCallbackFn, RouteItem } from './interfaces';
-import { InternalApi, PeerAction } from './entity';
-import { PeerRouter } from './router';
-export interface ContentPayload {
-    file: string;
-    parent: string;
-}
-type ResponseCb<T = any> = (args: T) => void;
-type PeerTransferOptions = PeerOptions & {
-    turnExpiredAt: number;
-};
-export declare abstract class PeerTransfer {
-    protected peer: Peer | undefined;
-    protected connectPool: Map<string, DataConnection>;
-    static connecting: Map<string, {
-        promise: Promise<any>;
-        resolve: (value: any | PromiseLike<any>) => void;
-        reject: (reason?: any) => void;
-    }>;
-    protected peerConfig: PeerTransferOptions | undefined;
-    readonly deviceId: string;
-    /** 接入 peerjs 服务端的 peerId，默认与 deviceId 相同 */
-    readonly peerId: string;
-    protected requests: Map<string, ResponseCb>;
-    /** 追踪 addRequest 的延时清理定时器，避免重试时误删新回调 */
-    protected requestTimers: Map<string, ReturnType<typeof setTimeout>>;
-    protected timeout: number;
-    protected router: PeerRouter;
-    protected booted: Promise<Peer | undefined> | undefined;
-    protected reconnectingPromise: Promise<Peer | undefined> | undefined;
-    protected checkerId: ReturnType<typeof setInterval> | null;
-    isPaused: boolean;
-    /** 重连尝试次数，成功连接后归零 */
-    protected reconnectAttempt: number;
-    /** 标记实例已销毁，防止异步操作继续 */
-    protected destroyed: boolean;
-    /** 按 requestId 追踪进行中的请求 */
-    private inRequest;
-    constructor(deviceId: string, config: PeerTransferOptions, isRandomPeerId?: boolean);
-    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>;
-    createPeer(force?: boolean): Promise<Peer | undefined>;
-    initialize(peer: Peer): Promise<Peer>;
-    handleSocketMessage(message: IMessage): void;
-    onHeartbeat(message: IMessage): void;
-    onError(message: IMessage): void;
-    onOpen(message: IMessage): void;
-    onDeviceOnline(message: IMessage): Promise<void>;
-    onDeviceOffline(message: IMessage): void;
-    removeConnection(peerId: string, connectionId?: string): void;
-    /**
-     * 连接关闭时尝试快速重连（5s 超时）：
-     * - 重连成功 → 保留 inRequest 条目，更新 conn 引用
-     * - 重连失败 → 触发 feedback 并清理 inRequest
-     */
-    private handleConnectionClose;
-    addConnection(conn: DataConnection): void;
-    checkConnection(): void;
-    getApiHost(): string;
-    getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined>;
-    connectToPeer(peerId: string): Promise<DataConnection | undefined>;
-    private createConnection;
-    /**
-     * 心跳检测 - 直接 send，不走 request 管线，避免重试放大
-     */
-    ping(peerId: string): Promise<boolean>;
-    onConnect(conn: DataConnection): Promise<DataConnection | undefined>;
-    /** 绑定 DataConnection 的 data 事件 */
-    private bindConnectionData;
-    request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage>;
-    /**
-     * 执行一次请求，返回带错误码的结果供外层判断是否重试
-     * @param peerId - 目标 peerId
-     * @param payload - 请求负载
-     * @param requestId - 请求ID（重试时复用）
-     * @returns error.code: CONN_CLOSED/CONN_FAILED（可重试）、TIMEOUT（不重试）
-     */
-    private doRequestOnce;
-    reply(conn: DataConnection, oldMessage: PeerMessage, message: {
-        body?: Record<string, any>;
-        headers?: Record<string, string | number>;
-        error?: string | Record<string, any>;
-    }): Promise<void>;
-    send(conn: DataConnection, message: PeerRequestPayload): Promise<void>;
-    inheritMessage(receiveMsg: PeerMessage): {
-        src: string;
-        id: string;
-        requestId: string;
-        route: string;
-        createdAt: string | number;
-        action: PeerAction;
-    };
-    reconnect(): Promise<Peer | undefined>;
-    isValidConnection(conn: DataConnection): boolean;
-    private doReconnect;
-    clearInstance(): void;
-    destroy(): void;
-    onRequest(conn: DataConnection, message: PeerMessage): Promise<void>;
-    onResponse(conn: DataConnection, message: PeerMessage): Promise<void>;
-    responseOk(conn: DataConnection, message: PeerMessage): Promise<void>;
-    responseFail(conn: DataConnection, message: PeerMessage, err: string | Record<string, any>): Promise<void>;
-    addRequest(id: string, cb: ResponseCb): void;
-    use(handler: RequestCallbackFn, prefix?: string): void;
-    addRoute(route: Omit<RouteItem, 'scope'>): void;
-    stop(): void;
-    resume(): Promise<Peer>;
-}
+export * from './peer-transfer';
 export * from './interfaces';
 export * from './handler';
 export * from './file-transfer';
@@ -123,3 +8,4 @@ export * from './locker';
 export * from './entity';
 export * from './http-transformer';
 export * from './http-transfer';
+export * from './connection-manager';