pluto-rtc 0.0.2

package/dist/core/Connection.js

@@ -0,0 +1,392 @@
+export class Connection {
+    get isClosed() { return this._isClosed; }
+    constructor(id, localNodeId, deviceId, writer, reader, options = {}) {
+        this.listeners = [];
+        this.closeListeners = [];
+        // We'll keep track of the internal stream
+        this.writer = null;
+        this.reader = null;
+        this._isClosed = false;
+        // Buffer for incoming data
+        this.receiveBuffer = new Uint8Array(0);
+        this.writeMutex = Promise.resolve();
+        this.mediaListeners = [];
+        // --- Native WebRTC Upgrade ---
+        this.pc = null;
+        this.dc = null;
+        this.upgradeState = 'none';
+        this.pendingCandidates = [];
+        this.trackListeners = [];
+        this.id = id;
+        this.localNodeId = localNodeId;
+        this.deviceId = deviceId;
+        this.writer = writer;
+        this.reader = reader;
+        this.options = options;
+        this.readLoop();
+        // Auto-upgrade if configured
+        if (this.options.rtcConfig) {
+            this.attemptUpgrade();
+        }
+    }
+    /**
+     * Send a message to the other peer.
+     * Messages can be strings or objects (JSON stringified).
+     */
+    async send(message) {
+        return this.sendTyped(0, message);
+    }
+    /**
+     * Send media data (video/audio header + payload)
+     * Internal use for now.
+     */
+    async sendMedia(type, data) {
+        const typeId = type === 'video' ? 1 : 2;
+        return this.sendTyped(typeId, data);
+    }
+    async sendTyped(typeId, message) {
+        // Upgrade Routing
+        if (this.dc && this.dc.readyState === 'open' && this.upgradeState === 'upgraded') {
+            if (typeId === 0) {
+                try {
+                    const data = (typeof message === 'object' && !(message instanceof Uint8Array) && !(message instanceof ArrayBuffer))
+                        ? JSON.stringify(message)
+                        : message;
+                    this.dc.send(data);
+                    return; // Success!
+                }
+                catch (e) {
+                    console.warn("[Connection] ⚠️ Native Send Failed (Fallback to Iroh):", e);
+                    // Fallthrough to Iroh
+                }
+            }
+        }
+        if (this.isClosed || !this.writer) {
+            throw new Error('Connection is closed');
+        }
+        let payload;
+        if (typeof message === 'string') {
+            payload = new TextEncoder().encode(message);
+        }
+        else if (message instanceof Uint8Array) {
+            payload = message;
+        }
+        else if (message instanceof ArrayBuffer) {
+            payload = new Uint8Array(message);
+        }
+        else {
+            payload = new TextEncoder().encode(JSON.stringify(message));
+        }
+        // Framing: 4 bytes length (Big Endian) + 1 byte Type + payload
+        // Total frame size = 4 + 1 + payload.length
+        const totalLen = 4 + 1 + payload.length;
+        const frame = new Uint8Array(totalLen);
+        const view = new DataView(frame.buffer);
+        view.setUint32(0, 1 + payload.length, false); // Length includes Type byte
+        frame[4] = typeId; // Type byte
+        frame.set(payload, 5);
+        // Mutex to ensure atomic writes to the stream (prevents interleaving of audio/video chunks)
+        const previousMutex = this.writeMutex;
+        let releaseMutex;
+        this.writeMutex = new Promise((resolve) => {
+            releaseMutex = resolve;
+        });
+        try {
+            await previousMutex; // Wait for previous write
+            if (this.writer) {
+                await this.writer.write(frame);
+            }
+        }
+        catch (err) {
+            console.error('[Connection] Send error:', err);
+            this.close(`Send Error: ${err}`);
+            throw err;
+        }
+        finally {
+            releaseMutex();
+        }
+    }
+    /**
+     * Disconnect the connection
+     */
+    async disconnect() {
+        this.close('Explicit Disconnect');
+    }
+    /**
+     * Listen for incoming messages
+     */
+    onMessage(callback) {
+        this.listeners.push(callback);
+    }
+    /**
+     * Listen for incoming media
+     */
+    onMedia(callback) {
+        this.mediaListeners.push(callback);
+    }
+    /**
+     * Listen for disconnection
+     */
+    onDisconnect(callback) {
+        this.closeListeners.push(callback);
+    }
+    close(reason) {
+        if (this._isClosed)
+            return;
+        console.log(`[Connection] Closing connection ${this.id}. Reason: ${reason || 'Unknown'}`);
+        this._isClosed = true;
+        // Close writer/reader
+        this.writer?.close().catch(() => { });
+        this.reader?.cancel().catch(() => { });
+        this.writer = null;
+        this.reader = null;
+        // Notify listeners
+        this.closeListeners.forEach(cb => cb());
+    }
+    async readLoop() {
+        if (!this.reader)
+            return;
+        try {
+            while (!this.isClosed) {
+                const { done, value } = await this.reader.read();
+                if (done) {
+                    this.close('Read Done (Remote Closed)');
+                    break;
+                }
+                if (value) {
+                    this.handleData(value);
+                }
+            }
+        }
+        catch (err) {
+            console.error('[Connection] Read loop error:', err);
+            this.close(`Read Error: ${err}`);
+        }
+    }
+    handleData(chunk) {
+        // Append to buffer
+        const newBuffer = new Uint8Array(this.receiveBuffer.length + chunk.length);
+        newBuffer.set(this.receiveBuffer);
+        newBuffer.set(chunk, this.receiveBuffer.length);
+        this.receiveBuffer = newBuffer;
+        // Process messages
+        while (true) {
+            if (this.receiveBuffer.length < 4)
+                break; // Need at least length header
+            const view = new DataView(this.receiveBuffer.buffer, this.receiveBuffer.byteOffset, this.receiveBuffer.byteLength);
+            const length = view.getUint32(0, false);
+            if (this.receiveBuffer.length < 4 + length)
+                break; // Wait for full message
+            // Extract message
+            // First byte of body is Type
+            // Body is technically at index 4, length includes Type
+            const body = this.receiveBuffer.slice(4, 4 + length);
+            // However, we need to handle Legacy fallback? 
+            // If we upgrade, we assume all traffic is upgraded.
+            // If the user connects to an old client, the old client sends [Len][Data].
+            // We interpret [Data[0]] as Type. This is RISKY if old client sends binary starting with 0, 1, 2.
+            // But since old client sends JSON strings usually, '{' is 123.
+            // Strings start with chars.
+            // We can try to heuristic?
+            // Actually, if we control both ends (deployment), we enforce new protocol.
+            // Assuming this is a breaking change OR we are careful.
+            // New Protocol: Length = N (where N includes the type byte).
+            // So if payload is 10 bytes, N=11.
+            if (body.length > 0) {
+                const typeId = body[0];
+                const payload = body.slice(1);
+                // console.log(`[Connection] Packet received. Type: ${typeId}, Payload Len: ${payload.length}`);
+                if (typeId === 1) {
+                    this.emitMedia('video', payload);
+                }
+                else if (typeId === 2) {
+                    this.emitMedia('audio', payload);
+                }
+                else {
+                    // Type 0 or unknown -> Treat as Data
+                    this.processDataPayload(payload);
+                }
+            }
+            this.receiveBuffer = this.receiveBuffer.slice(4 + length);
+        }
+    }
+    processDataPayload(messageData) {
+        // Check if it's text/JSON
+        try {
+            const text = new TextDecoder().decode(messageData);
+            // Try to parse JSON
+            try {
+                const json = JSON.parse(text);
+                // Intercept Internal Signals
+                if (json && typeof json === 'object' && json.type === '#pluto-signal') {
+                    this.handleInternalSignal(json);
+                    return;
+                }
+                if (typeof json === 'object' && json !== null) {
+                    this.emitMessage(json);
+                }
+                else {
+                    this.emitMessage(text);
+                }
+            }
+            catch {
+                this.emitMessage(text);
+            }
+        }
+        catch {
+            this.emitMessage(messageData);
+        }
+    }
+    emitMedia(type, data) {
+        this.mediaListeners.forEach(cb => cb(type, data));
+    }
+    emitMessage(msg) {
+        this.listeners.forEach(cb => cb(msg));
+    }
+    // Public API for adding tracks (used by PlutoPeerConnection)
+    addTrack(track) {
+        if (!this.pc)
+            return null;
+        console.log(`[Connection] Adding track ${track.kind} to internal PC`);
+        return this.pc.addTrack(track);
+    }
+    addTransceiver(trackOrKind, init) {
+        if (!this.pc)
+            return null;
+        console.log(`[Connection] Adding transceiver ${typeof trackOrKind === 'string' ? trackOrKind : trackOrKind.kind}`);
+        return this.pc.addTransceiver(trackOrKind, init);
+    }
+    // Allow external access to PC events (ontrack)
+    onTrack(callback) {
+        this.trackListeners.push(callback);
+    }
+    async attemptUpgrade() {
+        if (this.upgradeState !== 'none')
+            return;
+        this.upgradeState = 'upgrading';
+        const config = this.options.rtcConfig;
+        console.log(`[Connection] Initializing RTCPeerConnection for ${this.deviceId.substring(0, 6)}`);
+        this.pc = new RTCPeerConnection(config);
+        // Tie-breaker: Local > Remote ? Initiator : Responder
+        const isInitiator = this.localNodeId > this.deviceId;
+        console.log(`[Connection] Role: ${isInitiator ? 'Initiator' : 'Responder'}`);
+        // Standardize m-line order: Always create DataChannel first (id=0)
+        // Using negotiated: true ensures it matches on both sides without "magic" signaling
+        const dc = this.pc.createDataChannel("pluto-dc", { negotiated: true, id: 0 });
+        this.setupDataChannel(dc);
+        if (isInitiator) {
+            // Negotiation needed will trigger Offer logic below
+        }
+        else {
+            // Responder waits for Offer
+        }
+        this.setupPCHandlers(isInitiator);
+    }
+    setupPCHandlers(isInitiator) {
+        if (!this.pc)
+            return;
+        this.pc.onicecandidate = (ev) => {
+            if (ev.candidate) {
+                this.sendInternalSignal({ type: 'candidate', candidate: ev.candidate });
+            }
+        };
+        this.pc.onnegotiationneeded = async () => {
+            // Strict Role: Only Initiator starts negotiation to prevent glare/loops
+            if (!isInitiator) {
+                console.log("[Connection] Negotiation needed (Responder) - Ignoring (waiting for offer)");
+                return;
+            }
+            if (this.pc?.signalingState !== 'stable') {
+                console.log(`[Connection] Negotiation needed (Initiator) - Ignored (state: ${this.pc?.signalingState})`);
+                return;
+            }
+            console.log("[Connection] Negotiation Needed (Initiator). Creating Offer.");
+            try {
+                const offer = await this.pc.createOffer();
+                await this.pc.setLocalDescription(offer);
+                this.sendInternalSignal({ type: 'sdp', sdp: offer });
+            }
+            catch (e) {
+                console.error("Offer failed", e);
+            }
+        };
+        // Note: ondatachannel won't fire for negotiated channels! 
+        // We already setup the DC in attemptUpgrade.
+        this.pc.ontrack = (ev) => {
+            console.log(`[Connection] Peer -> Track: ${ev.track.kind}`);
+            this.trackListeners.forEach(cb => cb(ev));
+        };
+        this.pc.onconnectionstatechange = () => {
+            const state = this.pc?.connectionState;
+            console.log(`[Connection] 🌐 Native PC State: ${state}`);
+            if (state === 'connected') {
+                this.upgradeState = 'upgraded';
+                console.log("%c[Connection] 🚀 UPGRADE COMPLETE: Switched to Native WebRTC", "color: green; font-weight: bold;");
+            }
+            else if (state === 'failed' || state === 'disconnected') {
+                this.upgradeState = 'failed';
+                console.warn("%c[Connection] ⚠️ Native Connection Failed. Falling back to Iroh Relay.", "color: orange; font-weight: bold;");
+                // Do not close PC immediately to allow for potential restart or inspection?
+                // Actually, if failed, we should probably close to cleanup resources.
+                // But for now, just marking as failed ensures sendTyped uses Iroh.
+            }
+        };
+    }
+    setupDataChannel(dc) {
+        this.dc = dc;
+        dc.onopen = () => console.log("[Connection] DC OPEN");
+        dc.onmessage = (ev) => {
+            // Treat as regular message
+            // We might need to handle the framing?
+            // If it's pure string/json from DC, just emit.
+            // If we want to support binary media over DC later, we need framing.
+            // For now: Text/JSON is Message. 
+            // Binary... let's assume it's data payload.
+            this.processDataPayload(typeof ev.data === 'string' ? new TextEncoder().encode(ev.data) : new Uint8Array(ev.data));
+        };
+    }
+    async sendInternalSignal(msg) {
+        // Send via Iroh with special type
+        // internal type 255? or just a wrapped JSON
+        const envelope = {
+            type: '#pluto-signal',
+            content: msg
+        };
+        // Use Low-Level sendTyped or high level send?
+        // High level send uses JSON.
+        // We need to differentiate this from User Messages.
+        // Current User Messages are "Any JSON".
+        // Use a reserved property?
+        return this.send(envelope);
+    }
+    handleInternalSignal(msg) {
+        if (!this.pc) {
+            // We might be responder who hasn't initialized yet (if Init happens on first signal?)
+            // But constructor init should have happened if config was passed.
+            return;
+        }
+        const content = msg.content;
+        if (content.type === 'candidate') {
+            if (this.pc.remoteDescription) {
+                this.pc.addIceCandidate(content.candidate).catch(e => console.error("AddICE failed", e));
+            }
+            else {
+                this.pendingCandidates.push(content.candidate);
+            }
+        }
+        else if (content.type === 'sdp') {
+            const sdp = content.sdp;
+            this.pc.setRemoteDescription(sdp).then(async () => {
+                if (this.pendingCandidates.length) {
+                    this.pendingCandidates.forEach(c => this.pc?.addIceCandidate(c));
+                    this.pendingCandidates = [];
+                }
+                if (sdp.type === 'offer') {
+                    const answer = await this.pc.createAnswer();
+                    await this.pc.setLocalDescription(answer);
+                    this.sendInternalSignal({ type: 'sdp', sdp: answer });
+                }
+            }).catch(e => console.error("SDP Error", e));
+        }
+    }
+}

package/dist/core/Room.d.ts

@@ -0,0 +1,29 @@
+import { Signaling } from './Signaling';
+import { Connection } from './Connection';
+import { Client } from './Client';
+export interface JoinRequest {
+    id: string;
+    userId: string;
+    ticket: string;
+    state: 'pending' | 'accepted' | 'rejected';
+}
+export declare class RoomManager {
+    private signaling;
+    private client;
+    private heartbeatInterval;
+    constructor(client: Client, signaling: Signaling);
+    private get db();
+    private get tag();
+    /**
+     * Creates a new room (or joins the special 'demo' room if specified)
+     */
+    createRoom(): Promise<string>;
+    /**
+     * Joins a room by ID.
+     */
+    joinRoom(roomId: string): Promise<Connection[]>;
+    leaveRoom(roomId: string): Promise<void>;
+    private startHeartbeat;
+    stopHeartbeat(): void;
+    private pruneStaleMembers;
+}