pluto-rtc 0.0.2

package/dist/api/PlutoPeerConnection.js

@@ -0,0 +1,242 @@
+import { MediaTransport } from './MediaTransport';
+// Tiny SDP helpers to make the ticket look like an SDP so generic parsers don't choke immediately
+// although we usually just pass the string. The demo code uses desc.sdp.
+function toSDP(ticket) {
+    return `v=0\r\no=- 0 0 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=pluto-ticket:${ticket}\r\n`;
+}
+function fromSDP(sdp) {
+    const match = sdp.match(/a=pluto-ticket:(.+)(\r\n|$)/);
+    return match ? match[1] : null;
+}
+export class PlutoPeerConnection extends EventTarget {
+    static setDefaultClient(client) {
+        this.defaultClient = client;
+    }
+    constructor(configuration, clientInstance) {
+        super();
+        this.onicecandidate = null;
+        this.oniceconnectionstatechange = null;
+        this.ontrack = null;
+        this.onsignalingstatechange = null;
+        this.connectionState = 'new';
+        this.iceConnectionState = 'new';
+        this.signalingState = 'stable';
+        this.localDescription = null;
+        this.remoteDescription = null;
+        this.connection = null;
+        /**
+         * Manually provide an existing connection (e.g. from an incoming connection listener)
+         */
+        // Simplified PlutoPeerConnection
+        // Implementation: Delegates to Core Connection
+        this.bufferTracks = [];
+        this.receivers = {};
+        this.mediaSenders = {};
+        // Try to resolve client: constructor arg -> config arg (custom) -> static default
+        const client = clientInstance || configuration?.client || PlutoPeerConnection.defaultClient;
+        if (!client) {
+            throw new Error("PlutoPeerConnection requires a 'Client' instance. Pass it in constructor or use PlutoPeerConnection.setDefaultClient().");
+        }
+        this.client = client;
+    }
+    async createOffer(options) {
+        // Get our ticket
+        let ticket;
+        try {
+            ticket = await this.client.getTicket();
+        }
+        catch (e) {
+            console.error("Failed to get ticket for offer:", e);
+            ticket = "error-no-ticket";
+        }
+        const sdp = toSDP(ticket);
+        return { type: 'offer', sdp };
+    }
+    async createAnswer(options) {
+        // Return dummy answer. 
+        // In "half-signaling", the connection is arguably already established by the offerer (if they connected) 
+        // OR the answerer (if they connected upon receiving offer).
+        // Strategy: The SIDE THAT RECEIVES THE TICKET connects.
+        // Usually, 'offer' contains ticket. 'Remote' receives offer -> Remote connects to Local.
+        return { type: 'answer', sdp: toSDP('answer-dummy') };
+    }
+    async setLocalDescription(desc) {
+        this.localDescription = desc;
+        this.signalingState = (desc.type === 'offer') ? 'have-local-offer' : 'stable';
+        // If we just set a local offer, we should simulate gathering candidates (immediate finish)
+        if (desc.type === 'offer') {
+            setTimeout(() => {
+                // Emit a null candidate to signal end of candidates
+                const event = new Event('icecandidate');
+                event.candidate = null;
+                if (this.onicecandidate)
+                    this.onicecandidate(event);
+                this.dispatchEvent(event);
+            }, 10);
+        }
+    }
+    async setRemoteDescription(desc) {
+        this.remoteDescription = desc;
+        this.signalingState = (desc.type === 'offer') ? 'have-remote-offer' : 'stable';
+        // Check if description has a ticket
+        const ticket = fromSDP(desc.sdp || '');
+        if (ticket && ticket !== 'answer-dummy' && ticket !== 'error-no-ticket') {
+            // We received a ticket! Connect to it.
+            this.connect(ticket);
+        }
+        else {
+            // Maybe it's an answer? If so, we assume the OTHER side connected to US.
+            // We just wait for the connection to come in via client.onConnection?
+            // Actually, if we are the Offerer, we are passive.
+        }
+    }
+    async addIceCandidate(candidate) {
+        // No-op for Iroh/Pluto
+        return;
+    }
+    async handleIncomingConnection(connection) {
+        this.connection = connection;
+        this.setupHooks();
+        // Flush buffer
+        this.bufferTracks.forEach(t => this.addTrack(t.track));
+        this.bufferTracks = [];
+    }
+    setupHooks() {
+        if (!this.connection)
+            return;
+        this.connection.onDisconnect(() => this.close());
+        this.connection.onTrack((ev) => {
+            if (this.ontrack)
+                this.ontrack(ev);
+            // Clone event to avoid "event is already being dispatched" error
+            const newEvent = new RTCTrackEvent('track', {
+                track: ev.track,
+                streams: [...ev.streams],
+                receiver: ev.receiver,
+                transceiver: ev.transceiver
+            });
+            this.dispatchEvent(newEvent);
+        });
+        // Listen for Iroh media (Fallback/Legacy)
+        this.connection.onMedia((type, data) => {
+            let track = this.receivers[type];
+            if (!track) {
+                // New track received!
+                track = MediaTransport.receiveTrack(type, () => {
+                    this.connection?.send({ type: 'PLI', kind: type }).catch(console.error);
+                });
+                if (track) {
+                    this.receivers[type] = track;
+                    // Helper to fire Event
+                    const event = new Event('track');
+                    event.track = track;
+                    event.streams = [new MediaStream([track])];
+                    event.receiver = { track };
+                    event.transceiver = { receiver: event.receiver, sender: {}, direction: 'receiveonly' };
+                    if (this.ontrack)
+                        this.ontrack(event);
+                    this.dispatchEvent(event);
+                }
+            }
+            if (track)
+                (track.feed(data));
+        });
+    }
+    addTrack(track, ...streams) {
+        const sender = {
+            track,
+            replaceTrack: async () => { },
+            getStats: async () => new Map()
+        };
+        if (this.connection) {
+            // Use Native if available, fallback to Iroh is handled inside Connection or we do dual?
+            // Connection now has addTransceiver/addTrack which ADDS to the native PC.
+            // But we ALSO need to start the Iroh stream for fallback (Graceful).
+            // 1. Add to Native
+            this.connection.addTransceiver(track, { direction: 'sendrecv' });
+            // 2. Start Iroh Stream (Legacy)
+            this.startIrohStream(track);
+        }
+        else {
+            this.bufferTracks.push({ track });
+        }
+        return sender;
+    }
+    async startIrohStream(track) {
+        if (!this.connection)
+            return;
+        const conn = this.connection;
+        try {
+            const sender = await MediaTransport.sendTrack(track, async (data) => {
+                // Stop if connection closed
+                if (!this.connection || this.connection.isClosed) {
+                    // We can throw here to stop MediaTransport
+                    throw new Error("Connection closed");
+                }
+                try {
+                    await conn.sendMedia(track.kind, data);
+                }
+                catch (e) {
+                    if (e.message && e.message.includes('Connection is closed')) {
+                        // Expected race condition on close
+                        return;
+                    }
+                    console.error("Iroh send failed", e);
+                }
+            });
+            if (sender) {
+                this.mediaSenders[track.kind] = sender;
+            }
+        }
+        catch (e) {
+            console.error("Failed to start Iroh stream", e);
+        }
+    }
+    // ... createDataChannel delegates ...
+    createDataChannel(label) {
+        // We return a proxy that calls connection.send
+        return new PlutoDataChannel(label, this);
+    }
+    sendData(data) {
+        this.connection?.send(data);
+    }
+    // ... connect ...
+    async connect(ticket) {
+        this.connection = await this.client.connect(ticket);
+        this.setupHooks();
+    }
+    // ... close ...
+    close() {
+        this.connection?.disconnect();
+        // Stop all legacy senders
+        Object.values(this.mediaSenders).forEach(sender => {
+            try {
+                sender.stop();
+            }
+            catch (e) {
+                console.warn("Error stopping sender", e);
+            }
+        });
+        this.mediaSenders = {};
+        this.updateState('closed');
+    }
+    updateState(state) {
+        this.connectionState = state;
+        this.iceConnectionState = (state === 'closed') ? 'closed' : 'connected'; // aprox
+        this.dispatchEvent(new Event('connectionstatechange'));
+        this.dispatchEvent(new Event('iceconnectionstatechange'));
+    }
+}
+PlutoPeerConnection.defaultClient = null;
+// ... Simple Data Channel Proxy ...
+class PlutoDataChannel extends EventTarget {
+    constructor(label, pc) {
+        super();
+        this.label = label;
+        this.pc = pc;
+        setTimeout(() => this.emitOpen(), 0);
+    }
+    send(data) { this.pc.sendData(data); }
+    emitOpen() { this.dispatchEvent(new Event('open')); if (this.onopen)
+        this.onopen(new Event('open')); }
+}

package/dist/api/PlutoWebSocket.d.ts

@@ -0,0 +1,24 @@
+import { Client } from '../core/Client';
+export declare class PlutoWebSocket extends EventTarget {
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly url: string;
+    readyState: number;
+    bufferedAmount: number;
+    extensions: string;
+    protocol: string;
+    binaryType: "blob" | "arraybuffer";
+    onopen: ((this: PlutoWebSocket, ev: Event) => any) | null;
+    onmessage: ((this: PlutoWebSocket, ev: MessageEvent) => any) | null;
+    onclose: ((this: PlutoWebSocket, ev: CloseEvent) => any) | null;
+    onerror: ((this: PlutoWebSocket, ev: Event) => any) | null;
+    private client;
+    private connection;
+    constructor(url: string, protocols?: string | string[], clientInstance?: Client);
+    private connect;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    private handleClose;
+}

package/dist/api/PlutoWebSocket.js

@@ -0,0 +1,112 @@
+export class PlutoWebSocket extends EventTarget {
+    constructor(url, protocols, clientInstance) {
+        super();
+        this.readyState = PlutoWebSocket.CONNECTING;
+        this.bufferedAmount = 0;
+        this.extensions = "";
+        this.protocol = "";
+        this.binaryType = "blob";
+        this.onopen = null;
+        this.onmessage = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.connection = null;
+        this.url = url;
+        // We need a Client instance. If not provided, we have to throw or use a singleton?
+        // Since Pluto requires setup (tag, auth), it's hard to make a 100% drop-in without configuration.
+        // We will assume the user has a Client initialized or we provide one via a static method,
+        // BUT for a true new WebSocket replacement, we might rely on a global or strictly require a passed client if not configuring here.
+        // However, the standard WebSocket(url) doesn't take a client.
+        // To make it easy, we will support passing the client in the 2nd arg if protocols is ignored/abused, 
+        // or just expect the developer to instantiate this class with the client.
+        if (clientInstance) {
+            this.client = clientInstance;
+        }
+        else {
+            // Fallback: This is tricky. We'll throw for now.
+            throw new Error("PlutoWebSocket requires a 'Client' instance to be passed in constructor currently.");
+        }
+        this.connect();
+    }
+    async connect() {
+        try {
+            // URL format: pluto://<ticket>
+            let ticket = this.url;
+            if (ticket.startsWith('pluto://')) {
+                ticket = ticket.replace('pluto://', '');
+            }
+            else if (ticket.startsWith('wss://') || ticket.startsWith('ws://')) {
+                // Ignore standard WS urls or treat as ticket?
+                // Assume ticket only for now.
+            }
+            this.connection = await this.client.connect(ticket);
+            this.readyState = PlutoWebSocket.OPEN;
+            const event = new Event('open');
+            if (this.onopen)
+                this.onopen(event);
+            this.dispatchEvent(event);
+            this.connection.onMessage((msg) => {
+                let data = msg;
+                // If msg is buffer/uint8array, respect binaryType
+                if (this.binaryType === 'arraybuffer' && (msg instanceof Uint8Array)) {
+                    data = msg.buffer;
+                }
+                const msgEvent = new MessageEvent('message', {
+                    data,
+                    origin: this.url,
+                });
+                if (this.onmessage)
+                    this.onmessage(msgEvent);
+                this.dispatchEvent(msgEvent);
+            });
+            this.connection.onDisconnect(() => {
+                this.handleClose();
+            });
+        }
+        catch (e) {
+            console.error("WebSocket connection failure:", e);
+            const event = new Event('error');
+            if (this.onerror)
+                this.onerror(event);
+            this.dispatchEvent(event);
+            this.handleClose(1006, "Connection failed");
+        }
+    }
+    send(data) {
+        if (this.readyState !== PlutoWebSocket.OPEN || !this.connection) {
+            throw new Error("WebSocket is not open");
+        }
+        if (data instanceof Blob) {
+            data.arrayBuffer().then(buf => {
+                this.connection?.send(buf);
+            });
+        }
+        else {
+            // @ts-ignore - Connection.send handles these
+            this.connection.send(data);
+        }
+    }
+    close(code, reason) {
+        if (this.readyState === PlutoWebSocket.CLOSED)
+            return;
+        this.readyState = PlutoWebSocket.CLOSING;
+        if (this.connection) {
+            this.connection.disconnect();
+        }
+        // Force close if it takes too long? 
+        this.handleClose(code, reason);
+    }
+    handleClose(code = 1000, reason = "") {
+        if (this.readyState === PlutoWebSocket.CLOSED)
+            return;
+        this.readyState = PlutoWebSocket.CLOSED;
+        const event = new CloseEvent('close', { code, reason, wasClean: true });
+        if (this.onclose)
+            this.onclose(event);
+        this.dispatchEvent(event);
+    }
+}
+PlutoWebSocket.CONNECTING = 0;
+PlutoWebSocket.OPEN = 1;
+PlutoWebSocket.CLOSING = 2;
+PlutoWebSocket.CLOSED = 3;

package/dist/api/PlutoWebTransport.d.ts

@@ -0,0 +1,28 @@
+import { Client } from '../core/Client';
+export declare class PlutoWebTransport {
+    readonly ready: Promise<void>;
+    closed: Promise<void>;
+    datagrams: any;
+    incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalStream>;
+    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
+    private client;
+    private connection;
+    private url;
+    private _readyResolve;
+    private _readyReject;
+    private _closedResolve;
+    private _closedReject;
+    private incomingBiController;
+    private incomingUniController;
+    private remoteNodeId;
+    constructor(url: string, options?: any, clientInstance?: Client);
+    private setupListeners;
+    private connect;
+    createBidirectionalStream(): Promise<WebTransportBidirectionalStream>;
+    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
+    close(): void;
+}
+export interface WebTransportBidirectionalStream {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+}

package/dist/api/PlutoWebTransport.js

@@ -0,0 +1,88 @@
+export class PlutoWebTransport {
+    constructor(url, options, clientInstance) {
+        this.connection = null;
+        this.remoteNodeId = null;
+        this.url = url;
+        if (clientInstance) {
+            this.client = clientInstance;
+        }
+        else {
+            throw new Error("PlutoWebTransport requires a 'Client' instance to be passed in constructor currently.");
+        }
+        this.ready = new Promise((resolve, reject) => {
+            this._readyResolve = resolve;
+            this._readyReject = reject;
+        });
+        this.closed = new Promise((resolve, reject) => {
+            this._closedResolve = resolve;
+            this._closedReject = reject;
+        });
+        this.datagrams = {
+            readable: new ReadableStream(),
+            writable: new WritableStream()
+        };
+        this.incomingBidirectionalStreams = new ReadableStream({
+            start: (controller) => { this.incomingBiController = controller; }
+        });
+        this.incomingUnidirectionalStreams = new ReadableStream({
+            start: (controller) => { this.incomingUniController = controller; }
+        });
+        this.setupListeners();
+        this.connect();
+    }
+    setupListeners() {
+        this.client.onIncomingStream((incoming) => {
+            // Filter by remote Node ID if we are connected
+            if (!this.remoteNodeId || incoming.remoteNodeId !== this.remoteNodeId) {
+                return;
+            }
+            if (incoming.type === 'bi') {
+                const stream = incoming.stream; // BiStream
+                this.incomingBiController.enqueue({
+                    readable: stream.recv,
+                    writable: stream.send
+                });
+            }
+            else if (incoming.type === 'uni') {
+                const stream = incoming.stream; // ReadableStream
+                this.incomingUniController.enqueue(stream);
+            }
+        });
+    }
+    async connect() {
+        try {
+            let ticket = this.url;
+            if (ticket.startsWith('pluto://')) {
+                ticket = ticket.replace('pluto://', '');
+            }
+            else if (ticket.startsWith('https://')) {
+                // WebTransport uses https, but we treat it as ticket for now or need a way to resolve
+            }
+            this.connection = await this.client.connect(ticket);
+            this.remoteNodeId = this.connection.deviceId; // Get peer ID from connection
+            this._readyResolve();
+            this.connection.onDisconnect(() => {
+                this._closedResolve();
+            });
+        }
+        catch (e) {
+            this._readyReject(e);
+            this._closedReject(e);
+        }
+    }
+    async createBidirectionalStream() {
+        await this.ready;
+        if (!this.connection || !this.remoteNodeId)
+            throw new Error("Connection not established");
+        return await this.client.openBi(this.remoteNodeId);
+    }
+    async createUnidirectionalStream() {
+        await this.ready;
+        if (!this.connection || !this.remoteNodeId)
+            throw new Error("Connection not established");
+        return await this.client.openUni(this.remoteNodeId);
+    }
+    close() {
+        this.connection?.disconnect();
+    }
+}

package/dist/core/Client.d.ts

@@ -0,0 +1,70 @@
+import { Connection } from './Connection';
+import { Signaling } from './Signaling';
+import { RoomManager, JoinRequest } from './Room';
+export interface ClientOptions {
+    tag: string;
+    storagePrefix?: string;
+    deviceTTL?: number;
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    secretKey?: string;
+    experimental?: {
+        nativeWebRTC?: RTCConfiguration;
+    };
+}
+export declare class Client {
+    signaling: Signaling;
+    rooms: RoomManager;
+    private wasmLoaded;
+    private wasmPkg;
+    private node;
+    private connections;
+    private connectionListeners;
+    private disconnectionListeners;
+    private messageListeners;
+    private roomRequestListeners;
+    private streamListeners;
+    private localNodeId;
+    private listening;
+    private options;
+    private pendingConnection;
+    private presenceInterval;
+    constructor(options: ClientOptions);
+    get currentUser(): import("@firebase/auth").User | null;
+    onAuthChange(callback: (user: any) => void): void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): void;
+    signOut(): Promise<void>;
+    searchDevices(): Promise<{
+        deviceId: string;
+        deviceName: string;
+        online: boolean;
+        ticket: string;
+    }[]>;
+    onDevicesChange(callback: any): () => void;
+    init(): Promise<void>;
+    connect(ticket: string): Promise<Connection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    getConnections(): Connection[];
+    getTicket(): Promise<string>;
+    getNodeId(): Promise<string>;
+    startListening(): Promise<void>;
+    stopListening(): void;
+    private updatePresence;
+    private listenLoop;
+    private handleIncomingStream;
+    private registerConnection;
+    onConnection(callback: (conn: Connection) => void): void;
+    onDisconnection(callback: (conn: Connection) => void): void;
+    onMessage(callback: (conn: Connection, msg: any) => void): void;
+    onIncomingStream(callback: (stream: {
+        type: 'bi' | 'uni';
+        stream: any;
+        remoteNodeId: string;
+    }) => void): void;
+    onRoomJoinRequest(callback: (request: JoinRequest) => void): void;
+    private handleMessage;
+}