peer-client 1.0.0 → 1.0.1

package/dist/core/client.js

@@ -286,18 +286,22 @@ export class PeerClient extends Emitter {
                 break;
             }
             case 'peer_joined': {
-                const info = msg.payload ?? { fingerprint: msg.from ?? '', alias: '' };
-                this.emit('peer_joined', info);
+                const ns = msg.namespace ?? '';
+                const info = typeof msg.payload === 'string'
+                    ? JSON.parse(msg.payload)
+                    : msg.payload ?? { fingerprint: msg.from ?? '', alias: '' };
+                this.emit('peer_joined', info, ns);
                 break;
             }
             case 'peer_left': {
+                const ns = msg.namespace ?? '';
                 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);
+                this.emit('peer_left', fp, ns);
                 break;
             }
             case 'signal': {

package/dist/e2e.room.d.ts

@@ -0,0 +1,37 @@
+import { Emitter } from './core/emitter';
+import type { PeerClient } from './core/client';
+import type { PeerInfo } from './core/types';
+import { DirectRoom } from './room';
+import { E2E } from './crypto';
+type E2ERoomEvent = 'ready' | 'data' | 'decrypt_error' | 'peer_joined' | 'peer_left' | 'state_changed' | 'closed' | 'error';
+type E2ERoomState = 'connecting' | 'exchanging' | 'ready' | 'closed';
+export declare class E2EDirectRoom extends Emitter<E2ERoomEvent> {
+    private client;
+    private roomId;
+    private room;
+    private e2e;
+    private remoteFingerprint;
+    private _state;
+    private _closed;
+    private exchangeTimer;
+    private cleanups;
+    constructor(client: PeerClient, roomId: string, e2e?: E2E);
+    get state(): E2ERoomState;
+    get fingerprint(): string;
+    hasEncryption(): boolean;
+    getRoom(): DirectRoom | null;
+    getE2E(): E2E;
+    create(): Promise<void>;
+    join(): Promise<PeerInfo[]>;
+    send(data: any): void;
+    close(): void;
+    private initE2E;
+    private setState;
+    private attachListeners;
+    private startKeyExchange;
+    private handleKeyExchange;
+    private handleData;
+    private encryptAndSend;
+    private clearExchangeTimer;
+}
+export {};

package/dist/e2e.room.js

@@ -0,0 +1,221 @@
+import { Emitter } from './core/emitter';
+import { DirectRoom } from './room';
+import { E2E } from './crypto';
+const KEY_EXCHANGE_TIMEOUT = 10000;
+export class E2EDirectRoom extends Emitter {
+    client;
+    roomId;
+    room = null;
+    e2e;
+    remoteFingerprint = '';
+    _state = 'connecting';
+    _closed = false;
+    exchangeTimer = null;
+    cleanups = [];
+    constructor(client, roomId, e2e) {
+        super();
+        this.client = client;
+        this.roomId = roomId;
+        this.e2e = e2e ?? new E2E();
+    }
+    get state() {
+        return this._state;
+    }
+    get fingerprint() {
+        return this.remoteFingerprint;
+    }
+    hasEncryption() {
+        return this._state === 'ready' && this.e2e.hasKey(this.remoteFingerprint);
+    }
+    getRoom() {
+        return this.room;
+    }
+    getE2E() {
+        return this.e2e;
+    }
+    async create() {
+        if (this._closed)
+            throw new Error('Room is closed');
+        await this.initE2E();
+        this.room = new DirectRoom(this.client, this.roomId);
+        this.attachListeners();
+        await this.room.create();
+    }
+    async join() {
+        if (this._closed)
+            throw new Error('Room is closed');
+        await this.initE2E();
+        this.room = new DirectRoom(this.client, this.roomId);
+        this.attachListeners();
+        return this.room.join();
+    }
+    send(data) {
+        if (this._closed)
+            return;
+        if (!this.room)
+            return;
+        if (this._state === 'ready' && this.e2e.hasKey(this.remoteFingerprint)) {
+            this.encryptAndSend(data);
+        }
+        else {
+            this.room.send({ _plain: true, data });
+        }
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.setState('closed');
+        this.clearExchangeTimer();
+        this.cleanups.forEach((fn) => fn());
+        this.cleanups = [];
+        if (this.room) {
+            this.room.close();
+            this.room = null;
+        }
+        this.emit('closed');
+        this.removeAllListeners();
+    }
+    async initE2E() {
+        if (!this.e2e.getPublicKeyRaw()) {
+            await this.e2e.init();
+        }
+    }
+    setState(s) {
+        if (this._state === s)
+            return;
+        this._state = s;
+        this.emit('state_changed', s);
+    }
+    attachListeners() {
+        if (!this.room)
+            return;
+        const offData = this.room.on('data', (raw, from) => {
+            this.handleData(raw, from);
+        });
+        const offJoined = this.room.on('peer_joined', (info) => {
+            this.remoteFingerprint = info.fingerprint;
+            this.emit('peer_joined', info);
+        });
+        const offConnected = this.room.on('peer_connected', (fp) => {
+            this.remoteFingerprint = fp;
+            this.startKeyExchange(fp);
+        });
+        const offLeft = this.room.on('peer_left', (fp) => {
+            if (fp === this.remoteFingerprint) {
+                this.e2e.removeKey(fp);
+                this.remoteFingerprint = '';
+                if (this._state !== 'closed') {
+                    this.setState('connecting');
+                }
+            }
+            this.emit('peer_left', fp);
+        });
+        const offClosed = this.room.on('closed', () => {
+            this.close();
+        });
+        const offError = this.room.on('error', (err) => {
+            this.emit('error', err);
+        });
+        this.cleanups.push(offData, offJoined, offConnected, offLeft, offClosed, offError);
+    }
+    startKeyExchange(fingerprint) {
+        if (this._closed)
+            return;
+        this.setState('exchanging');
+        this.clearExchangeTimer();
+        this.exchangeTimer = setTimeout(() => {
+            if (this._state === 'exchanging') {
+                this.emit('error', new Error('Key exchange timeout'));
+                this.setState('connecting');
+            }
+        }, KEY_EXCHANGE_TIMEOUT);
+        try {
+            const pubKey = this.e2e.getPublicKeyB64();
+            this.room.send({
+                _e2e_exchange: true,
+                type: 'key_offer',
+                publicKey: pubKey,
+                fingerprint: this.client.fingerprint,
+            });
+        }
+        catch (err) {
+            this.clearExchangeTimer();
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    async handleKeyExchange(payload, from) {
+        if (this._closed)
+            return;
+        if (payload.type === 'key_offer') {
+            try {
+                await this.e2e.deriveKey(from, payload.publicKey);
+                const pubKey = this.e2e.getPublicKeyB64();
+                this.room.send({
+                    _e2e_exchange: true,
+                    type: 'key_ack',
+                    publicKey: pubKey,
+                    fingerprint: this.client.fingerprint,
+                });
+                this.clearExchangeTimer();
+                this.remoteFingerprint = from;
+                this.setState('ready');
+                this.emit('ready', from);
+            }
+            catch (err) {
+                this.emit('error', err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        if (payload.type === 'key_ack') {
+            try {
+                await this.e2e.deriveKey(from, payload.publicKey);
+                this.clearExchangeTimer();
+                this.remoteFingerprint = from;
+                this.setState('ready');
+                this.emit('ready', from);
+            }
+            catch (err) {
+                this.emit('error', err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    }
+    async handleData(raw, from) {
+        if (raw?._e2e_exchange) {
+            await this.handleKeyExchange(raw, from);
+            return;
+        }
+        if (raw?._encrypted && this.e2e.hasKey(from)) {
+            try {
+                const decrypted = await this.e2e.decrypt(from, raw.data);
+                const parsed = JSON.parse(decrypted);
+                this.emit('data', parsed, from);
+            }
+            catch {
+                this.emit('decrypt_error', from, raw);
+                this.startKeyExchange(from);
+            }
+            return;
+        }
+        if (raw?._plain) {
+            this.emit('data', raw.data, from);
+            return;
+        }
+        this.emit('data', raw, from);
+    }
+    async encryptAndSend(data) {
+        try {
+            const encrypted = await this.e2e.encrypt(this.remoteFingerprint, JSON.stringify(data));
+            this.room.send({ _encrypted: true, data: encrypted });
+        }
+        catch (err) {
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+            this.room.send({ _plain: true, data });
+        }
+    }
+    clearExchangeTimer() {
+        if (this.exchangeTimer) {
+            clearTimeout(this.exchangeTimer);
+            this.exchangeTimer = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { Identity } from './core/identity';
 export { Transport } from './core/transport';
 export { Emitter, setEmitterErrorHandler } from './core/emitter';
 export { DirectRoom, GroupRoom } from './room';
+export { E2EDirectRoom } from './e2e.room';
 export { DirectMedia, GroupMedia } from './media';
 export { JSONTransfer, FileTransfer, ImageTransfer } from './transfer';
 export { StateSync, CRDTSync } from './sync';

package/dist/index.js

@@ -4,6 +4,7 @@ export { Identity } from './core/identity';
 export { Transport } from './core/transport';
 export { Emitter, setEmitterErrorHandler } from './core/emitter';
 export { DirectRoom, GroupRoom } from './room';
+export { E2EDirectRoom } from './e2e.room';
 export { DirectMedia, GroupMedia } from './media';
 export { JSONTransfer, FileTransfer, ImageTransfer } from './transfer';
 export { StateSync, CRDTSync } from './sync';

package/dist/room.js

@@ -26,13 +26,17 @@ export class DirectRoom extends Emitter {
         return peers;
     }
     listen() {
-        const offJoined = this.client.on('peer_joined', (info) => {
+        const offJoined = this.client.on('peer_joined', (info, ns) => {
+            if (ns && ns !== this.roomId)
+                return;
             this.emit('peer_joined', info);
             if (!this.remotePeer) {
                 this.connectTo(info.fingerprint, info.alias);
             }
         });
-        const offLeft = this.client.on('peer_left', (fp) => {
+        const offLeft = this.client.on('peer_left', (fp, ns) => {
+            if (ns && ns !== this.roomId)
+                return;
             if (fp === this.remoteFingerprint) {
                 this.remotePeer = null;
                 this.remoteFingerprint = '';
@@ -123,11 +127,15 @@ export class GroupRoom extends Emitter {
         return peers;
     }
     listen() {
-        const offJoined = this.client.on('peer_joined', (info) => {
+        const offJoined = this.client.on('peer_joined', (info, ns) => {
+            if (ns && ns !== this.roomId)
+                return;
             this.emit('peer_joined', info);
             this.connectTo(info.fingerprint, info.alias);
         });
-        const offLeft = this.client.on('peer_left', (fp) => {
+        const offLeft = this.client.on('peer_left', (fp, ns) => {
+            if (ns && ns !== this.roomId)
+                return;
             const hadP2P = this.connectedPeers.has(fp);
             this.connectedPeers.delete(fp);
             this.relayPeers.delete(fp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-client",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Universal WebRTC peer-to-peer library with signaling, rooms, file transfer, state sync, and E2E encryption",
   "type": "module",
   "main": "dist/index.js",