egos-transfer 0.2.6 → 0.2.8

package/dist/index.js

@@ -13,502 +13,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeerTransfer = void 0;
-const constant_1 = require("./constant");
-const peerjs_1 = require("peerjs");
-const entity_1 = require("./entity");
-const router_1 = require("./router");
-const axios_1 = __importDefault(require("axios"));
-const delay_1 = __importDefault(require("delay"));
-const MAX_RECONNECT_BACKOFF = 30000;
-const BASE_RECONNECT_BACKOFF = 1000;
-class PeerTransfer {
-    constructor(deviceId, config) {
-        this.connectPool = new Map();
-        this.requests = new Map();
-        this.router = new router_1.PeerRouter();
-        this.reconnectAttempt = 0;
-        this.destroyed = false;
-        /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
-        this.connRequests = new Map();
-        this._reconnecting = false;
-        this.peerConfig = Object.assign(Object.assign({}, config), { key: String(Date.now()) });
-        this.peerId = deviceId;
-        this.deviceId = deviceId;
-    }
-    // ── Peer lifecycle ──────────────────────────────────────────────
-    createPeer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.destroyed)
-                throw new Error('destroyed');
-            if ((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)
-                return this.peer;
-            this.destroyPeer();
-            yield this.reloadConfig();
-            const peer = new peerjs_1.Peer(this.peerId, Object.assign(Object.assign({}, this.peerConfig), { pingInterval: 9000 }));
-            this.peer = peer;
-            yield this.waitForOpen(peer);
-            peer.on('close', () => {
-                if (!this.destroyed)
-                    this.reconnect();
-            });
-            peer.on('error', (err) => {
-                if (this.destroyed)
-                    return;
-                if (err.type === 'network' || err.type === 'server-error') {
-                    this.reconnect();
-                }
-            });
-            peer.on('connection', (conn) => {
-                conn.label = 'incoming';
-                this.onConnect(conn);
-            });
-            const socket = peer.socket;
-            socket === null || socket === void 0 ? void 0 : socket.on('message', (message) => {
-                this.handleSocketMessage(message);
-            });
-            return peer;
-        });
-    }
-    waitForOpen(peer) {
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => resolve(), constant_1.PEER_OPEN_TIMEOUT);
-            peer.once('open', () => {
-                clearTimeout(timer);
-                this.reconnectAttempt = 0;
-                resolve();
-            });
-            peer.once('error', (err) => {
-                if (err.message === constant_1.CONNECTION_DUPLICATED)
-                    return; // wait for open
-                clearTimeout(timer);
-                if (err.message === constant_1.CONNECTION_PEER_CONFLICT) {
-                    resolve();
-                    return;
-                }
-                if (err.message === constant_1.CONNECTION_LIMIT_EXCEED) {
-                    this.onConnectLimit();
-                    resolve();
-                    return;
-                }
-                if (err.message === constant_1.UNAUTHORIZED) {
-                    this.requireAuth();
-                    resolve();
-                    return;
-                }
-                resolve();
-            });
-        });
-    }
-    handleSocketMessage(message) {
-        var _a;
-        switch (message.type) {
-            case 'ONLINE':
-                this.online(message.payload.deviceId);
-                break;
-            case 'OFFLINE':
-                this.ping(message.payload.deviceId);
-                break;
-            case 'ERROR':
-                if (((_a = message.payload) === null || _a === void 0 ? void 0 : _a.msg) === constant_1.CONNECTION_PEER_CONFLICT) {
-                    this.getStore().dispatch({
-                        type: 'global/updateNetworkState',
-                        payload: { error: true, code: 'PEER_CONNECTION_CONFLICT', message: 'peer conflict' },
-                    });
-                }
-                break;
-        }
-    }
-    // ── Connection management ───────────────────────────────────────
-    connectToPeer(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (peerId === this.deviceId)
-                return;
-            const existing = this.connectPool.get(peerId);
-            if (this.isValidConnection(existing))
-                return existing;
-            if (existing)
-                this.removeConnection(peerId, existing.connectionId);
-            return this.createConnection(peerId);
-        });
-    }
-    createConnection(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            for (let retry = 0; retry < 3; retry++) {
-                if (!((_a = this.peer) === null || _a === void 0 ? void 0 : _a.open)) {
-                    try {
-                        yield this.createPeer();
-                    }
-                    catch ( /* fall through */_c) { /* fall through */ }
-                }
-                if (!((_b = this.peer) === null || _b === void 0 ? void 0 : _b.open))
-                    continue;
-                const pooled = this.connectPool.get(peerId);
-                if (this.isValidConnection(pooled))
-                    return pooled;
-                const conn = this.peer.connect(peerId, {
-                    label: 'outgoing',
-                    metadata: { time: Date.now() },
-                });
-                if (!conn)
-                    continue;
-                const result = yield this.onConnect(conn).catch(() => undefined);
-                if (result)
-                    return result;
-                const pooled2 = this.connectPool.get(peerId);
-                if (this.isValidConnection(pooled2))
-                    return pooled2;
-            }
-            return undefined;
-        });
-    }
-    onConnect(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!conn)
-                return;
-            const existing = this.connectPool.get(conn.peer);
-            if (existing) {
-                if (existing.connectionId > conn.connectionId) {
-                    this.removeConnection(conn.peer, conn.connectionId);
-                    if (this.isValidConnection(existing))
-                        return existing;
-                }
-                else {
-                    this.removeConnection(existing.peer, existing.connectionId);
-                }
-            }
-            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);
-                }, constant_1.CONNECTION_TIMEOUT);
-                const onOpen = () => {
-                    clearTimeout(timer);
-                    conn.off('error', onError);
-                    conn.off('close', onClose);
-                    resolve(this.setupConnection(conn));
-                };
-                const onError = () => {
-                    clearTimeout(timer);
-                    conn.off('open', onOpen);
-                    conn.off('close', onClose);
-                    const pooled = this.connectPool.get(conn.peer);
-                    resolve(this.isValidConnection(pooled) ? pooled : undefined);
-                };
-                const onClose = () => {
-                    clearTimeout(timer);
-                    conn.off('open', onOpen);
-                    conn.off('error', onError);
-                    resolve(undefined);
-                };
-                conn.once('open', onOpen);
-                conn.once('error', onError);
-                conn.once('close', onClose);
-            });
-        });
-    }
-    setupConnection(conn) {
-        this.connectPool.set(conn.peer, conn);
-        this.bindConnectionData(conn);
-        conn.on('close', () => this.onConnClosed(conn));
-        conn.on('error', () => this.onConnClosed(conn));
-        return conn;
-    }
-    onConnClosed(conn) {
-        this.connectPool.delete(conn.peer);
-        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' } });
-                    this.requests.delete(reqId);
-                }
-            }
-            this.connRequests.delete(conn.connectionId);
-        }
-    }
-    removeConnection(peerId, connectionId) {
-        var _a, _b, _c;
-        const conn = this.connectPool.get(peerId);
-        if (conn) {
-            if (connectionId && conn.connectionId !== connectionId)
-                return;
-            this.connectPool.delete(peerId);
-            this.connRequests.delete(conn.connectionId);
-            conn.removeAllListeners();
-            conn.close();
-            (_a = this.peer) === null || _a === void 0 ? void 0 : _a._removeConnection(conn);
-        }
-        else {
-            const connections = ((_b = this.peer) === null || _b === void 0 ? void 0 : _b.connections) || {};
-            for (const c of connections[peerId] || []) {
-                c.removeAllListeners();
-                c.close();
-                (_c = this.peer) === null || _c === void 0 ? void 0 : _c._removeConnection(c);
-            }
-        }
-    }
-    isValidConnection(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);
-    }
-    bindConnectionData(conn) {
-        conn.on('data', (message) => {
-            switch (message.scope) {
-                case entity_1.PeerScope.REQUEST:
-                    return this.onRequest(conn, message);
-                case entity_1.PeerScope.RESPONSE:
-                    return this.onResponse(conn, message);
-                default:
-                    return this.responseFail(conn, message, 'unknown scope');
-            }
-        });
-    }
-    // ── Request / Reply ─────────────────────────────────────────────
-    request(peerId, payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const requestId = payload.requestId || (yield this.genRequestId());
-            let res;
-            for (let attempt = 0; attempt <= 2; attempt++) {
-                res = yield this.doRequestOnce(peerId, payload, requestId);
-                const code = (_a = res.error) === null || _a === void 0 ? void 0 : _a.code;
-                if (!res.error || (code !== 'CONN_CLOSED' && code !== 'CONN_FAILED'))
-                    return res;
-            }
-            return res;
-        });
-    }
-    doRequestOnce(peerId, payload, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.destroyed) {
-                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'destroyed', code: 'CONN_CLOSED' } });
-            }
-            const conn = yield this.connectToPeer(peerId);
-            if (!this.isValidConnection(conn)) {
-                return Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'connection failed', code: 'CONN_FAILED' } });
-            }
-            return new Promise((resolve) => {
-                let timeout = 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);
-                        if (reqs.size === 0)
-                            this.connRequests.delete(conn.connectionId);
-                    }
-                };
-                timeout = setTimeout(() => {
-                    cleanup();
-                    this.removeConnection(conn.peer, conn.connectionId);
-                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'timeout', code: 'TIMEOUT' } }));
-                }, payload.timeout || entity_1.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) => {
-                    cleanup();
-                    resolve(message);
-                });
-                this.send(conn, Object.assign(Object.assign({}, payload), { requestId })).catch(() => {
-                    cleanup();
-                    resolve(Object.assign(Object.assign({}, payload), { body: {}, error: { message: 'send failed', code: 'CONN_CLOSED' } }));
-                });
-            });
-        });
-    }
-    reply(conn, oldMessage, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = Object.assign(Object.assign(Object.assign({}, this.inheritMessage(oldMessage)), message), { dest: conn.peer, scope: entity_1.PeerScope.RESPONSE, updatedAt: Date.now() });
-            if (!this.isValidConnection(conn)) {
-                const c = yield this.connectToPeer(conn.peer);
-                return c === null || c === void 0 ? void 0 : c.send(data);
-            }
-            return conn.send(data);
-        });
-    }
-    send(conn, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const internalApi = yield this.getApi(conn.peer);
-            let connection = conn;
-            if (!this.isValidConnection(conn)) {
-                const c = yield this.connectToPeer(conn.peer);
-                if (!c)
-                    return this.responseFail(conn, message, 'send with invalid connection');
-                connection = c;
-            }
-            const requestId = message.requestId || (yield this.genRequestId());
-            return connection.send(Object.assign(Object.assign({}, message), { requestId, headers: Object.assign(Object.assign({}, message.headers), { ['x-device-token']: internalApi === null || internalApi === void 0 ? void 0 : internalApi.token }), scope: entity_1.PeerScope.REQUEST, action: entity_1.PeerAction.SEND, src: this.peerId, dest: conn.peer, createdAt: Date.now() }), false);
-        });
-    }
-    // ── Ping ────────────────────────────────────────────────────────
-    ping(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.deviceId === peerId)
-                return false;
-            const conn = this.connectPool.get(peerId);
-            if (!this.isValidConnection(conn)) {
-                this.removeConnection(peerId, conn === null || conn === void 0 ? void 0 : conn.connectionId);
-                return false;
-            }
-            try {
-                const requestId = yield this.genRequestId();
-                return new Promise((resolve) => {
-                    const timer = setTimeout(() => { this.requests.delete(requestId); resolve(false); }, constant_1.PING_TIMEOUT);
-                    this.requests.set(requestId, () => { clearTimeout(timer); resolve(true); });
-                    conn.send({
-                        route: entity_1.PeerRoutes.HEARTBEAT, method: 'get', body: {}, requestId,
-                        scope: entity_1.PeerScope.REQUEST, action: entity_1.PeerAction.SEND,
-                        src: this.peerId, dest: peerId, headers: {}, createdAt: Date.now(),
-                    });
-                });
-            }
-            catch (_a) {
-                return false;
-            }
-        });
-    }
-    // ── Server helpers ──────────────────────────────────────────────
-    getApiHost() {
-        var _a, _b, _c;
-        const protocol = ((_a = this.peerConfig) === null || _a === void 0 ? void 0 : _a.secure) ? 'https' : 'http';
-        const host = ((_b = this.peerConfig) === null || _b === void 0 ? void 0 : _b.host) || 'localhost';
-        const port = ((_c = this.peerConfig) === null || _c === void 0 ? void 0 : _c.port) || 9000;
-        return `${protocol}://${host}:${port}`;
-    }
-    getDeviceStatus(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const res = yield axios_1.default.get(`${this.getApiHost()}/api/v1/devices/${peerId}/status`);
-                if (res.status < 400)
-                    return res.data.data;
-            }
-            catch ( /* ignore */_a) { /* ignore */ }
-        });
-    }
-    // ── Reconnection ────────────────────────────────────────────────
-    reconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.destroyed || this._reconnecting)
-                return;
-            this._reconnecting = true;
-            try {
-                this.reconnectAttempt++;
-                const backoff = Math.min(BASE_RECONNECT_BACKOFF * Math.pow(2, this.reconnectAttempt - 1), MAX_RECONNECT_BACKOFF);
-                yield (0, delay_1.default)(backoff);
-                yield this.reloadConfig();
-                return yield this.createPeer();
-            }
-            catch (_a) {
-                return this.createPeer();
-            }
-            finally {
-                this._reconnecting = false;
-            }
-        });
-    }
-    // ── Message helpers ─────────────────────────────────────────────
-    inheritMessage(receiveMsg) {
-        return {
-            src: this.peerId,
-            id: receiveMsg.id,
-            requestId: receiveMsg.requestId,
-            route: receiveMsg.route,
-            createdAt: receiveMsg.createdAt,
-            action: entity_1.PeerAction.RECEIVE,
-        };
-    }
-    // ── Router integration ──────────────────────────────────────────
-    onRequest(conn, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.router.run(conn, message);
-            }
-            catch (err) {
-                this.responseFail(conn, message, { message: err.message, code: err.code });
-            }
-        });
-    }
-    onResponse(_conn, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cb = this.requests.get(message.requestId);
-            if (cb) {
-                cb.apply(this, [message]);
-                this.requests.delete(message.requestId);
-            }
-        });
-    }
-    responseOk(conn, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.reply(conn, message, { body: { ok: true } });
-        });
-    }
-    responseFail(conn, message, err) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.reply(conn, message, { body: {}, error: err || 'service error' });
-        });
-    }
-    use(handler, prefix = '') {
-        this.router.use(handler, prefix);
-    }
-    addRoute(route) {
-        this.router.add(route);
-    }
-    // ── Lifecycle ───────────────────────────────────────────────────
-    clearInstance() {
-        this.destroyed = true;
-        for (const peerId of Array.from(this.connectPool.keys())) {
-            this.removeConnection(peerId);
-        }
-        this.requests.clear();
-        this.connRequests.clear();
-        this.destroyPeer();
-    }
-    destroy() {
-        this.clearInstance();
-        this.onDestroy();
-    }
-    destroyPeer() {
-        var _a, _b;
-        (_a = this.peer) === null || _a === void 0 ? void 0 : _a.destroy();
-        (_b = this.peer) === null || _b === void 0 ? void 0 : _b.removeAllListeners();
-        this.peer = undefined;
-    }
-}
-exports.PeerTransfer = PeerTransfer;
+__exportStar(require("./peer-transfer"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./handler"), exports);
 __exportStar(require("./file-transfer"), exports);
@@ -518,3 +24,4 @@ __exportStar(require("./locker"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./http-transformer"), exports);
 __exportStar(require("./http-transfer"), exports);
+__exportStar(require("./connection-manager"), exports);

package/dist/interfaces.d.ts

@@ -158,6 +158,10 @@ export interface MiddlewareItem {
     async?: boolean;
     errorHandler?: (error: Error) => void;
 }
+export declare enum MessageRole {
+    Agent = "agent",
+    User = "user"
+}
 export type DataMessage = {
     id: string;
     src: string;
@@ -173,6 +177,8 @@ export type DataMessage = {
     priority?: TransferPriority;
     retryCount?: number;
     metadata?: Record<string, any>;
+    sessionId?: string;
+    role?: MessageRole;
 };
 export interface MetaData {
     size: number;

package/dist/interfaces.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRole = void 0;
+var MessageRole;
+(function (MessageRole) {
+    MessageRole["Agent"] = "agent";
+    MessageRole["User"] = "user";
+})(MessageRole || (exports.MessageRole = MessageRole = {}));

package/dist/peer-transfer.d.ts

@@ -0,0 +1,95 @@
+import { DataConnection, Peer, PeerOptions } from 'peerjs';
+import { IDeviceStatus, IMessage, PeerMessage, PeerRequestPayload, RequestCallbackFn, RouteItem } from './interfaces';
+import { InternalApi, PeerAction } from './entity';
+import { ConnectionManager } from './connection-manager';
+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 const PEER_CLOSE_RECONNECT_TIMEOUT = 3000;
+export declare abstract class PeerTransfer {
+    protected peer: Peer | undefined;
+    protected connectionManager: ConnectionManager;
+    protected peerConfig: PeerTransferOptions | undefined;
+    readonly deviceId: string;
+    readonly peerId: string;
+    protected requests: Map<string, ResponseCb<any>>;
+    protected router: PeerRouter;
+    protected reconnectAttempt: number;
+    protected destroyed: boolean;
+    /** connectionId → Set<requestId> — settle in-flight requests on connection drop */
+    private connRequests;
+    private _reconnecting;
+    /** 退出标志：为 true 时禁止自动重连，直到 createPeer 被调用 */
+    private _exited;
+    /** 空闲重连定时器：超时无消息活动则重建 Peer */
+    private idleTimer;
+    /** 心跳超时定时器：30 秒未收到 HEARTBEAT 则重连 */
+    private heartbeatTimer;
+    constructor(deviceId: string, config: PeerTransferOptions);
+    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>;
+    private waitForOpen;
+    handleSocketMessage(message: IMessage): void;
+    connectToPeer(peerId: string): Promise<DataConnection | undefined>;
+    private createConnection;
+    onConnect(conn: DataConnection): Promise<DataConnection | undefined>;
+    private setupConnection;
+    private onConnClosed;
+    removeConnection(peerId: string, connectionId?: string): void;
+    isValidConnection(conn?: DataConnection): boolean;
+    request(peerId: string, payload: PeerRequestPayload): Promise<PeerMessage>;
+    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>;
+    ping(peerId: string): Promise<boolean>;
+    getApiHost(): string;
+    getDeviceStatus(peerId: string): Promise<IDeviceStatus | undefined>;
+    reconnect(force?: boolean): Promise<Peer | undefined>;
+    inheritMessage(receiveMsg: PeerMessage): {
+        src: string;
+        id: string;
+        requestId: string;
+        route: string;
+        createdAt: string | number;
+        action: PeerAction;
+    };
+    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>;
+    use(handler: RequestCallbackFn, prefix?: string): void;
+    addRoute(route: Omit<RouteItem, 'scope'>): void;
+    private resetIdleTimer;
+    private clearIdleTimer;
+    private resetHeartbeatTimer;
+    private clearHeartbeatTimer;
+    clearInstance(): void;
+    destroy(): void;
+    /**
+     * 退出：关闭 peer 和所有连接，停止自动重连。
+     * 与 destroy   stop 后仍可调用 createPeer 恢复工作。
+     */
+    stop(): void;
+    private destroyPeer;
+    askReload(peerId: string): void;
+}
+export {};