pluto-rtc 0.0.2

package/dist/core/Room.js

@@ -0,0 +1,297 @@
+import { doc, runTransaction, serverTimestamp, collection, getDocs, updateDoc } from 'firebase/firestore';
+export class RoomManager {
+    constructor(client, signaling) {
+        this.heartbeatInterval = null;
+        this.client = client;
+        this.signaling = signaling;
+    }
+    get db() {
+        return this.signaling.db;
+    }
+    get tag() {
+        // We access tag via signaling options, but we don't have it exposed directly on Signaling instance publicly
+        // A bit of a hack, but let's assume options are available or we pass it
+        // For now, let's fix Signaling to expose tag or access it differently.
+        // Actually, let's just re-use the tag from the signaling instance if we expose it or passed it.
+        // I will update Signaling.ts to expose tag as public readonly or getter.
+        // For now I'll cast to any as a temporary measure or fix Signaling in next step.
+        return this.signaling.tag;
+    }
+    /**
+     * Creates a new room (or joins the special 'demo' room if specified)
+     */
+    async createRoom() {
+        if (!this.signaling.currentUser)
+            throw new Error("Must be signed in");
+        const myTicket = await this.client.getTicket();
+        const userId = this.signaling.currentUser.uid;
+        const myNodeId = await this.client.getNodeId();
+        // Generate 6-char random ID
+        // Try up to 3 times to account for collisions
+        let roomId = '';
+        let created = false;
+        for (let i = 0; i < 3; i++) {
+            roomId = Math.random().toString(36).substring(2, 8).toUpperCase();
+            const roomRef = doc(this.db, `custom/${this.tag}/rooms`, roomId);
+            const memberRef = doc(this.db, `custom/${this.tag}/rooms`, roomId, 'members', myNodeId);
+            try {
+                await runTransaction(this.db, async (transaction) => {
+                    const roomDoc = await transaction.get(roomRef);
+                    if (roomDoc.exists()) {
+                        throw "Room already exists"; // Collision, try again
+                    }
+                    // Create room parent
+                    transaction.set(roomRef, {
+                        hostId: userId,
+                        memberCount: 1,
+                        maxMembers: 10,
+                        status: 'open',
+                        createdAt: serverTimestamp()
+                    });
+                    // Add self as member
+                    transaction.set(memberRef, {
+                        userId: userId, // Store userId for auth verification
+                        ticket: myTicket,
+                        joinedAt: serverTimestamp()
+                    });
+                });
+                console.log(`Room created: ${roomId}`);
+                created = true;
+                break;
+            }
+            catch (e) {
+                if (e === "Room already exists") {
+                    console.log(`Collision for roomId ${roomId}, retrying...`);
+                    continue;
+                }
+                throw e; // Real error
+            }
+        }
+        if (!created) {
+            throw new Error("Failed to create room after multiple attempts (ID collisions).");
+        }
+        return roomId;
+    }
+    /**
+     * Joins a room by ID.
+     */
+    async joinRoom(roomId) {
+        if (!this.signaling.currentUser)
+            throw new Error("Must be signed in");
+        const myTicket = await this.client.getTicket();
+        const userId = this.signaling.currentUser.uid;
+        const myNodeId = await this.client.getNodeId();
+        const normalizedId = roomId.toUpperCase();
+        const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+        const roomRef = doc(this.db, `custom/${this.tag}/rooms`, targetRoomId);
+        const memberRef = doc(this.db, `custom/${this.tag}/rooms`, targetRoomId, 'members', myNodeId);
+        let createdDemo = false;
+        try {
+            await runTransaction(this.db, async (transaction) => {
+                const roomDoc = await transaction.get(roomRef);
+                if (!roomDoc.exists()) {
+                    if (targetRoomId === 'demo') {
+                        // Create demo room on the fly
+                        transaction.set(roomRef, {
+                            hostId: 'system',
+                            memberCount: 1,
+                            maxMembers: 100, // Explicit 100 limit for demo
+                            status: 'open',
+                            createdAt: serverTimestamp(),
+                            isDemo: true
+                        });
+                        createdDemo = true;
+                    }
+                    else {
+                        throw "Room does not exist!";
+                    }
+                }
+                else {
+                    const data = roomDoc.data();
+                    const currentCount = data.memberCount || 0;
+                    const maxMembers = data.maxMembers || 10;
+                    if (currentCount >= maxMembers) {
+                        // Check if I am ALREADY a member
+                        const memberDoc = await transaction.get(memberRef);
+                        if (memberDoc.exists()) {
+                            // Already joined, just update ticket
+                            transaction.update(memberRef, { ticket: myTicket });
+                            return;
+                        }
+                        throw "Room is full!";
+                    }
+                    transaction.update(roomRef, { memberCount: currentCount + 1 });
+                }
+                // Add/Update member
+                if (!createdDemo) {
+                    transaction.set(memberRef, {
+                        userId: userId,
+                        ticket: myTicket,
+                        joinedAt: serverTimestamp()
+                    }, { merge: true });
+                }
+                else {
+                    transaction.set(memberRef, {
+                        userId: userId,
+                        ticket: myTicket,
+                        joinedAt: serverTimestamp()
+                    });
+                }
+            });
+            console.log(`Joined room: ${targetRoomId}`);
+        }
+        catch (e) {
+            console.error("Join Transaction failed: ", e);
+            throw e;
+        }
+        // BOOTSTRAP: Connect to existing members
+        const membersRef = collection(this.db, `custom/${this.tag}/rooms`, targetRoomId, 'members');
+        const membersSnap = await getDocs(membersRef);
+        const connections = [];
+        for (const doc of membersSnap.docs) {
+            if (doc.id === myNodeId)
+                continue; // Skip self
+            const data = doc.data();
+            // Check expiration
+            let isExpired = false;
+            const now = Date.now();
+            if (data.expiresAt) {
+                const exp = data.expiresAt.seconds ? data.expiresAt.seconds * 1000 : new Date(data.expiresAt).getTime();
+                if (exp < now)
+                    isExpired = true;
+            }
+            else {
+                const lastSeen = data.lastSeenAt?.toMillis() || data.joinedAt?.toMillis() || 0;
+                if (now - lastSeen > 5 * 60 * 1000)
+                    isExpired = true;
+            }
+            if (isExpired)
+                continue;
+            const ticket = data.ticket;
+            if (ticket) {
+                try {
+                    console.log(`Bootstrapping: Connecting to peer ${doc.id}...`);
+                    const conn = await this.client.connect(ticket);
+                    conn.send({ type: 'chat', text: `Use ${userId} joined the room.` });
+                    connections.push(conn);
+                }
+                catch (e) {
+                    console.warn(`Failed to connect to peer ${doc.id}:`, e);
+                }
+            }
+        }
+        // Start Heartbeat
+        this.startHeartbeat(targetRoomId, myNodeId);
+        // Prune Stale Members (Lazy cleanup)
+        this.pruneStaleMembers(targetRoomId).catch(console.error);
+        return connections;
+    }
+    async leaveRoom(roomId) {
+        if (!this.signaling.currentUser)
+            return;
+        const myNodeId = await this.client.getNodeId();
+        if (!myNodeId)
+            return;
+        console.log(`Leaving room ${roomId}...`);
+        this.stopHeartbeat();
+        const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+        const roomRef = doc(this.db, `custom/${this.tag}/rooms`, targetRoomId);
+        const memberRef = doc(this.db, `custom/${this.tag}/rooms`, targetRoomId, 'members', myNodeId);
+        try {
+            await runTransaction(this.db, async (transaction) => {
+                const roomDoc = await transaction.get(roomRef);
+                const memberDoc = await transaction.get(memberRef);
+                if (!memberDoc.exists()) {
+                    return;
+                }
+                transaction.delete(memberRef);
+                if (roomDoc.exists()) {
+                    const currentCount = roomDoc.data().memberCount || 0;
+                    if (currentCount > 0) {
+                        transaction.update(roomRef, { memberCount: currentCount - 1 });
+                    }
+                }
+            });
+            console.log(`Left room: ${targetRoomId}`);
+        }
+        catch (e) {
+            console.warn("Leave room failed:", e);
+            throw e;
+        }
+    }
+    // --- Heartbeats & Cleanup ---
+    // --- Heartbeats & Cleanup ---
+    startHeartbeat(roomId, memberId) {
+        if (this.heartbeatInterval)
+            clearInterval(this.heartbeatInterval);
+        const memberRef = doc(this.db, `custom/${this.tag}/rooms`, roomId, 'members', memberId);
+        const update = () => {
+            // Expires in 2 minutes
+            const expiresAt = new Date(Date.now() + 2 * 60 * 1000);
+            updateDoc(memberRef, {
+                lastSeenAt: serverTimestamp(),
+                expiresAt: expiresAt
+            }).catch(e => {
+                console.warn("Heartbeat failed:", e);
+                if (e.message && e.message.includes('No document to update')) {
+                    console.log("Member document not found, stopping heartbeat.");
+                    clearInterval(this.heartbeatInterval);
+                    this.heartbeatInterval = null;
+                }
+            });
+        };
+        update(); // Initial update
+        this.heartbeatInterval = setInterval(update, 60000); // 1 minute
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+            console.log("Heartbeat stopped.");
+        }
+    }
+    async pruneStaleMembers(roomId) {
+        const membersRef = collection(this.db, `custom/${this.tag}/rooms`, roomId, 'members');
+        const now = Date.now();
+        const snapshot = await getDocs(membersRef);
+        const prunePromises = snapshot.docs.map(async (docSnap) => {
+            const data = docSnap.data();
+            let isExpired = false;
+            if (data.expiresAt) {
+                // Handle both Firestore Timestamp and JS Date/number
+                const exp = data.expiresAt.seconds ? data.expiresAt.seconds * 1000 : new Date(data.expiresAt).getTime();
+                if (exp < now)
+                    isExpired = true;
+            }
+            else {
+                // Fallback for legacy members without expiresAt
+                const lastSeen = data.lastSeenAt?.toMillis() || data.joinedAt?.toMillis() || 0;
+                if (now - lastSeen > 5 * 60 * 1000)
+                    isExpired = true;
+            }
+            if (isExpired) {
+                console.log(`Pruning stale member ${docSnap.id}`);
+                try {
+                    const roomRef = doc(this.db, `custom/${this.tag}/rooms`, roomId);
+                    await runTransaction(this.db, async (transaction) => {
+                        const roomDoc = await transaction.get(roomRef);
+                        if (!roomDoc.exists())
+                            return;
+                        const memberDoc = await transaction.get(docSnap.ref);
+                        if (!memberDoc.exists())
+                            return;
+                        transaction.delete(docSnap.ref);
+                        const currentCount = roomDoc.data().memberCount || 0;
+                        if (currentCount > 0) {
+                            transaction.update(roomRef, { memberCount: currentCount - 1 });
+                        }
+                    });
+                }
+                catch (e) {
+                    console.warn(`Failed to prune member ${docSnap.id}:`, e);
+                }
+            }
+        });
+        await Promise.all(prunePromises);
+    }
+}

package/dist/core/Signaling.d.ts

@@ -0,0 +1,37 @@
+import { FirebaseApp } from 'firebase/app';
+import { Auth, User } from 'firebase/auth';
+import { Firestore } from 'firebase/firestore';
+export interface SignalingOptions {
+    tag: string;
+    storagePrefix?: string;
+}
+export declare class Signaling {
+    app: FirebaseApp;
+    auth: Auth;
+    db: Firestore;
+    tag: string;
+    private options;
+    private authListeners;
+    constructor(options: SignalingOptions);
+    get currentUser(): User | null;
+    onAuthChange(callback: (user: User | null) => void): void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): void;
+    signOut(): Promise<void>;
+    private checkForSSOToken;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<{
+        deviceId: string;
+        deviceName: string;
+        online: boolean;
+        ticket: string;
+    }[]>;
+    onDevicesChange(callback: (devices: {
+        deviceId: string;
+        deviceName: string;
+        online: boolean;
+        ticket: string;
+    }[]) => void, excludeNodeId?: string): () => void;
+}

package/dist/core/Signaling.js

@@ -0,0 +1,199 @@
+import { initializeApp } from 'firebase/app';
+import { getAuth, onAuthStateChanged, signInWithCustomToken, signInAnonymously } from 'firebase/auth';
+import { getFirestore, doc, setDoc, updateDoc, serverTimestamp, deleteDoc, collection, query, where, getDocs, onSnapshot, Timestamp } from 'firebase/firestore';
+// Internal Firebase Config
+const FIREBASE_CONFIG = {
+    apiKey: "AIzaSyAxyDE1xSYNAk5Ohe8VvKWi3xHOxB4cNV8",
+    authDomain: "plutonium.hargreaves.dev",
+    projectId: "files-bb895",
+    storageBucket: "files-bb895.firebasestorage.app",
+    messagingSenderId: "734446020343",
+    appId: "1:734446020343:web:da52ff2b8170058fb6d5f2",
+    measurementId: "G-FM0GQ9QF30"
+};
+export class Signaling {
+    constructor(options) {
+        // Auth listeners
+        this.authListeners = [];
+        if (!options.tag)
+            throw new Error("Signaling requires a 'tag' option.");
+        this.tag = options.tag;
+        this.options = options;
+        this.app = initializeApp(FIREBASE_CONFIG);
+        this.auth = getAuth(this.app);
+        // Enable persistence
+        import('firebase/auth').then(({ setPersistence, browserLocalPersistence }) => {
+            setPersistence(this.auth, browserLocalPersistence).catch(console.error);
+        });
+        this.db = getFirestore(this.app);
+        // Check for SSO token immediately
+        this.checkForSSOToken();
+        // Propagate auth state changes
+        onAuthStateChanged(this.auth, (user) => {
+            this.authListeners.forEach(cb => cb(user));
+        });
+    }
+    get currentUser() {
+        return this.auth.currentUser;
+    }
+    onAuthChange(callback) {
+        this.authListeners.push(callback);
+        // Fire immediately with current state if known
+        if (this.auth.currentUser !== undefined) {
+            callback(this.auth.currentUser);
+        }
+    }
+    async signInAnonymously() {
+        await signInAnonymously(this.auth);
+    }
+    signInWithPluto() {
+        const plutoAuthUrl = 'https://plutonium.hargreaves.dev/sso/authorize';
+        const redirectUri = window.location.href;
+        const url = new URL(plutoAuthUrl);
+        url.searchParams.set('redirect_uri', redirectUri);
+        window.location.href = url.toString();
+    }
+    async signOut() {
+        await this.auth.signOut();
+        await this.signInAnonymously();
+    }
+    async checkForSSOToken() {
+        if (typeof window === 'undefined')
+            return;
+        const hash = window.location.hash;
+        if (hash && hash.includes('token=')) {
+            const params = new URLSearchParams(hash.substring(1));
+            const token = params.get('token');
+            if (token) {
+                console.log("Found SSO token, signing in...");
+                try {
+                    await signInWithCustomToken(this.auth, token);
+                    console.log("SSO Sign in successful");
+                    window.history.replaceState(null, '', window.location.pathname + window.location.search);
+                }
+                catch (e) {
+                    console.error("SSO Sign in failed", e);
+                }
+            }
+        }
+    }
+    // --- Presence ---
+    async updatePresence(localNodeId, ticketStr, isOnline = true, ttlMs = 5 * 60 * 1000) {
+        if (!this.auth.currentUser)
+            return;
+        let name = "Web Client";
+        if (typeof navigator !== 'undefined') {
+            if (navigator.userAgent.includes("Chrome"))
+                name = "Chrome";
+            else if (navigator.userAgent.includes("Firefox"))
+                name = "Firefox";
+            else if (navigator.userAgent.includes("Safari"))
+                name = "Safari";
+        }
+        if (this.options.storagePrefix) {
+            const prefix = this.options.storagePrefix.replace(/_$/, '');
+            name = `${name} (${prefix})`;
+        }
+        const deviceRef = doc(this.db, 'users', this.auth.currentUser.uid, 'devices', localNodeId);
+        const expiresAt = Timestamp.fromMillis(Date.now() + ttlMs);
+        try {
+            await setDoc(deviceRef, {
+                userId: this.auth.currentUser.uid,
+                nodeId: localNodeId,
+                ticket: ticketStr,
+                deviceName: name,
+                platformType: 'web',
+                tag: this.tag,
+                online: isOnline,
+                lastSeenAt: serverTimestamp(),
+                expiresAt: expiresAt
+            }, { merge: true });
+        }
+        catch (e) {
+            console.warn("Update presence failed", e);
+        }
+    }
+    async setOffline(localNodeId) {
+        if (this.auth.currentUser && localNodeId) {
+            const deviceRef = doc(this.db, 'users', this.auth.currentUser.uid, 'devices', localNodeId);
+            updateDoc(deviceRef, { online: false }).catch(() => { });
+        }
+    }
+    async cleanupStaleDevices() {
+        if (!this.auth.currentUser)
+            return;
+        const devicesRef = collection(this.db, 'users', this.auth.currentUser.uid, 'devices');
+        // Delete expired devices
+        const now = Timestamp.now();
+        const q = query(devicesRef, where('expiresAt', '<', now));
+        try {
+            const snapshot = await getDocs(q);
+            const deletePromises = [];
+            snapshot.forEach(doc => {
+                deletePromises.push(deleteDoc(doc.ref));
+            });
+            if (deletePromises.length > 0) {
+                await Promise.all(deletePromises);
+            }
+        }
+        catch (e) {
+            console.warn("Failed to cleanup stale devices:", e);
+        }
+    }
+    // --- Discovery ---
+    async searchDevices(excludeNodeId) {
+        if (!this.auth.currentUser)
+            return [];
+        const devicesRef = collection(this.db, 'users', this.auth.currentUser.uid, 'devices');
+        const snapshot = await getDocs(devicesRef);
+        const devices = [];
+        snapshot.forEach(doc => {
+            const data = doc.data();
+            if (excludeNodeId && data.nodeId === excludeNodeId)
+                return;
+            // Check expiration
+            if (data.expiresAt) {
+                const expiresCmp = data.expiresAt instanceof Timestamp ? data.expiresAt.toMillis() : (data.expiresAt.seconds * 1000);
+                if (expiresCmp < Date.now())
+                    return; // Expired
+            }
+            devices.push({
+                deviceId: doc.id,
+                deviceName: data.deviceName || 'Unknown',
+                online: data.online,
+                ticket: data.ticket || data.nodeId
+            });
+        });
+        return devices;
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        if (!this.auth.currentUser)
+            return () => { };
+        const devicesRef = collection(this.db, 'users', this.auth.currentUser.uid, 'devices');
+        // Filter by tag to only show relevant devices
+        const q = query(devicesRef, where('tag', '==', this.tag));
+        const unsub = onSnapshot(q, (snapshot) => {
+            const devices = [];
+            const now = Date.now();
+            snapshot.forEach(doc => {
+                const data = doc.data();
+                if (excludeNodeId && data.nodeId === excludeNodeId)
+                    return;
+                // Check expiration
+                if (data.expiresAt) {
+                    const expiresCmp = data.expiresAt instanceof Timestamp ? data.expiresAt.toMillis() : (data.expiresAt.seconds * 1000);
+                    if (expiresCmp < now)
+                        return; // Expired
+                }
+                devices.push({
+                    deviceId: doc.id,
+                    deviceName: data.deviceName || 'Unknown',
+                    online: data.online,
+                    ticket: data.ticket || data.nodeId
+                });
+            });
+            callback(devices);
+        });
+        return unsub;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core/Client';
+export * from './core/Connection';
+export * from './core/Signaling';
+export * from './core/Room';
+export * from './ConnectionManager';
+export * from './api/PlutoWebSocket';
+export * from './api/PlutoWebTransport';
+export * from './api/PlutoPeerConnection';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './core/Client';
+export * from './core/Connection';
+export * from './core/Signaling';
+export * from './core/Room';
+export * from './ConnectionManager';
+export * from './api/PlutoWebSocket';
+export * from './api/PlutoWebTransport';
+export * from './api/PlutoPeerConnection';

package/dist/react/index.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode } from 'react';
+import { Client, ClientOptions } from '../core/Client';
+export interface PlutoProviderProps {
+    client?: Client;
+    clientOptions?: ClientOptions;
+    children: ReactNode;
+}
+export declare const PlutoProvider: React.FC<PlutoProviderProps>;
+export declare const usePlutoClient: () => Client;

package/dist/react/index.js

@@ -0,0 +1,34 @@
+import React, { createContext, useContext, useEffect, useState } from 'react';
+import { Client } from '../core/Client';
+const PlutoContext = createContext(null);
+export const PlutoProvider = ({ client: existingClient, clientOptions, children }) => {
+    const [client, setClient] = useState(existingClient || null);
+    useEffect(() => {
+        if (existingClient) {
+            setClient(existingClient);
+            return;
+        }
+        if (clientOptions) {
+            const newClient = new Client(clientOptions);
+            newClient.init().then(() => {
+                setClient(newClient);
+            });
+            return () => {
+                // Should we stop listening on unmount? 
+                // Mostly yes, to cleanup resources in that context context.
+                newClient.stopListening();
+            };
+        }
+    }, [existingClient, clientOptions]);
+    if (!client) {
+        return null; // Or some loading state? null is safer for now.
+    }
+    return (React.createElement(PlutoContext.Provider, { value: client }, children));
+};
+export const usePlutoClient = () => {
+    const context = useContext(PlutoContext);
+    if (!context) {
+        throw new Error("usePlutoClient must be used within a PlutoProvider");
+    }
+    return context;
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "pluto-rtc",
+  "version": "0.0.2",
+  "private": false,
+  "description": "A WebRTC library for Plutonium, supporting secure P2P communication.",
+  "keywords": [
+    "webrtc",
+    "p2p",
+    "networking",
+    "plutonium",
+    "iroh"
+  ],
+  "author": "Bryant Hargreaves",
+  "license": "MIT",
+  "homepage": "https://plutonium.hargreaves.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluestarburst/Plutonium.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "wasm"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:wasm": "export CC=/opt/homebrew/opt/llvm/bin/clang && export AR=/opt/homebrew/opt/llvm/bin/llvm-ar && cd ../src-tauri/crates/desktop/iroh-wasm && wasm-pack build --target web --out-dir ../../../../pluto-rtc/wasm/pkg && rm -rf ../../../../pluto-rtc/wasm/pkg/.gitignore",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build:wasm && npm run build"
+  },
+  "dependencies": {
+    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0"
+  },
+  "peerDependencies": {
+    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "happy-dom": "^20.5.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  }
+}