peer-client 1.0.0

package/dist/core/client.d.ts

@@ -0,0 +1,41 @@
+import { Emitter } from './emitter';
+import { Transport } from './transport';
+import { Identity } from './identity';
+import { Peer } from './peer';
+import type { ClientConfig, PeerClientEvent, PeerInfo, MatchResult, DataChannelConfig, RoomCreatedResult, RoomInfoResult, RoomConfig } from './types';
+export declare class PeerClient extends Emitter<PeerClientEvent> {
+    private transport;
+    private identity;
+    private config;
+    private peers;
+    private namespaces;
+    private matchResolvers;
+    private registerPromise;
+    private registerAbort;
+    constructor(config: ClientConfig);
+    get fingerprint(): string;
+    get alias(): string;
+    get connected(): boolean;
+    get peerMap(): ReadonlyMap<string, Peer>;
+    getIdentity(): Identity;
+    getTransport(): Transport;
+    connect(): Promise<void>;
+    join(namespace: string, appType?: string, version?: string): Promise<PeerInfo[]>;
+    leave(namespace: string): void;
+    discover(namespace: string, limit?: number): Promise<PeerInfo[]>;
+    match(namespace: string, criteria?: Record<string, any>, groupSize?: number): Promise<MatchResult>;
+    createRoom(roomId: string, config?: RoomConfig): Promise<RoomCreatedResult>;
+    joinRoom(roomId: string): Promise<PeerInfo[]>;
+    roomInfo(roomId: string): Promise<RoomInfoResult>;
+    kick(roomId: string, fingerprint: string): void;
+    connectToPeer(fingerprint: string, alias?: string, channelConfig?: DataChannelConfig): Peer;
+    getPeer(fingerprint: string): Peer | undefined;
+    relay(to: string, payload: any): void;
+    broadcast(namespace: string, data: any): void;
+    updateMetadata(meta: Record<string, any>): void;
+    closePeer(fingerprint: string): void;
+    disconnect(): void;
+    private doRegister;
+    createPeer(fingerprint: string, alias: string): Peer;
+    private handleMessage;
+}

package/dist/core/client.js

@@ -0,0 +1,361 @@
+import { Emitter } from './emitter';
+import { Transport } from './transport';
+import { Identity } from './identity';
+import { Peer } from './peer';
+import { DEFAULT_ICE_SERVERS } from './types';
+export class PeerClient extends Emitter {
+    transport;
+    identity;
+    config;
+    peers = new Map();
+    namespaces = new Set();
+    matchResolvers = new Map();
+    registerPromise = null;
+    registerAbort = null;
+    constructor(config) {
+        super();
+        this.config = {
+            url: config.url,
+            iceServers: config.iceServers ?? DEFAULT_ICE_SERVERS,
+            alias: config.alias ?? '',
+            meta: config.meta ?? {},
+            autoReconnect: config.autoReconnect ?? true,
+            reconnectDelay: config.reconnectDelay ?? 1000,
+            reconnectMaxDelay: config.reconnectMaxDelay ?? 30000,
+            pingInterval: config.pingInterval ?? 25000,
+            maxReconnectAttempts: config.maxReconnectAttempts ?? Infinity,
+            identityKeys: config.identityKeys,
+        };
+        this.identity = new Identity();
+        this.transport = new Transport(this.config.url, this.config.autoReconnect, this.config.reconnectDelay, this.config.reconnectMaxDelay, this.config.maxReconnectAttempts, this.config.pingInterval);
+        this.transport.on('message', (msg) => this.handleMessage(msg));
+        this.transport.on('close', () => this.emit('disconnected'));
+        this.transport.on('reconnecting', (attempt, delay) => {
+            this.emit('reconnecting', attempt, delay);
+        });
+        this.transport.on('open', () => {
+            if (this.identity.fingerprint) {
+                this.doRegister().then(() => {
+                    this.namespaces.forEach((ns) => {
+                        this.transport.send({
+                            type: 'join',
+                            payload: { namespace: ns },
+                        });
+                    });
+                    this.emit('reconnected');
+                }).catch(() => { });
+            }
+        });
+    }
+    get fingerprint() {
+        return this.identity.fingerprint;
+    }
+    get alias() {
+        return this.identity.alias;
+    }
+    get connected() {
+        return this.transport.connected;
+    }
+    get peerMap() {
+        return this.peers;
+    }
+    getIdentity() {
+        return this.identity;
+    }
+    getTransport() {
+        return this.transport;
+    }
+    async connect() {
+        await this.transport.connect();
+        await this.doRegister();
+    }
+    async join(namespace, appType, version) {
+        this.namespaces.add(namespace);
+        return new Promise((resolve) => {
+            const off = this.on('peer_list', (ns, peers) => {
+                if (ns === namespace) {
+                    off();
+                    resolve(peers);
+                }
+            });
+            this.transport.send({
+                type: 'join',
+                payload: { namespace, app_type: appType, version },
+            });
+        });
+    }
+    leave(namespace) {
+        this.namespaces.delete(namespace);
+        this.transport.send({ type: 'leave', payload: { namespace } });
+    }
+    async discover(namespace, limit = 20) {
+        return new Promise((resolve) => {
+            const off = this.on('peer_list', (ns, peers) => {
+                if (ns === namespace) {
+                    off();
+                    resolve(peers);
+                }
+            });
+            this.transport.send({
+                type: 'discover',
+                payload: { namespace, limit },
+            });
+        });
+    }
+    async match(namespace, criteria, groupSize) {
+        return new Promise((resolve) => {
+            this.matchResolvers.set(namespace, resolve);
+            this.transport.send({
+                type: 'match',
+                payload: { namespace, criteria, group_size: groupSize },
+            });
+        });
+    }
+    async createRoom(roomId, config) {
+        return new Promise((resolve, reject) => {
+            let offCreated = null;
+            let offError = null;
+            const cleanup = () => {
+                offCreated?.();
+                offError?.();
+            };
+            offCreated = this.on('room_created', (result) => {
+                if (result.room_id === roomId) {
+                    cleanup();
+                    resolve(result);
+                }
+            });
+            offError = this.on('error', (err) => {
+                cleanup();
+                reject(new Error(typeof err === 'string' ? err : err?.message ?? 'create_room failed'));
+            });
+            this.transport.send({
+                type: 'create_room',
+                payload: { room_id: roomId, max_size: config?.maxSize ?? 20 },
+            });
+        });
+    }
+    async joinRoom(roomId) {
+        this.namespaces.add(roomId);
+        return new Promise((resolve, reject) => {
+            let offList = null;
+            let offError = null;
+            const cleanup = () => {
+                offList?.();
+                offError?.();
+            };
+            offList = this.on('peer_list', (ns, peers) => {
+                if (ns === roomId) {
+                    cleanup();
+                    resolve(peers);
+                }
+            });
+            offError = this.on('error', (err) => {
+                cleanup();
+                this.namespaces.delete(roomId);
+                reject(new Error(typeof err === 'string' ? err : err?.message ?? 'join_room failed'));
+            });
+            this.transport.send({
+                type: 'join_room',
+                payload: { room_id: roomId },
+            });
+        });
+    }
+    async roomInfo(roomId) {
+        return new Promise((resolve, reject) => {
+            let offMsg = null;
+            const timeout = setTimeout(() => {
+                offMsg?.();
+                reject(new Error('room_info timeout'));
+            }, 10000);
+            offMsg = this.transport.on('message', (msg) => {
+                if (msg.type === 'room_info') {
+                    const info = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                    if (info.room_id === roomId) {
+                        clearTimeout(timeout);
+                        offMsg?.();
+                        resolve(info);
+                    }
+                }
+            });
+            this.transport.send({
+                type: 'room_info',
+                payload: { room_id: roomId },
+            });
+        });
+    }
+    kick(roomId, fingerprint) {
+        this.transport.send({
+            type: 'kick',
+            payload: { room_id: roomId, fingerprint },
+        });
+    }
+    connectToPeer(fingerprint, alias = '', channelConfig) {
+        const existing = this.peers.get(fingerprint);
+        if (existing)
+            return existing;
+        const peer = this.createPeer(fingerprint, alias);
+        peer.createOffer(channelConfig);
+        return peer;
+    }
+    getPeer(fingerprint) {
+        return this.peers.get(fingerprint);
+    }
+    relay(to, payload) {
+        this.transport.send({ type: 'relay', to, payload });
+    }
+    broadcast(namespace, data) {
+        this.transport.send({
+            type: 'broadcast',
+            payload: { namespace, data },
+        });
+    }
+    updateMetadata(meta) {
+        this.transport.send({ type: 'metadata', payload: meta });
+    }
+    closePeer(fingerprint) {
+        const peer = this.peers.get(fingerprint);
+        if (peer) {
+            peer.close();
+            this.peers.delete(fingerprint);
+        }
+    }
+    disconnect() {
+        this.peers.forEach((p) => p.close());
+        this.peers.clear();
+        this.namespaces.clear();
+        this.matchResolvers.clear();
+        if (this.registerPromise) {
+            this.registerPromise.reject(new Error('Disconnected'));
+            this.registerPromise = null;
+        }
+        this.transport.close();
+    }
+    async doRegister() {
+        if (this.registerPromise) {
+            this.registerPromise.reject(new Error('Register superseded'));
+            this.registerPromise = null;
+        }
+        if (!this.identity.publicKeyB64) {
+            if (this.config.identityKeys) {
+                await this.identity.restore(this.config.identityKeys);
+            }
+            else {
+                await this.identity.generate();
+            }
+        }
+        return new Promise((resolve, reject) => {
+            this.registerPromise = { resolve, reject };
+            this.transport.send({
+                type: 'register',
+                payload: {
+                    public_key: this.identity.publicKeyB64,
+                    alias: this.config.alias,
+                    meta: this.config.meta,
+                },
+            });
+        });
+    }
+    createPeer(fingerprint, alias) {
+        const existing = this.peers.get(fingerprint);
+        if (existing)
+            return existing;
+        const peer = new Peer(fingerprint, alias, this.config.iceServers, (payload) => {
+            this.transport.send({ type: 'signal', to: fingerprint, payload });
+        });
+        peer.on('disconnected', () => {
+            this.peers.delete(fingerprint);
+        });
+        this.peers.set(fingerprint, peer);
+        return peer;
+    }
+    handleMessage(msg) {
+        switch (msg.type) {
+            case 'registered': {
+                const reg = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                this.identity.setRegistered(reg.fingerprint, reg.alias);
+                this.registerPromise?.resolve();
+                this.registerPromise = null;
+                this.emit('registered', reg.fingerprint, reg.alias);
+                break;
+            }
+            case 'peer_list': {
+                const ns = msg.namespace ?? msg.payload?.namespace ?? '';
+                const peers = msg.payload?.peers ?? msg.payload ?? [];
+                this.emit('peer_list', ns, peers);
+                break;
+            }
+            case 'peer_joined': {
+                const info = msg.payload ?? { fingerprint: msg.from ?? '', alias: '' };
+                this.emit('peer_joined', info);
+                break;
+            }
+            case 'peer_left': {
+                const fp = msg.from ?? msg.payload?.fingerprint ?? '';
+                const peer = this.peers.get(fp);
+                if (peer) {
+                    peer.close();
+                    this.peers.delete(fp);
+                }
+                this.emit('peer_left', fp);
+                break;
+            }
+            case 'signal': {
+                const from = msg.from ?? '';
+                let peer = this.peers.get(from);
+                if (!peer) {
+                    peer = this.createPeer(from, '');
+                }
+                peer.handleSignal(msg.payload);
+                break;
+            }
+            case 'matched': {
+                const result = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                const resolver = this.matchResolvers.get(result.namespace);
+                if (resolver) {
+                    this.matchResolvers.delete(result.namespace);
+                    resolver(result);
+                }
+                this.emit('matched', result);
+                break;
+            }
+            case 'relay': {
+                this.emit('relay', msg.from, msg.payload);
+                break;
+            }
+            case 'broadcast': {
+                const ns = msg.namespace ?? msg.payload?.namespace ?? '';
+                const data = msg.payload?.data ?? msg.payload;
+                this.emit('broadcast', msg.from, ns, data);
+                break;
+            }
+            case 'room_created': {
+                const result = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                this.emit('room_created', result);
+                break;
+            }
+            case 'room_closed': {
+                const result = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                if (result?.room_id) {
+                    this.namespaces.delete(result.room_id);
+                }
+                this.emit('room_closed', result);
+                break;
+            }
+            case 'kick': {
+                const payload = typeof msg.payload === 'string' ? JSON.parse(msg.payload) : msg.payload;
+                if (payload?.room_id) {
+                    this.namespaces.delete(payload.room_id);
+                }
+                this.emit('kicked', payload);
+                break;
+            }
+            case 'error': {
+                this.emit('error', msg.payload);
+                this.registerPromise?.reject(new Error(typeof msg.payload === 'string' ? msg.payload : JSON.stringify(msg.payload)));
+                this.registerPromise = null;
+                break;
+            }
+        }
+    }
+}

package/dist/core/emitter.d.ts

@@ -0,0 +1,11 @@
+export type ErrorHandler = (error: unknown, event: string) => void;
+export declare function setEmitterErrorHandler(handler: ErrorHandler): void;
+export declare class Emitter<Events extends string = string> {
+    private listeners;
+    on(event: Events, fn: (...args: any[]) => void): () => void;
+    once(event: Events, fn: (...args: any[]) => void): () => void;
+    off(event: Events, fn: (...args: any[]) => void): void;
+    emit(event: Events, ...args: any[]): void;
+    listenerCount(event: Events): number;
+    removeAllListeners(event?: Events): void;
+}

package/dist/core/emitter.js

@@ -0,0 +1,46 @@
+let globalErrorHandler = (error, event) => {
+    console.error(`[Emitter] Error in "${event}" listener:`, error);
+};
+export function setEmitterErrorHandler(handler) {
+    globalErrorHandler = handler;
+}
+export class Emitter {
+    listeners = new Map();
+    on(event, fn) {
+        if (!this.listeners.has(event))
+            this.listeners.set(event, new Set());
+        this.listeners.get(event).add(fn);
+        return () => this.off(event, fn);
+    }
+    once(event, fn) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            fn(...args);
+        };
+        return this.on(event, wrapper);
+    }
+    off(event, fn) {
+        this.listeners.get(event)?.delete(fn);
+    }
+    emit(event, ...args) {
+        this.listeners.get(event)?.forEach((fn) => {
+            try {
+                fn(...args);
+            }
+            catch (e) {
+                globalErrorHandler(e, event);
+            }
+        });
+    }
+    listenerCount(event) {
+        return this.listeners.get(event)?.size ?? 0;
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+}

package/dist/core/identity.d.ts

@@ -0,0 +1,15 @@
+import type { IdentityKeys } from './types';
+export declare class Identity {
+    fingerprint: string;
+    alias: string;
+    publicKeyB64: string;
+    private keyPair;
+    generate(): Promise<string>;
+    restore(keys: IdentityKeys): Promise<void>;
+    export(): Promise<IdentityKeys>;
+    setRegistered(fingerprint: string, alias: string): void;
+    sign(data: ArrayBuffer): Promise<ArrayBuffer>;
+    verify(publicKey: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean>;
+    getPublicKey(): CryptoKey | null;
+    getPrivateKey(): CryptoKey | null;
+}

package/dist/core/identity.js

@@ -0,0 +1,54 @@
+export class Identity {
+    fingerprint = '';
+    alias = '';
+    publicKeyB64 = '';
+    keyPair = null;
+    async generate() {
+        this.keyPair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']);
+        const raw = await crypto.subtle.exportKey('raw', this.keyPair.publicKey);
+        this.publicKeyB64 = btoa(String.fromCharCode(...new Uint8Array(raw)));
+        return this.publicKeyB64;
+    }
+    async restore(keys) {
+        const privateKey = await crypto.subtle.importKey('jwk', keys.privateKeyJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign']);
+        const publicKey = await crypto.subtle.importKey('jwk', keys.publicKeyJwk, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify']);
+        this.keyPair = { privateKey, publicKey };
+        this.fingerprint = keys.fingerprint;
+        this.alias = keys.alias;
+        this.publicKeyB64 = keys.publicKeyB64;
+    }
+    async export() {
+        if (!this.keyPair)
+            throw new Error('No keypair generated');
+        const [privateKeyJwk, publicKeyJwk] = await Promise.all([
+            crypto.subtle.exportKey('jwk', this.keyPair.privateKey),
+            crypto.subtle.exportKey('jwk', this.keyPair.publicKey),
+        ]);
+        return {
+            fingerprint: this.fingerprint,
+            alias: this.alias,
+            publicKeyB64: this.publicKeyB64,
+            privateKeyJwk,
+            publicKeyJwk,
+        };
+    }
+    setRegistered(fingerprint, alias) {
+        this.fingerprint = fingerprint;
+        this.alias = alias;
+    }
+    async sign(data) {
+        if (!this.keyPair)
+            throw new Error('No keypair generated');
+        const result = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, this.keyPair.privateKey, data);
+        return new Uint8Array(result).buffer;
+    }
+    async verify(publicKey, signature, data) {
+        return crypto.subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, publicKey, signature, data);
+    }
+    getPublicKey() {
+        return this.keyPair?.publicKey ?? null;
+    }
+    getPrivateKey() {
+        return this.keyPair?.privateKey ?? null;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export { PeerClient } from './client';
+export { Peer } from './peer';
+export { Identity } from './identity';
+export { Transport } from './transport';
+export { Emitter, setEmitterErrorHandler } from './emitter';
+export * from './types';

package/dist/core/index.js

@@ -0,0 +1,6 @@
+export { PeerClient } from './client';
+export { Peer } from './peer';
+export { Identity } from './identity';
+export { Transport } from './transport';
+export { Emitter, setEmitterErrorHandler } from './emitter';
+export * from './types';

package/dist/core/peer.d.ts

@@ -0,0 +1,29 @@
+import { Emitter } from './emitter';
+import type { PeerEvent, DataChannelConfig } from './types';
+export declare class Peer extends Emitter<PeerEvent> {
+    readonly fingerprint: string;
+    readonly alias: string;
+    readonly pc: RTCPeerConnection;
+    private channels;
+    private pendingCandidates;
+    private remoteDescSet;
+    private _closed;
+    private _sendSignal;
+    constructor(fingerprint: string, alias: string, iceServers: RTCIceServer[], sendSignal: (payload: any) => void);
+    createOffer(channelConfig?: DataChannelConfig): Promise<void>;
+    handleSignal(payload: any): Promise<void>;
+    send(data: any, channel?: string): void;
+    sendBinary(data: ArrayBuffer, channel?: string): void;
+    addStream(stream: MediaStream): void;
+    removeStream(stream: MediaStream): void;
+    createDataChannel(config: DataChannelConfig): RTCDataChannel;
+    getChannel(label: string): RTCDataChannel | undefined;
+    getBufferedAmount(channel?: string): number;
+    get connectionState(): string;
+    get channelLabels(): string[];
+    get closed(): boolean;
+    restartIce(): void;
+    close(): void;
+    private setupChannel;
+    private flushCandidates;
+}