openrtc 0.1.0 → 0.1.2

package/dist/core/transports/TauriSignaling.js

@@ -1,373 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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[]>;
-}