openrtc 0.1.0

package/dist/core/transports/TauriSignaling.js

@@ -0,0 +1,373 @@
+import { WasmSignalingBackend } from './WasmSignaling';
+function isTauri() {
+    return typeof window !== 'undefined' && !!window.__TAURI_INTERNALS__;
+}
+export class TauriSignalingBackend extends WasmSignalingBackend {
+    constructor(options) {
+        super(options);
+        this.daemonSignalingEnabled = false;
+        this.subscriptionNonce = 0;
+        this.lastSyncedAuthToken = null;
+        this.cachedLocalDeviceId = null;
+    }
+    setDaemonSignalingEnabled(enabled) {
+        this.daemonSignalingEnabled = enabled;
+    }
+    async ensureDaemonAuth() {
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return;
+        }
+        try {
+            await this.waitForAuth();
+            if (!this.currentUser) {
+                await this.signInAnonymously();
+                await this.waitForAuth();
+            }
+            const token = this.currentUser && this.currentUser.getToken
+                ? await this.currentUser.getToken()
+                : null;
+            if (!token) {
+                console.warn('[TauriSignaling] No Firebase auth token available for daemon auth sync');
+                return;
+            }
+            if (token === this.lastSyncedAuthToken) {
+                return;
+            }
+            const { invoke } = await import('@tauri-apps/api/core');
+            await invoke('set_rtc_auth_token', { authToken: token });
+            this.lastSyncedAuthToken = token;
+            console.log(`[TauriSignaling] Synced daemon auth token (len=${token.length})`);
+        }
+        catch (error) {
+            console.warn('[TauriSignaling] Failed to sync daemon auth token:', error);
+        }
+    }
+    async resolveLocalDeviceId() {
+        if (this.cachedLocalDeviceId) {
+            return this.cachedLocalDeviceId;
+        }
+        if (!isTauri()) {
+            return null;
+        }
+        try {
+            const { invoke } = await import('@tauri-apps/api/core');
+            const deviceInfo = await invoke('get_device_info');
+            const deviceId = typeof deviceInfo?.device_id === 'string' ? deviceInfo.device_id.trim() : '';
+            if (!deviceId) {
+                return null;
+            }
+            this.cachedLocalDeviceId = deviceId;
+            return deviceId;
+        }
+        catch {
+            return null;
+        }
+    }
+    withPresenceMetadata(metadata, localDeviceId) {
+        if (!localDeviceId) {
+            return metadata || null;
+        }
+        if (!metadata || !metadata.trim()) {
+            return JSON.stringify({ deviceId: localDeviceId });
+        }
+        try {
+            const parsed = JSON.parse(metadata);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return JSON.stringify({
+                    ...parsed,
+                    deviceId: localDeviceId,
+                });
+            }
+        }
+        catch {
+            // fall through to wrapped raw metadata format
+        }
+        return JSON.stringify({
+            deviceId: localDeviceId,
+            raw: metadata,
+        });
+    }
+    async updatePresence(localNodeId, ticketStr, isOnline = true, ttlMs = 5 * 60 * 1000, metadata) {
+        if (!this.currentUser)
+            return;
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.updatePresence(localNodeId, ticketStr, isOnline, ttlMs, metadata);
+        }
+        await this.ensureDaemonAuth();
+        const localDeviceId = await this.resolveLocalDeviceId();
+        let name = "Desktop App";
+        if (typeof navigator !== 'undefined') {
+            if (navigator.userAgent.includes("Mac OS X"))
+                name = "macOS";
+            else if (navigator.userAgent.includes("Windows"))
+                name = "Windows";
+            else if (navigator.userAgent.includes("Linux"))
+                name = "Linux";
+        }
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('update_rtc_presence', {
+            userId: this.currentUser.id,
+            localNodeId,
+            deviceName: name,
+            ticket: ticketStr,
+            metadata: this.withPresenceMetadata(metadata, localDeviceId)
+        });
+    }
+    async searchDevices(excludeNodeId) {
+        if (!this.currentUser)
+            return [];
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.searchDevices(excludeNodeId);
+        }
+        await this.ensureDaemonAuth();
+        const { invoke } = await import('@tauri-apps/api/core');
+        const jsonLine = await invoke('search_rtc_devices', {
+            userId: this.currentUser.id,
+            excludeNodeId: excludeNodeId || null,
+        });
+        if (jsonLine) {
+            const parsed = JSON.parse(jsonLine);
+            if (parsed.type === "devices") {
+                const devs = (parsed.devices || [])
+                    .map((d) => this.normalizeDevice(d))
+                    .filter((device) => this.matchesTag(device));
+                if (excludeNodeId) {
+                    return devs.filter(d => d.ticket !== excludeNodeId && d.deviceId !== excludeNodeId);
+                }
+                return devs;
+            }
+            if (parsed.type === 'error') {
+                throw new Error(parsed.message || 'Daemon searchDevices failed');
+            }
+        }
+        throw new Error('Daemon returned unexpected searchDevices response');
+    }
+    async setOffline(localNodeId) {
+        if (!this.currentUser)
+            return;
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.setOffline(localNodeId);
+        }
+        await this.ensureDaemonAuth();
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('set_rtc_offline', {
+            userId: this.currentUser.id,
+            localNodeId,
+        });
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        if (!this.currentUser) {
+            return () => { };
+        }
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.onDevicesChange(callback, excludeNodeId);
+        }
+        let cancelled = false;
+        const devicesById = new Map();
+        let reader = null;
+        const emit = () => {
+            let devices = Array.from(devicesById.values());
+            if (excludeNodeId) {
+                devices = devices.filter((device) => device.ticket !== excludeNodeId && device.deviceId !== excludeNodeId);
+            }
+            callback(devices);
+        };
+        const bootstrap = async () => {
+            try {
+                const initialDevices = await this.searchDevices(excludeNodeId);
+                devicesById.clear();
+                for (const device of initialDevices) {
+                    devicesById.set(device.deviceId, device);
+                }
+                emit();
+                const stream = await this.subscribeDevices(this.currentUser.id);
+                reader = stream.getReader();
+                while (!cancelled) {
+                    const { done, value } = await reader.read();
+                    if (done || !value)
+                        break;
+                    for (const event of value) {
+                        if (event.type === 'removed') {
+                            devicesById.delete(event.deviceId);
+                            continue;
+                        }
+                        const normalized = this.normalizeDevice(event.device);
+                        if (!normalized.deviceId)
+                            continue;
+                        if (!this.matchesTag(normalized)) {
+                            devicesById.delete(normalized.deviceId);
+                            continue;
+                        }
+                        devicesById.set(normalized.deviceId, normalized);
+                    }
+                    emit();
+                }
+            }
+            catch (error) {
+                if (!cancelled) {
+                    console.error('[TauriSignaling] onDevicesChange stream failed:', error);
+                }
+            }
+        };
+        void bootstrap();
+        return () => {
+            cancelled = true;
+            if (reader) {
+                void reader.cancel();
+                reader = null;
+            }
+        };
+    }
+    async subscribeDevices(userId) {
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.subscribeDevices(userId);
+        }
+        await this.ensureDaemonAuth();
+        const { invoke } = await import('@tauri-apps/api/core');
+        const { listen } = await import('@tauri-apps/api/event');
+        const requestId = `rtc-devices-${Date.now()}-${++this.subscriptionNonce}`;
+        const normalizeEvents = (events) => {
+            if (!Array.isArray(events))
+                return [];
+            const output = [];
+            for (const event of events) {
+                if (!event || typeof event !== 'object')
+                    continue;
+                const evt = event;
+                const type = typeof evt.type === 'string' ? evt.type : '';
+                if (type === 'removed' && typeof evt.deviceId === 'string') {
+                    output.push({ type: 'removed', deviceId: evt.deviceId });
+                    continue;
+                }
+                if ((type === 'added' || type === 'modified') && evt.device && typeof evt.device === 'object') {
+                    const device = this.normalizeDevice(evt.device);
+                    if (!this.matchesTag(device)) {
+                        continue;
+                    }
+                    output.push({ type, device });
+                }
+            }
+            return output;
+        };
+        let stopSubscription = null;
+        return new ReadableStream({
+            async start(controller) {
+                let unlisten = null;
+                const stop = async () => {
+                    if (unlisten) {
+                        unlisten();
+                        unlisten = null;
+                    }
+                    try {
+                        await invoke('stop_rtc_subscription', { requestId });
+                    }
+                    catch {
+                        // noop
+                    }
+                };
+                stopSubscription = stop;
+                unlisten = await listen('rtc-device-events', (event) => {
+                    const payload = event.payload;
+                    if (!payload || payload.requestId !== requestId)
+                        return;
+                    if (payload.type === 'error') {
+                        controller.error(new Error(payload.message || 'RTC device subscription failed'));
+                        void stop();
+                        return;
+                    }
+                    if (payload.type !== 'deviceEvents') {
+                        return;
+                    }
+                    controller.enqueue(normalizeEvents(payload.events));
+                });
+                try {
+                    await invoke('start_rtc_device_subscription', { requestId, userId });
+                }
+                catch (error) {
+                    await stop();
+                    controller.error(error);
+                }
+            },
+            async cancel() {
+                if (stopSubscription) {
+                    await stopSubscription();
+                    stopSubscription = null;
+                }
+            },
+        });
+    }
+    async subscribeSessions(localDeviceId) {
+        if (!isTauri() || !this.daemonSignalingEnabled) {
+            return super.subscribeSessions(localDeviceId);
+        }
+        await this.ensureDaemonAuth();
+        const { invoke } = await import('@tauri-apps/api/core');
+        const { listen } = await import('@tauri-apps/api/event');
+        const requestId = `rtc-sessions-${Date.now()}-${++this.subscriptionNonce}`;
+        const normalizeEvents = (events) => {
+            if (!Array.isArray(events))
+                return [];
+            const output = [];
+            for (const event of events) {
+                if (!event || typeof event !== 'object')
+                    continue;
+                const evt = event;
+                const type = typeof evt.type === 'string' ? evt.type : '';
+                if (type === 'removed' && typeof evt.sessionId === 'string') {
+                    output.push({ type: 'removed', sessionId: evt.sessionId });
+                    continue;
+                }
+                if ((type === 'added' || type === 'modified') && evt.session && typeof evt.session === 'object') {
+                    output.push({ type, session: evt.session });
+                }
+            }
+            return output;
+        };
+        let stopSubscription = null;
+        return new ReadableStream({
+            async start(controller) {
+                let unlisten = null;
+                const stop = async () => {
+                    if (unlisten) {
+                        unlisten();
+                        unlisten = null;
+                    }
+                    try {
+                        await invoke('stop_rtc_subscription', { requestId });
+                    }
+                    catch {
+                        // noop
+                    }
+                };
+                stopSubscription = stop;
+                unlisten = await listen('rtc-session-events', (event) => {
+                    const payload = event.payload;
+                    if (!payload || payload.requestId !== requestId)
+                        return;
+                    if (payload.type === 'error') {
+                        controller.error(new Error(payload.message || 'RTC session subscription failed'));
+                        void stop();
+                        return;
+                    }
+                    if (payload.type !== 'sessionEvents') {
+                        return;
+                    }
+                    controller.enqueue(normalizeEvents(payload.events));
+                });
+                try {
+                    await invoke('start_rtc_session_subscription', { requestId, localDeviceId });
+                }
+                catch (error) {
+                    await stop();
+                    controller.error(error);
+                }
+            },
+            async cancel() {
+                if (stopSubscription) {
+                    await stopSubscription();
+                    stopSubscription = null;
+                }
+            },
+        });
+    }
+}

package/dist/core/transports/TransportFactory.d.ts

@@ -0,0 +1,9 @@
+import { ITransport } from './ITransport';
+import { ProtocolCapability, ProtocolCapabilityMap, ProtocolName } from '../types';
+export declare class TransportFactory {
+    private static readonly capabilityMap;
+    static createTransport(name: ProtocolName): ITransport;
+    static getProtocolCapability(name: ProtocolName): ProtocolCapability;
+    static getProtocolCapabilities(): ProtocolCapabilityMap;
+    static assertProtocolAvailable(name: ProtocolName): void;
+}

package/dist/core/transports/TransportFactory.js

@@ -0,0 +1,59 @@
+import { WebRTCTransport } from './WebRTCTransport';
+export class TransportFactory {
+    static createTransport(name) {
+        this.assertProtocolAvailable(name);
+        if (name === 'webrtc') {
+            return new WebRTCTransport();
+        }
+        throw new Error(`[TransportFactory] '${name}' is not implemented as an ITransport plugin.`);
+    }
+    static getProtocolCapability(name) {
+        return { ...this.capabilityMap[name] };
+    }
+    static getProtocolCapabilities() {
+        return {
+            iroh: this.getProtocolCapability('iroh'),
+            webrtc: this.getProtocolCapability('webrtc'),
+            websocket: this.getProtocolCapability('websocket'),
+            webtransport: this.getProtocolCapability('webtransport'),
+            moq: this.getProtocolCapability('moq'),
+        };
+    }
+    static assertProtocolAvailable(name) {
+        const capability = this.capabilityMap[name];
+        if (!capability.available || capability.maturity === 'unsupported') {
+            const reason = capability.reason ? ` ${capability.reason}` : '';
+            throw new Error(`[TransportFactory] Protocol '${name}' is unsupported.${reason}`);
+        }
+    }
+}
+TransportFactory.capabilityMap = {
+    iroh: {
+        protocol: 'iroh',
+        maturity: 'stable',
+        available: true,
+    },
+    webrtc: {
+        protocol: 'webrtc',
+        maturity: 'stable',
+        available: true,
+    },
+    websocket: {
+        protocol: 'websocket',
+        maturity: 'experimental',
+        available: true,
+        reason: 'Adapter over Pluto client connection primitives.',
+    },
+    webtransport: {
+        protocol: 'webtransport',
+        maturity: 'experimental',
+        available: true,
+        reason: 'Pluto ticket-backed adapter via core connection system.',
+    },
+    moq: {
+        protocol: 'moq',
+        maturity: 'experimental',
+        available: true,
+        reason: 'Client-level session lifecycle with evolving media/data semantics.',
+    },
+};

package/dist/core/transports/WasmSignaling.d.ts

@@ -0,0 +1,78 @@
+import { FirebaseApp } from 'firebase/app';
+import { Auth } from 'firebase/auth';
+import { Device, DeviceEvent, ISignalingBackend, LocalDaemonInfo, RuntimeIdentity, SignalingEnvelope, SignalingSession, SessionEvent } from '../types';
+export declare class WasmSignalingBackend implements ISignalingBackend {
+    app: FirebaseApp;
+    auth: Auth;
+    tag: string;
+    private options;
+    private authListeners;
+    private persistenceReady;
+    wasmClient: any;
+    private missingWasmWarnings;
+    private readonly wasmReadyWarningDelayMs;
+    private readonly deviceListeners;
+    private nextDeviceListenerId;
+    private deviceReader;
+    private devicesById;
+    private activeDeviceUserId;
+    private deviceSubscriptionCancelled;
+    private deviceSubscriptionTask;
+    private authContext;
+    constructor(options: {
+        tag: string;
+        storagePrefix?: string;
+        nodeIdPersistence?: 'persistent' | 'ephemeral';
+    });
+    private static readonly WEB_DEVICE_ID_STORAGE_PREFIX;
+    private static readonly EPHEMERAL_DEVICE_ID_TTL_MS;
+    private getDeviceIdentityStorageKey;
+    private getNodeIdPersistenceMode;
+    private createRandomDeviceId;
+    private resolveWebLogicalDeviceId;
+    private withWebPresenceMetadata;
+    setAuthContext(context: {
+        userId: string;
+        token?: string | null;
+    } | null): void;
+    private toRuntimeIdentity;
+    protected getCurrentUserId(): string | null;
+    private getFilteredDevices;
+    protected matchesTag(device: Pick<Device, 'tag'>): boolean;
+    private emitDeviceUpdateForListener;
+    private emitDeviceUpdate;
+    private applyDeviceEvents;
+    private stopDeviceSubscription;
+    private startDeviceSubscription;
+    setWasmClient(client: any): void;
+    private warnMissingWasmOnce;
+    private waitForWasmClient;
+    private emptyStream;
+    protected normalizeDevice(raw: Record<string, any>, fallbackId?: string): Device;
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    signOut(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    advertiseLocalDaemon(params: {
+        deviceId: string;
+        host: string;
+        localPort: number;
+        localToken: string;
+        ttlMs?: number;
+    }): Promise<void>;
+    findLocalDaemons(): Promise<LocalDaemonInfo[]>;
+}