pluto-rtc 0.0.2

package/dist/core/Client.js

@@ -0,0 +1,326 @@
+import { Connection } from './Connection';
+import { Signaling } from './Signaling';
+import { RoomManager } from './Room';
+export class Client {
+    constructor(options) {
+        this.wasmLoaded = false;
+        this.wasmPkg = null;
+        this.node = null;
+        this.connections = new Map();
+        this.connectionListeners = [];
+        this.disconnectionListeners = [];
+        this.messageListeners = [];
+        this.roomRequestListeners = [];
+        this.streamListeners = [];
+        this.localNodeId = null;
+        this.listening = false;
+        // Prevent GC
+        this.pendingConnection = null;
+        // Presence loop
+        this.presenceInterval = null;
+        if (!options.tag)
+            throw new Error("Client requires a 'tag' option.");
+        this.options = options;
+        this.signaling = new Signaling({
+            tag: options.tag,
+            storagePrefix: options.storagePrefix
+        });
+        this.rooms = new RoomManager(this, this.signaling);
+        this.signaling.onAuthChange((user) => {
+            if (user && this.listening && this.localNodeId) {
+                this.updatePresence();
+                this.signaling.cleanupStaleDevices();
+            }
+        });
+    }
+    // --- Helpers ---
+    get currentUser() {
+        return this.signaling.currentUser;
+    }
+    onAuthChange(callback) {
+        return this.signaling.onAuthChange(callback);
+    }
+    async signInAnonymously() {
+        return this.signaling.signInAnonymously();
+    }
+    signInWithPluto() {
+        return this.signaling.signInWithPluto();
+    }
+    async signOut() {
+        return this.signaling.signOut();
+    }
+    async searchDevices() {
+        return this.signaling.searchDevices();
+    }
+    onDevicesChange(callback) {
+        return this.signaling.onDevicesChange(callback);
+    }
+    async init() {
+        if (this.wasmLoaded)
+            return;
+        // @ts-ignore
+        this.wasmPkg = await import('../../wasm/pkg/iroh_wasm');
+        await this.wasmPkg.default();
+        const persistenceMode = this.options.nodeIdPersistence || 'persistent';
+        const storageKey = (this.options?.storagePrefix || '') + 'pluto_rtc_secret_key';
+        let secretKeyBytes;
+        // 1. Manual User Specified Key
+        if (this.options.secretKey) {
+            const match = this.options.secretKey.match(/.{1,2}/g);
+            if (match) {
+                secretKeyBytes = new Uint8Array(match.map(byte => parseInt(byte, 16)));
+            }
+        }
+        // 2. Persistent Mode (Default) - Try Load
+        else if (persistenceMode === 'persistent') {
+            const storedKeyHex = typeof localStorage !== 'undefined' ? localStorage.getItem(storageKey) : null;
+            if (storedKeyHex) {
+                const match = storedKeyHex.match(/.{1,2}/g);
+                if (match) {
+                    secretKeyBytes = new Uint8Array(match.map(byte => parseInt(byte, 16)));
+                }
+            }
+        }
+        // 3. Ephemeral Mode - secretKeyBytes remains undefined (generates new)
+        this.node = await this.wasmPkg.IrohNode.spawn(secretKeyBytes);
+        this.wasmLoaded = true;
+        if (this.node) {
+            const keyBytes = this.node.secret_key;
+            const hexString = Array.from(keyBytes)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            // Save ONLY if Persistent mode AND no manual key was provided (if manual, no need to save, user manages it)
+            if (persistenceMode === 'persistent' && !this.options.secretKey && typeof localStorage !== 'undefined') {
+                localStorage.setItem(storageKey, hexString);
+            }
+            const addrJson = await this.node.node_addr();
+            const addr = JSON.parse(addrJson);
+            this.localNodeId = addr.node_id || addr.id;
+        }
+    }
+    async connect(ticket) {
+        if (!this.wasmLoaded)
+            await this.init();
+        if (!this.node)
+            throw new Error('Node not initialized');
+        // Parse ticket
+        let nodeId = ticket;
+        try {
+            const parsed = JSON.parse(ticket);
+            const extractedId = parsed.node_id || parsed.id;
+            if (extractedId) {
+                nodeId = extractedId;
+                let relayUrl = parsed.relay_url;
+                let directAddrs = parsed.direct_addresses || [];
+                if (Array.isArray(parsed.addrs)) {
+                    for (const addr of parsed.addrs) {
+                        if (addr.Relay)
+                            relayUrl = addr.Relay;
+                        if (addr.Direct)
+                            directAddrs.push(addr.Direct);
+                    }
+                }
+                if (relayUrl || (directAddrs && directAddrs.length > 0)) {
+                    try {
+                        await this.node.addNodeAddr(nodeId, relayUrl, directAddrs);
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                }
+            }
+        }
+        catch { }
+        // Check if already connected
+        const connId = `${this.localNodeId}-${nodeId}`;
+        const existing = this.connections.get(connId);
+        if (existing) {
+            return existing;
+        }
+        // Initiate connection
+        try {
+            console.log(`Initiating connection to ${nodeId}...`);
+            // @ts-ignore
+            this.pendingConnection = this.node.connect(nodeId);
+        }
+        catch (e) {
+            console.warn("Connect trigger failed:", e);
+        }
+        // Retry open_bi loop
+        let biStream = null;
+        let retries = 0;
+        const maxRetries = 40; // 20 seconds
+        while (retries < maxRetries) {
+            try {
+                biStream = await this.node.open_bi(nodeId);
+                break;
+            }
+            catch (e) {
+                retries++;
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        if (!biStream) {
+            throw new Error(`Failed to establish connection to ${nodeId} after ${maxRetries} attempts`);
+        }
+        const connection = new Connection(connId, this.localNodeId, // Local
+        nodeId, // Remote
+        biStream.send.getWriter(), biStream.recv.getReader(), {
+            rtcConfig: this.options.experimental?.nativeWebRTC
+        });
+        this.registerConnection(connection);
+        this.connectionListeners.forEach(cb => cb(connection));
+        connection.send({ type: 'handshake' }).catch(() => { });
+        return connection;
+    }
+    // --- Multiplexing API ---
+    async openBi(nodeId) {
+        if (!this.node)
+            throw new Error("Node not initialized");
+        const bi = await this.node.open_bi(nodeId);
+        return {
+            readable: bi.recv,
+            writable: bi.send
+        };
+    }
+    async openUni(nodeId) {
+        if (!this.node)
+            throw new Error("Node not initialized");
+        return await this.node.open_uni(nodeId);
+    }
+    // --- Listener Management ---
+    getConnections() {
+        return Array.from(this.connections.values());
+    }
+    async getTicket() {
+        if (!this.wasmLoaded)
+            await this.init();
+        if (!this.node || !this.localNodeId)
+            throw new Error('Node not initialized');
+        // @ts-ignore
+        return await this.node.node_addr();
+    }
+    async getNodeId() {
+        if (!this.wasmLoaded)
+            await this.init();
+        if (!this.node || !this.localNodeId)
+            throw new Error('Node not initialized');
+        return this.localNodeId;
+    }
+    async startListening() {
+        if (this.listening)
+            return;
+        if (!this.wasmLoaded)
+            await this.init();
+        if (!this.node)
+            throw new Error('Node not initialized');
+        this.listening = true;
+        this.listenLoop();
+        this.updatePresence();
+        // Auto-update presence (heartbeat) every 1 minute
+        this.presenceInterval = setInterval(() => {
+            this.updatePresence();
+        }, 60000);
+    }
+    stopListening() {
+        this.listening = false;
+        if (this.presenceInterval) {
+            clearInterval(this.presenceInterval);
+            this.presenceInterval = null;
+        }
+        if (this.localNodeId) {
+            this.signaling.setOffline(this.localNodeId);
+        }
+    }
+    async updatePresence() {
+        if (this.localNodeId) {
+            const ticket = await this.getTicket();
+            await this.signaling.updatePresence(this.localNodeId, ticket, true, this.options.deviceTTL);
+        }
+    }
+    async listenLoop() {
+        if (!this.node)
+            return;
+        try {
+            const streams = this.node.incoming_streams();
+            const reader = streams.getReader();
+            while (this.listening) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value) {
+                    this.handleIncomingStream(value);
+                }
+            }
+        }
+        catch (e) {
+            console.error("Listen loop error", e);
+        }
+    }
+    handleIncomingStream(incoming) {
+        // Compatibility check: OLD behavior returned BiStream directly?
+        // New behavior returns { type, stream, endpointId }
+        // Normalize
+        let type = 'bi';
+        let stream = incoming;
+        let endpointId = incoming.endpoint_id;
+        if ('type' in incoming) {
+            // New structure
+            type = incoming.type;
+            stream = incoming.stream;
+            endpointId = incoming.endpointId;
+        }
+        // Notify raw stream listeners (for WebTransport)
+        this.streamListeners.forEach(cb => cb({ type: type, stream, remoteNodeId: endpointId }));
+        // Legacy Connection handling for FIRST Bidirectional Stream
+        // If we don't have a connection for this peer yet, create one using this stream.
+        // This assumes the first stream is the "main" signaling/control channel.
+        if (type === 'bi') {
+            const remoteId = endpointId;
+            const connId = `${this.localNodeId}-${remoteId}`;
+            if (!this.connections.has(connId)) {
+                // New connection!
+                const biStream = stream;
+                const connection = new Connection(connId, this.localNodeId, remoteId, biStream.send.getWriter(), biStream.recv.getReader(), {
+                    rtcConfig: this.options.experimental?.nativeWebRTC
+                });
+                this.registerConnection(connection);
+                this.connectionListeners.forEach(cb => cb(connection));
+            }
+        }
+    }
+    registerConnection(conn) {
+        this.connections.set(conn.id, conn);
+        conn.onMessage((msg) => {
+            this.handleMessage(conn, msg);
+        });
+        conn.onDisconnect(() => {
+            this.connections.delete(conn.id);
+            this.disconnectionListeners.forEach(cb => cb(conn));
+        });
+    }
+    // --- Listeners ---
+    onConnection(callback) {
+        this.connectionListeners.push(callback);
+    }
+    onDisconnection(callback) {
+        this.disconnectionListeners.push(callback);
+    }
+    onMessage(callback) {
+        this.messageListeners.push(callback);
+    }
+    // New: listen for raw headers
+    onIncomingStream(callback) {
+        this.streamListeners.push(callback);
+    }
+    onRoomJoinRequest(callback) {
+        this.roomRequestListeners.push(callback);
+    }
+    // --- Signaling (for WebRTC Upgrade) ---
+    // Deprecated: Connection handles its own signaling via #pluto-signal messages.
+    // Keeping hooks if user wants to send custom signals (e.g. app specific)
+    handleMessage(conn, msg) {
+        // We no longer intercept #signal here, Connection does it before emitting message event.
+        this.messageListeners.forEach(cb => cb(conn, msg));
+    }
+}

package/dist/core/Connection.d.ts

@@ -0,0 +1,66 @@
+export interface ConnectionOptions {
+    reliable?: boolean;
+    rtcConfig?: RTCConfiguration;
+}
+export declare class Connection {
+    private listeners;
+    private closeListeners;
+    private writer;
+    private reader;
+    private _isClosed;
+    get isClosed(): boolean;
+    private receiveBuffer;
+    readonly id: string;
+    readonly deviceId: string;
+    readonly localNodeId: string;
+    private options;
+    private writeMutex;
+    constructor(id: string, localNodeId: string, deviceId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
+    private mediaListeners;
+    /**
+     * Send a message to the other peer.
+     * Messages can be strings or objects (JSON stringified).
+     */
+    send(message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
+    /**
+     * Send media data (video/audio header + payload)
+     * Internal use for now.
+     */
+    sendMedia(type: 'audio' | 'video', data: Uint8Array): Promise<void>;
+    private sendTyped;
+    /**
+     * Disconnect the connection
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Listen for incoming messages
+     */
+    onMessage(callback: (message: any) => void): void;
+    /**
+     * Listen for incoming media
+     */
+    onMedia(callback: (type: 'audio' | 'video', data: Uint8Array) => void): void;
+    /**
+     * Listen for disconnection
+     */
+    onDisconnect(callback: () => void): void;
+    private close;
+    private readLoop;
+    private handleData;
+    private processDataPayload;
+    private emitMedia;
+    private emitMessage;
+    private pc;
+    private dc;
+    private upgradeState;
+    private pendingCandidates;
+    addTrack(track: MediaStreamTrack): RTCRtpSender | null;
+    addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver | null;
+    onTrack(callback: (event: RTCTrackEvent) => void): void;
+    private trackListeners;
+    private attemptUpgrade;
+    private setupPCHandlers;
+    private setupDataChannel;
+    private sendInternalSignal;
+    private handleInternalSignal;
+}