peer-client 1.0.0

package/dist/core/peer.js

@@ -0,0 +1,234 @@
+import { Emitter } from './emitter';
+export class Peer extends Emitter {
+    fingerprint;
+    alias;
+    pc;
+    channels = new Map();
+    pendingCandidates = [];
+    remoteDescSet = false;
+    _closed = false;
+    _sendSignal;
+    constructor(fingerprint, alias, iceServers, sendSignal) {
+        super();
+        this.fingerprint = fingerprint;
+        this.alias = alias;
+        this._sendSignal = sendSignal;
+        this.pc = new RTCPeerConnection({ iceServers });
+        this.pc.onicecandidate = (e) => {
+            if (e.candidate) {
+                this._sendSignal({
+                    signal_type: 'candidate',
+                    candidate: JSON.stringify(e.candidate),
+                });
+            }
+        };
+        this.pc.onconnectionstatechange = () => {
+            if (this._closed)
+                return;
+            const state = this.pc.connectionState;
+            if (state === 'connected')
+                this.emit('connected');
+            if (state === 'disconnected' || state === 'failed' || state === 'closed') {
+                this.emit('disconnected', state);
+            }
+        };
+        this.pc.oniceconnectionstatechange = () => {
+            if (this._closed)
+                return;
+            const state = this.pc.iceConnectionState;
+            if (state === 'failed') {
+                this.restartIce();
+            }
+        };
+        this.pc.onnegotiationneeded = async () => {
+            if (this._closed)
+                return;
+            try {
+                const offer = await this.pc.createOffer();
+                await this.pc.setLocalDescription(offer);
+                this._sendSignal({ signal_type: 'offer', sdp: offer.sdp });
+            }
+            catch (e) {
+                this.emit('error', e);
+            }
+        };
+        this.pc.ondatachannel = (e) => {
+            this.setupChannel(e.channel);
+            this.emit('datachannel:create', e.channel);
+        };
+        this.pc.ontrack = (e) => {
+            this.emit('track', e.track, e.streams);
+            if (e.streams[0])
+                this.emit('stream', e.streams[0]);
+        };
+    }
+    async createOffer(channelConfig) {
+        const label = channelConfig?.label ?? 'data';
+        const ch = this.pc.createDataChannel(label, {
+            ordered: channelConfig?.ordered ?? true,
+            maxRetransmits: channelConfig?.maxRetransmits,
+            maxPacketLifeTime: channelConfig?.maxPacketLifeTime,
+        });
+        this.setupChannel(ch);
+        const offer = await this.pc.createOffer();
+        await this.pc.setLocalDescription(offer);
+        this._sendSignal({ signal_type: 'offer', sdp: offer.sdp });
+    }
+    async handleSignal(payload) {
+        if (this._closed)
+            return;
+        const { signal_type, sdp, candidate } = payload;
+        try {
+            if (signal_type === 'offer') {
+                await this.pc.setRemoteDescription({ type: 'offer', sdp });
+                this.remoteDescSet = true;
+                await this.flushCandidates();
+                const answer = await this.pc.createAnswer();
+                await this.pc.setLocalDescription(answer);
+                this._sendSignal({ signal_type: 'answer', sdp: answer.sdp });
+            }
+            else if (signal_type === 'answer') {
+                await this.pc.setRemoteDescription({ type: 'answer', sdp });
+                this.remoteDescSet = true;
+                await this.flushCandidates();
+            }
+            else if (signal_type === 'candidate') {
+                const parsed = JSON.parse(candidate);
+                if (this.remoteDescSet) {
+                    await this.pc.addIceCandidate(parsed);
+                }
+                else {
+                    this.pendingCandidates.push(parsed);
+                }
+            }
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    send(data, channel) {
+        const label = channel ?? 'data';
+        const ch = this.channels.get(label);
+        if (!ch || ch.readyState !== 'open') {
+            throw new Error(`Channel "${label}" not open`);
+        }
+        if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+            ch.send(data);
+        }
+        else {
+            ch.send(typeof data === 'string' ? data : JSON.stringify(data));
+        }
+    }
+    sendBinary(data, channel) {
+        const label = channel ?? 'data';
+        const ch = this.channels.get(label);
+        if (!ch || ch.readyState !== 'open') {
+            throw new Error(`Channel "${label}" not open`);
+        }
+        ch.send(data);
+    }
+    addStream(stream) {
+        stream.getTracks().forEach((track) => {
+            this.pc.addTrack(track, stream);
+        });
+    }
+    removeStream(stream) {
+        const senders = this.pc.getSenders();
+        stream.getTracks().forEach((track) => {
+            const sender = senders.find((s) => s.track === track);
+            if (sender)
+                this.pc.removeTrack(sender);
+        });
+    }
+    createDataChannel(config) {
+        const ch = this.pc.createDataChannel(config.label ?? 'extra', {
+            ordered: config.ordered ?? true,
+            maxRetransmits: config.maxRetransmits,
+            maxPacketLifeTime: config.maxPacketLifeTime,
+        });
+        this.setupChannel(ch);
+        return ch;
+    }
+    getChannel(label) {
+        return this.channels.get(label);
+    }
+    getBufferedAmount(channel) {
+        const ch = this.channels.get(channel ?? 'data');
+        return ch?.bufferedAmount ?? 0;
+    }
+    get connectionState() {
+        return this._closed ? 'closed' : this.pc.connectionState;
+    }
+    get channelLabels() {
+        return [...this.channels.keys()];
+    }
+    get closed() {
+        return this._closed;
+    }
+    restartIce() {
+        if (this._closed)
+            return;
+        try {
+            this.pc.restartIce();
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.channels.forEach((ch) => {
+            try {
+                ch.close();
+            }
+            catch { }
+        });
+        this.channels.clear();
+        try {
+            this.pc.close();
+        }
+        catch { }
+        this.removeAllListeners();
+    }
+    setupChannel(ch) {
+        this.channels.set(ch.label, ch);
+        ch.binaryType = 'arraybuffer';
+        ch.onopen = () => {
+            this.emit('datachannel:open', ch.label, ch);
+        };
+        ch.onmessage = (e) => {
+            if (e.data instanceof ArrayBuffer) {
+                this.emit('data', e.data, ch.label);
+                return;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(e.data);
+            }
+            catch {
+                parsed = e.data;
+            }
+            this.emit('data', parsed, ch.label);
+        };
+        ch.onclose = () => {
+            this.channels.delete(ch.label);
+            this.emit('datachannel:close', ch.label);
+        };
+        ch.onerror = (e) => {
+            this.emit('error', e);
+        };
+    }
+    async flushCandidates() {
+        for (const c of this.pendingCandidates) {
+            try {
+                await this.pc.addIceCandidate(c);
+            }
+            catch (e) {
+                this.emit('error', e);
+            }
+        }
+        this.pendingCandidates = [];
+    }
+}

package/dist/core/transport.d.ts

@@ -0,0 +1,35 @@
+import { Emitter } from './emitter';
+import type { ServerMessage } from './types';
+type TransportEvent = 'open' | 'close' | 'message' | 'error' | 'reconnecting';
+export declare class Transport extends Emitter<TransportEvent> {
+    private url;
+    private autoReconnect;
+    private reconnectDelay;
+    private reconnectMaxDelay;
+    private maxReconnectAttempts;
+    private pingInterval;
+    private ws;
+    private pingTimer;
+    private pongTimer;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private intentionalClose;
+    private lastPongTime;
+    private messageQueue;
+    private _connected;
+    constructor(url: string, autoReconnect: boolean, reconnectDelay: number, reconnectMaxDelay: number, maxReconnectAttempts: number, pingInterval: number);
+    connect(): Promise<void>;
+    send(msg: Partial<ServerMessage>): void;
+    private sendRaw;
+    close(): void;
+    get connected(): boolean;
+    getQueueSize(): number;
+    clearQueue(): void;
+    private flushQueue;
+    private startPing;
+    private schedulePongCheck;
+    private stopPing;
+    private cleanup;
+    private scheduleReconnect;
+}
+export {};

package/dist/core/transport.js

@@ -0,0 +1,174 @@
+import { Emitter } from './emitter';
+import { LIMITS } from './types';
+export class Transport extends Emitter {
+    url;
+    autoReconnect;
+    reconnectDelay;
+    reconnectMaxDelay;
+    maxReconnectAttempts;
+    pingInterval;
+    ws = null;
+    pingTimer = null;
+    pongTimer = null;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    intentionalClose = false;
+    lastPongTime = 0;
+    messageQueue = [];
+    _connected = false;
+    constructor(url, autoReconnect, reconnectDelay, reconnectMaxDelay, maxReconnectAttempts, pingInterval) {
+        super();
+        this.url = url;
+        this.autoReconnect = autoReconnect;
+        this.reconnectDelay = reconnectDelay;
+        this.reconnectMaxDelay = reconnectMaxDelay;
+        this.maxReconnectAttempts = maxReconnectAttempts;
+        this.pingInterval = pingInterval;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.intentionalClose = false;
+            let settled = false;
+            try {
+                this.ws = new WebSocket(this.url);
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.onopen = () => {
+                settled = true;
+                this._connected = true;
+                this.reconnectAttempts = 0;
+                this.lastPongTime = Date.now();
+                this.startPing();
+                this.flushQueue();
+                this.emit('open');
+                resolve();
+            };
+            this.ws.onclose = (ev) => {
+                this._connected = false;
+                this.cleanup();
+                this.emit('close', ev.code, ev.reason);
+                if (!settled) {
+                    settled = true;
+                    reject(new Error(`WebSocket closed: ${ev.code} ${ev.reason}`));
+                    return;
+                }
+                if (!this.intentionalClose && this.autoReconnect) {
+                    this.scheduleReconnect();
+                }
+            };
+            this.ws.onerror = (ev) => {
+                this.emit('error', ev);
+            };
+            this.ws.onmessage = (ev) => {
+                try {
+                    const msg = JSON.parse(ev.data);
+                    if (msg.type === 'pong') {
+                        this.lastPongTime = Date.now();
+                        return;
+                    }
+                    if (msg.type === 'ping') {
+                        this.sendRaw({ type: 'pong' });
+                        return;
+                    }
+                    this.emit('message', msg);
+                }
+                catch {
+                    this.emit('error', new Error('Failed to parse message'));
+                }
+            };
+        });
+    }
+    send(msg) {
+        if (this._connected && this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+        else if (this.messageQueue.length < LIMITS.MESSAGE_QUEUE_MAX) {
+            this.messageQueue.push(msg);
+        }
+    }
+    sendRaw(msg) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    close() {
+        this.intentionalClose = true;
+        this._connected = false;
+        this.cleanup();
+        this.messageQueue = [];
+        if (this.ws) {
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            this.ws.onmessage = null;
+            this.ws.close(1000, 'client disconnect');
+            this.ws = null;
+        }
+    }
+    get connected() {
+        return this._connected && this.ws?.readyState === WebSocket.OPEN;
+    }
+    getQueueSize() {
+        return this.messageQueue.length;
+    }
+    clearQueue() {
+        this.messageQueue = [];
+    }
+    flushQueue() {
+        const queue = this.messageQueue.splice(0);
+        for (const msg of queue) {
+            this.send(msg);
+        }
+    }
+    startPing() {
+        this.stopPing();
+        this.pingTimer = setInterval(() => {
+            this.sendRaw({ type: 'ping' });
+            this.schedulePongCheck();
+        }, this.pingInterval);
+    }
+    schedulePongCheck() {
+        if (this.pongTimer)
+            clearTimeout(this.pongTimer);
+        const timeout = this.pingInterval * LIMITS.PONG_TIMEOUT_MULTIPLIER;
+        this.pongTimer = setTimeout(() => {
+            const elapsed = Date.now() - this.lastPongTime;
+            if (elapsed > timeout) {
+                this._connected = false;
+                if (this.ws) {
+                    this.ws.close(4000, 'pong timeout');
+                }
+            }
+        }, timeout);
+    }
+    stopPing() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        if (this.pongTimer) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
+    cleanup() {
+        this.stopPing();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts)
+            return;
+        const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts), this.reconnectMaxDelay);
+        this.reconnectAttempts++;
+        this.emit('reconnecting', this.reconnectAttempts, delay);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch(() => { });
+        }, delay);
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,173 @@
+export type MessageType = 'register' | 'registered' | 'join' | 'leave' | 'signal' | 'discover' | 'peer_list' | 'match' | 'matched' | 'relay' | 'broadcast' | 'peer_joined' | 'peer_left' | 'metadata' | 'ping' | 'pong' | 'error' | 'create_room' | 'room_created' | 'join_room' | 'room_info' | 'room_closed' | 'kick';
+export interface ServerMessage {
+    type: MessageType;
+    from?: string;
+    to?: string;
+    namespace?: string;
+    payload?: any;
+    ts?: number;
+}
+export interface PeerInfo {
+    fingerprint: string;
+    alias: string;
+    meta?: Record<string, any>;
+    app_type?: string;
+}
+export interface MatchResult {
+    namespace: string;
+    session_id: string;
+    peers: PeerInfo[];
+}
+export interface RoomCreatedResult {
+    room_id: string;
+    max_size: number;
+    owner: string;
+}
+export interface RoomInfoResult {
+    room_id: string;
+    peer_count: number;
+    max_size: number;
+    owner: string;
+}
+export interface IdentityKeys {
+    fingerprint: string;
+    alias: string;
+    publicKeyB64: string;
+    privateKeyJwk: JsonWebKey;
+    publicKeyJwk: JsonWebKey;
+}
+export interface ClientConfig {
+    url: string;
+    iceServers?: RTCIceServer[];
+    alias?: string;
+    meta?: Record<string, any>;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    reconnectMaxDelay?: number;
+    pingInterval?: number;
+    maxReconnectAttempts?: number;
+    identityKeys?: IdentityKeys;
+}
+export interface DataChannelConfig {
+    label?: string;
+    ordered?: boolean;
+    maxRetransmits?: number;
+    maxPacketLifeTime?: number;
+}
+export interface RoomConfig {
+    maxSize?: number;
+}
+export interface MediaConfig {
+    audio?: boolean | MediaTrackConstraints;
+    video?: boolean | MediaTrackConstraints;
+}
+export interface FileChunk {
+    id: string;
+    index: number;
+    total: number;
+    data: ArrayBuffer;
+}
+export interface FileMetadata {
+    id: string;
+    filename: string;
+    size: number;
+    mime: string;
+    totalChunks: number;
+    chunkSize: number;
+}
+export interface TransferOffer {
+    _ft: true;
+    type: 'offer';
+    id: string;
+    filename: string;
+    size: number;
+    mime: string;
+    chunkSize: number;
+    totalChunks: number;
+}
+export interface TransferAccept {
+    _ft: true;
+    type: 'accept';
+    id: string;
+}
+export interface TransferAck {
+    _ft: true;
+    type: 'ack';
+    id: string;
+    index: number;
+}
+export interface TransferComplete {
+    _ft: true;
+    type: 'complete';
+    id: string;
+}
+export interface TransferCancel {
+    _ft: true;
+    type: 'cancel';
+    id: string;
+}
+export interface TransferResume {
+    _ft: true;
+    type: 'resume';
+    id: string;
+    lastIndex: number;
+}
+export interface TransferError {
+    _ft: true;
+    type: 'error';
+    id: string;
+    message: string;
+}
+export type TransferControl = TransferOffer | TransferAccept | TransferAck | TransferComplete | TransferCancel | TransferResume | TransferError;
+export interface TransferProgress {
+    id: string;
+    sent: number;
+    total: number;
+    percentage: number;
+    bytesPerSecond?: number;
+}
+export interface TransferState {
+    id: string;
+    filename: string;
+    size: number;
+    mime: string;
+    totalChunks: number;
+    chunkSize: number;
+    lastAckedIndex: number;
+}
+export type SyncMode = 'lww' | 'operational' | 'crdt';
+export interface HLC {
+    ts: number;
+    counter: number;
+    node: string;
+}
+export interface SyncConfig {
+    mode: SyncMode;
+    merge?: (local: any, remote: any) => any;
+}
+export interface SyncState {
+    key: string;
+    value: any;
+    hlc: HLC;
+    from: string;
+    version: number;
+    deleted?: boolean;
+}
+export type PeerClientEvent = 'connected' | 'disconnected' | 'registered' | 'peer_joined' | 'peer_left' | 'peer_list' | 'matched' | 'broadcast' | 'relay' | 'error' | 'reconnecting' | 'reconnected' | 'room_created' | 'room_closed' | 'kicked';
+export type PeerEvent = 'connected' | 'disconnected' | 'data' | 'stream' | 'track' | 'datachannel:create' | 'datachannel:open' | 'datachannel:close' | 'error';
+export declare const DEFAULT_ICE_SERVERS: RTCIceServer[];
+export declare const DEFAULT_CONFIG: Required<Omit<ClientConfig, 'url' | 'identityKeys'>>;
+export declare const LIMITS: {
+    readonly MAX_MEDIA_PEERS: 10;
+    readonly MAX_DATA_PEERS: 30;
+    readonly MAX_GROUP_SIZE: 20;
+    readonly RELAY_THRESHOLD: 30;
+    readonly CHUNK_SIZE: 65536;
+    readonly BUFFERED_AMOUNT_HIGH: number;
+    readonly BUFFERED_AMOUNT_LOW: number;
+    readonly ACK_INTERVAL: 100;
+    readonly TRANSFER_CHANNEL_PREFIX: "ft-";
+    readonly TOMBSTONE_TTL: 60000;
+    readonly PONG_TIMEOUT_MULTIPLIER: 2.5;
+    readonly MESSAGE_QUEUE_MAX: 500;
+};

package/dist/core/types.js

@@ -0,0 +1,28 @@
+export const DEFAULT_ICE_SERVERS = [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'stun:stun1.l.google.com:19302' },
+];
+export const DEFAULT_CONFIG = {
+    iceServers: DEFAULT_ICE_SERVERS,
+    alias: '',
+    meta: {},
+    autoReconnect: true,
+    reconnectDelay: 1000,
+    reconnectMaxDelay: 30000,
+    pingInterval: 25000,
+    maxReconnectAttempts: Infinity,
+};
+export const LIMITS = {
+    MAX_MEDIA_PEERS: 10,
+    MAX_DATA_PEERS: 30,
+    MAX_GROUP_SIZE: 20,
+    RELAY_THRESHOLD: 30,
+    CHUNK_SIZE: 65536,
+    BUFFERED_AMOUNT_HIGH: 4 * 1024 * 1024,
+    BUFFERED_AMOUNT_LOW: 1 * 1024 * 1024,
+    ACK_INTERVAL: 100,
+    TRANSFER_CHANNEL_PREFIX: 'ft-',
+    TOMBSTONE_TTL: 60000,
+    PONG_TIMEOUT_MULTIPLIER: 2.5,
+    MESSAGE_QUEUE_MAX: 500,
+};

package/dist/crypto.d.ts

@@ -0,0 +1,32 @@
+import { Emitter } from './core/emitter';
+import type { PeerClient } from './core/client';
+import type { Peer } from './core/peer';
+type E2EEvent = 'key_exchanged' | 'error';
+export declare class E2E extends Emitter<E2EEvent> {
+    private keys;
+    private keyPair;
+    private publicKeyRaw;
+    init(): Promise<void>;
+    getPublicKeyB64(): string;
+    getPublicKeyRaw(): ArrayBuffer;
+    deriveKey(peerFingerprint: string, remotePublicKeyB64: string): Promise<void>;
+    encrypt(peerFingerprint: string, data: string): Promise<string>;
+    decrypt(peerFingerprint: string, data: string): Promise<string>;
+    hasKey(peerFingerprint: string): boolean;
+    removeKey(peerFingerprint: string): void;
+    destroy(): void;
+}
+export declare class GroupKeyManager {
+    private e2e;
+    private client;
+    constructor(client: PeerClient);
+    getE2E(): E2E;
+    init(): Promise<void>;
+    exchangeWith(peer: Peer): Promise<void>;
+    handleIncomingKeyExchange(peer: Peer, data: any): Promise<void>;
+    encryptForPeer(fingerprint: string, data: any): Promise<string>;
+    decryptFromPeer(fingerprint: string, data: string): Promise<any>;
+    private waitForConnection;
+    destroy(): void;
+}
+export {};