openrtc 0.1.0

package/dist/api/PlutoWebTransport.js

@@ -0,0 +1,105 @@
+import { TransportFactory } from '../core/transports/TransportFactory';
+export class PlutoWebTransport {
+    constructor(url, options, clientInstance) {
+        this.connection = null;
+        this.remoteNodeId = null;
+        this.offIncomingStreams = null;
+        this.url = url;
+        TransportFactory.assertProtocolAvailable('webtransport');
+        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; }
+        });
+        // Use existing connection if provided
+        if (options && options.connection) {
+            this.connection = options.connection;
+            this.remoteNodeId = this.connection.remoteNodeId;
+            this.setupListeners();
+            this._readyResolve();
+            this.connection.onDisconnect(() => {
+                this._closedResolve();
+            });
+        }
+        else {
+            this.setupListeners();
+            this.connect();
+        }
+    }
+    setupListeners() {
+        if (!this.client || typeof this.client.onIncomingStream !== 'function')
+            return;
+        this.offIncomingStreams = 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.trim();
+            if (ticket.startsWith('pluto://')) {
+                ticket = ticket.replace('pluto://', '');
+            }
+            else if (ticket.startsWith('https://') || ticket.startsWith('http://')) {
+                throw new Error('PlutoWebTransport does not support direct native WebTransport URLs. Use a Pluto ticket (pluto://...) routed through the core Client.');
+            }
+            this.connection = await this.client.connect(ticket);
+            this.remoteNodeId = this.connection.remoteNodeId;
+            this.connection.onDisconnect(() => this._closedResolve());
+            this._readyResolve();
+        }
+        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.offIncomingStreams?.();
+        this.offIncomingStreams = null;
+        this.connection?.disconnect();
+    }
+}

package/dist/auth/host.d.ts

@@ -0,0 +1,73 @@
+import { FirebaseApp } from 'firebase/app';
+import { Auth, User } from 'firebase/auth';
+type ProviderName = 'google' | 'apple';
+interface SignInCredentialPayload {
+    provider: ProviderName;
+    idToken: string;
+    accessToken?: string;
+    nonce?: string;
+    isCustomToken?: boolean;
+    callbackId?: string;
+    email?: string;
+    displayName?: string;
+    photoURL?: string;
+}
+type DesktopAuthRelay = (payload: {
+    authToken: string | null;
+    refreshToken: string | null;
+}) => Promise<void> | void;
+export declare function registerDesktopAuthRelay(relay: DesktopAuthRelay | null): void;
+declare class AuthHost {
+    private app;
+    private auth;
+    private functions;
+    private persistenceReady;
+    private redirectResultPromise;
+    private redirectResultConsumed;
+    private lastRelayedToken;
+    private lastRelayedRefreshToken;
+    private desktopTokenRefreshIntervalId;
+    private syncDesktopAuthToken;
+    constructor();
+    getApp(): FirebaseApp;
+    getCurrentUser(): User | null;
+    getAuth(): Auth;
+    onAuthStateChanged(callback: (user: User | null) => void): () => void;
+    onIdTokenChanged(callback: (user: User | null) => void): () => void;
+    getIdToken(options?: {
+        forceRefresh?: boolean;
+    }): Promise<string | null>;
+    checkForSSOToken(): Promise<void>;
+    signInWithCustomTokenValue(token: string): Promise<User>;
+    signInWithPluto(options?: {
+        redirectUri?: string;
+        authorizeBaseUrl?: string;
+    }): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    signIn(email: string, password: string): Promise<User>;
+    signUp(email: string, password: string): Promise<User>;
+    signOut(): Promise<void>;
+    deleteAccount(): Promise<void>;
+    signInWithCredential(payload: SignInCredentialPayload): Promise<User>;
+    private mintSessionTokenFromProviderToken;
+    signInWithPopup(provider: ProviderName): Promise<{
+        idToken: string;
+        refreshToken?: string;
+    }>;
+    signInWithRedirect(provider: ProviderName, options?: {
+        nonce?: string;
+    }): Promise<void>;
+    consumeRedirectResult(): Promise<{
+        fromRedirect: boolean;
+        user: User | null;
+        providerId?: string | null;
+        idToken?: string | null;
+    } | null>;
+    startGoogleSignIn(): Promise<void>;
+    startAppleSignIn(): Promise<void>;
+    mintSessionToken(): Promise<string>;
+}
+export declare function getAuthHost(): AuthHost;
+export declare const authHost: AuthHost;
+export {};

package/dist/auth/host.js

@@ -0,0 +1,513 @@
+import { getApps, initializeApp } from 'firebase/app';
+import { getFunctions, httpsCallable } from 'firebase/functions';
+import { GoogleAuthProvider, OAuthProvider, browserPopupRedirectResolver, inMemoryPersistence, browserLocalPersistence, createUserWithEmailAndPassword, deleteUser, getAuth, initializeAuth, getRedirectResult, getIdToken as firebaseGetIdToken, onIdTokenChanged, onAuthStateChanged, signInWithCustomToken, signInWithCredential, signInWithEmailAndPassword, signInAnonymously, signInWithPopup, signInWithRedirect, signOut, setPersistence, updateProfile, } from 'firebase/auth';
+import { isTauriEnvironment as detectTauriEnvironment } from '../utils/runtime';
+import { PLUTO_HOSTED_FIREBASE_CONFIG } from '../presets/plutoHosted';
+const AUTH_APP_NAME = 'pluto-rtc-auth';
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+let desktopAuthRelay = null;
+function authDebugEnabled() {
+    if (typeof globalThis !== 'undefined' && globalThis.__OPENRTC_DEBUG__ === true) {
+        return true;
+    }
+    if (typeof localStorage !== 'undefined') {
+        try {
+            return localStorage.getItem('openrtc:debug') === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function authDebugLog(message, data) {
+    if (!authDebugEnabled()) {
+        return;
+    }
+    if (typeof data === 'undefined') {
+        console.log(message);
+        return;
+    }
+    console.log(message, data);
+}
+export function registerDesktopAuthRelay(relay) {
+    desktopAuthRelay = relay;
+}
+function isTauri() {
+    return detectTauriEnvironment();
+}
+function isMobileUserAgent() {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+    return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent || '');
+}
+function isTauriMobileEnvironment() {
+    return isTauri() && isMobileUserAgent();
+}
+function withTimeout(promise, timeoutMs, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`${label} timeout after ${timeoutMs}ms`)), timeoutMs);
+        }),
+    ]);
+}
+function generateNonce(length) {
+    const charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._';
+    const randomValues = new Uint8Array(length);
+    window.crypto.getRandomValues(randomValues);
+    let result = '';
+    for (let index = 0; index < length; index += 1) {
+        result += charset[randomValues[index] % charset.length];
+    }
+    return result;
+}
+async function sha256(value) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(value);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+}
+class AuthHost {
+    async syncDesktopAuthToken(user, forceRefresh = false) {
+        if (!desktopAuthRelay) {
+            return;
+        }
+        const token = user ? await firebaseGetIdToken(user, forceRefresh).catch(() => null) : null;
+        const refreshToken = user ? (user.refreshToken ?? null) : null;
+        if (token === this.lastRelayedToken && refreshToken === this.lastRelayedRefreshToken) {
+            return;
+        }
+        this.lastRelayedToken = token;
+        this.lastRelayedRefreshToken = refreshToken;
+        const relayResult = await Promise.allSettled([
+            Promise.resolve(desktopAuthRelay({
+                authToken: token,
+                refreshToken,
+            })),
+        ]);
+        if (relayResult[0]?.status === 'rejected') {
+            console.warn('[PLUTO-RTC][AUTH-HOST] Failed to relay auth token to desktop backend', {
+                message: relayResult[0].reason?.message,
+            });
+        }
+    }
+    constructor() {
+        this.redirectResultPromise = null;
+        this.redirectResultConsumed = false;
+        this.lastRelayedToken = null;
+        this.lastRelayedRefreshToken = null;
+        this.desktopTokenRefreshIntervalId = null;
+        const existingAuthApp = getApps().find((app) => app.name === AUTH_APP_NAME);
+        this.app = existingAuthApp || initializeApp(PLUTO_HOSTED_FIREBASE_CONFIG, AUTH_APP_NAME);
+        const useMobileSafeAuth = isMobileUserAgent();
+        const useTauriMobileSafeAuth = isTauriMobileEnvironment();
+        if (useMobileSafeAuth) {
+            try {
+                const authOptions = useTauriMobileSafeAuth
+                    ? {
+                        persistence: [browserLocalPersistence, inMemoryPersistence],
+                    }
+                    : {
+                        persistence: [browserLocalPersistence, inMemoryPersistence],
+                        popupRedirectResolver: browserPopupRedirectResolver,
+                    };
+                this.auth = initializeAuth(this.app, authOptions);
+                authDebugLog('[PLUTO-RTC][AUTH-HOST] Using mobile-safe Firebase auth initialization', {
+                    appName: this.app.name,
+                    persistence: 'browserLocalPersistence->inMemoryPersistence',
+                    redirectResolver: useTauriMobileSafeAuth ? 'disabled-for-tauri-mobile' : 'browserPopupRedirectResolver',
+                    tauriMobile: useTauriMobileSafeAuth,
+                });
+            }
+            catch {
+                this.auth = getAuth(this.app);
+                console.warn('[PLUTO-RTC][AUTH-HOST] Mobile-safe auth initialization unavailable; falling back to default getAuth');
+            }
+        }
+        else {
+            this.auth = getAuth(this.app);
+        }
+        this.functions = getFunctions(this.app);
+        if (!useMobileSafeAuth) {
+            this.persistenceReady = setPersistence(this.auth, browserLocalPersistence).catch((error) => {
+                console.warn('[PLUTO-RTC][AUTH-HOST] Failed to set auth persistence', {
+                    message: error?.message,
+                });
+            });
+        }
+        else {
+            this.persistenceReady = Promise.resolve();
+        }
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] Initialized auth host', {
+            appName: this.app.name,
+            mobileSafeAuth: useMobileSafeAuth,
+        });
+        onIdTokenChanged(this.auth, (user) => {
+            authDebugLog('[PLUTO-RTC][AUTH-HOST] Firebase ID token changed', {
+                hasUser: !!user,
+                uid: user?.uid,
+                providerDataCount: user?.providerData?.length || 0,
+            });
+            void this.syncDesktopAuthToken(user);
+        });
+        if (!this.desktopTokenRefreshIntervalId) {
+            this.desktopTokenRefreshIntervalId = setInterval(() => {
+                void this.syncDesktopAuthToken(this.auth.currentUser, true);
+            }, 10 * 60 * 1000);
+        }
+    }
+    getApp() {
+        return this.app;
+    }
+    getCurrentUser() {
+        return this.auth.currentUser;
+    }
+    getAuth() {
+        return this.auth;
+    }
+    onAuthStateChanged(callback) {
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] onAuthStateChanged listener registered (via onIdTokenChanged)');
+        return onIdTokenChanged(this.auth, callback);
+    }
+    onIdTokenChanged(callback) {
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] onIdTokenChanged listener registered');
+        return onIdTokenChanged(this.auth, callback);
+    }
+    async getIdToken(options) {
+        if (!this.auth.currentUser) {
+            return null;
+        }
+        return firebaseGetIdToken(this.auth.currentUser, options?.forceRefresh ?? true);
+    }
+    async checkForSSOToken() {
+        if (typeof window === 'undefined')
+            return;
+        const urlParams = new URLSearchParams(window.location.search);
+        const hashParams = new URLSearchParams(window.location.hash.startsWith('#') ? window.location.hash.slice(1) : window.location.hash);
+        const token = urlParams.get('token')
+            || hashParams.get('token')
+            || ((urlParams.get('custom_token') === 'true' || hashParams.get('custom_token') === 'true')
+                ? (urlParams.get('id_token') || hashParams.get('id_token'))
+                : null);
+        if (!token)
+            return;
+        try {
+            await this.persistenceReady;
+            await signInWithCustomToken(this.auth, token);
+            window.history.replaceState({}, document.title, window.location.pathname);
+        }
+        catch (error) {
+            console.error('[PLUTO-RTC][AUTH-HOST] SSO sign-in failed:', error);
+        }
+    }
+    async signInWithCustomTokenValue(token) {
+        await this.persistenceReady;
+        const result = await signInWithCustomToken(this.auth, token);
+        return result.user;
+    }
+    async signInWithPluto(options) {
+        if (typeof window === 'undefined') {
+            throw new Error('Pluto SSO requires a browser environment.');
+        }
+        const redirectUri = options?.redirectUri || window.location.href;
+        const authorizeBaseUrl = options?.authorizeBaseUrl || 'https://pluto.openrtc.app/sso/authorize';
+        const url = new URL(authorizeBaseUrl);
+        url.searchParams.set('redirect_uri', redirectUri);
+        window.location.assign(url.toString());
+    }
+    async waitForAuth() {
+        await this.persistenceReady;
+        if (this.auth.currentUser) {
+            return;
+        }
+        return new Promise((resolve) => {
+            const unsubscribe = onAuthStateChanged(this.auth, (user) => {
+                if (user) {
+                    unsubscribe();
+                    resolve();
+                }
+            });
+        });
+    }
+    async signInAnonymously() {
+        await signInAnonymously(this.auth);
+    }
+    async signIn(email, password) {
+        const result = await signInWithEmailAndPassword(this.auth, email, password);
+        return result.user;
+    }
+    async signUp(email, password) {
+        const result = await createUserWithEmailAndPassword(this.auth, email, password);
+        return result.user;
+    }
+    async signOut() {
+        await signOut(this.auth);
+    }
+    async deleteAccount() {
+        if (!this.auth.currentUser) {
+            throw new Error('No user signed in');
+        }
+        await deleteUser(this.auth.currentUser);
+    }
+    async signInWithCredential(payload) {
+        const startedAt = Date.now();
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] signInWithCredential start', {
+            callbackId: payload.callbackId,
+            provider: payload.provider,
+            hasIdToken: !!payload.idToken,
+            hasAccessToken: !!payload.accessToken,
+            hasNonce: !!payload.nonce,
+        });
+        // Fast path: if we received a custom token (minted by the authenticated
+        // Web App via mintSessionToken), we can sign in directly without going
+        // through the IdP credential flow.
+        if (payload.isCustomToken) {
+            authDebugLog('[PLUTO-RTC][AUTH-HOST] signInWithCredential: custom token detected, using signInWithCustomToken');
+            try {
+                const skipAuthStateReady = isTauriMobileEnvironment();
+                if (skipAuthStateReady) {
+                    authDebugLog('[PLUTO-RTC][AUTH-HOST] Skipping authStateReady before custom token sign-in on Tauri mobile', {
+                        callbackId: payload.callbackId,
+                    });
+                }
+                else {
+                    authDebugLog('[PLUTO-RTC][AUTH-HOST] Awaiting authStateReady...');
+                    try {
+                        await withTimeout(this.auth.authStateReady(), 5000, 'authStateReady');
+                        authDebugLog('[PLUTO-RTC][AUTH-HOST] Auth state ready, signing in with custom token...');
+                    }
+                    catch (readyErr) {
+                        console.warn('[PLUTO-RTC][AUTH-HOST] authStateReady did not resolve in time; continuing custom token sign-in', {
+                            callbackId: payload.callbackId,
+                            message: readyErr?.message,
+                        });
+                    }
+                }
+                let result;
+                try {
+                    result = await withTimeout(signInWithCustomToken(this.auth, payload.idToken), 25000, 'signInWithCustomToken (custom token path)');
+                }
+                catch (firstErr) {
+                    console.warn('[PLUTO-RTC][AUTH-HOST] First custom token sign-in attempt failed; retrying once', {
+                        callbackId: payload.callbackId,
+                        message: firstErr?.message,
+                        code: firstErr?.code,
+                    });
+                    await sleep(250);
+                    result = await withTimeout(signInWithCustomToken(this.auth, payload.idToken), 25000, 'signInWithCustomToken (custom token path retry)');
+                }
+                authDebugLog('[PLUTO-RTC][AUTH-HOST] signInWithCustomToken success', {
+                    callbackId: payload.callbackId,
+                    provider: payload.provider,
+                    uid: result.user?.uid,
+                    elapsedMs: Date.now() - startedAt,
+                });
+                if (result.user && (payload.displayName || payload.photoURL)) {
+                    try {
+                        await updateProfile(result.user, {
+                            displayName: payload.displayName || result.user.displayName || undefined,
+                            photoURL: payload.photoURL || result.user.photoURL || undefined,
+                        });
+                    }
+                    catch (profileError) {
+                        console.warn('[PLUTO-RTC][AUTH-HOST] Failed to update custom-token user profile', {
+                            callbackId: payload.callbackId,
+                            message: profileError?.message,
+                        });
+                    }
+                }
+                return result.user;
+            }
+            catch (err) {
+                console.error('[PLUTO-RTC][AUTH-HOST] signInWithCustomToken failed', {
+                    callbackId: payload.callbackId,
+                    error: err?.message,
+                    code: err?.code,
+                    stack: err?.stack,
+                    elapsedMs: Date.now() - startedAt,
+                });
+                throw err;
+            }
+        }
+        let credential;
+        if (payload.provider === 'google') {
+            credential = GoogleAuthProvider.credential(payload.idToken, payload.accessToken);
+        }
+        else {
+            const provider = new OAuthProvider('apple.com');
+            credential = provider.credential({
+                idToken: payload.idToken,
+                rawNonce: payload.nonce,
+                accessToken: payload.accessToken,
+            });
+        }
+        try {
+            const result = await withTimeout(signInWithCredential(this.auth, credential), 10000, 'firebase signInWithCredential');
+            authDebugLog('[PLUTO-RTC][AUTH-HOST] signInWithCredential success', {
+                callbackId: payload.callbackId,
+                provider: payload.provider,
+                uid: result.user?.uid,
+                elapsedMs: Date.now() - startedAt,
+            });
+            return result.user;
+        }
+        catch (error) {
+            console.warn('[PLUTO-RTC][AUTH-HOST] signInWithCredential primary path failed; trying custom token fallback', {
+                callbackId: payload.callbackId,
+                provider: payload.provider,
+                elapsedMs: Date.now() - startedAt,
+                code: error?.code,
+                message: error?.message,
+            });
+            const customToken = await withTimeout(this.mintSessionTokenFromProviderToken(payload), 15000, 'mintSessionTokenFromProviderToken');
+            const fallbackResult = await withTimeout(signInWithCustomToken(this.auth, customToken), 15000, 'signInWithCustomToken');
+            authDebugLog('[PLUTO-RTC][AUTH-HOST] signInWithCustomToken fallback success', {
+                callbackId: payload.callbackId,
+                provider: payload.provider,
+                uid: fallbackResult.user?.uid,
+                elapsedMs: Date.now() - startedAt,
+            });
+            return fallbackResult.user;
+        }
+    }
+    async mintSessionTokenFromProviderToken(payload) {
+        const callable = httpsCallable(this.functions, 'mintSessionToken');
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] mintSessionToken fallback request start', {
+            provider: payload.provider,
+            hasIdToken: !!payload.idToken,
+            hasNonce: !!payload.nonce,
+        });
+        const result = await callable({
+            provider: payload.provider,
+            idToken: payload.idToken,
+            nonce: payload.nonce,
+        });
+        const token = result.data?.token;
+        if (!token) {
+            throw new Error('mintSessionToken did not return a token for provider exchange');
+        }
+        authDebugLog('[PLUTO-RTC][AUTH-HOST] mintSessionToken fallback request success', {
+            provider: payload.provider,
+        });
+        return token;
+    }
+    async signInWithPopup(provider) {
+        if (provider === 'google') {
+            const googleProvider = new GoogleAuthProvider();
+            googleProvider.addScope('email');
+            googleProvider.addScope('profile');
+            googleProvider.setCustomParameters({ prompt: 'select_account' });
+            const result = await signInWithPopup(this.auth, googleProvider);
+            return {
+                idToken: await firebaseGetIdToken(result.user, true),
+                refreshToken: result.user.refreshToken,
+            };
+        }
+        const appleProvider = new OAuthProvider('apple.com');
+        appleProvider.addScope('email');
+        appleProvider.addScope('name');
+        const nonce = generateNonce(32);
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem('apple_auth_nonce', nonce);
+        }
+        appleProvider.setCustomParameters({ nonce: await sha256(nonce) });
+        const result = await signInWithPopup(this.auth, appleProvider);
+        return {
+            idToken: await firebaseGetIdToken(result.user, true),
+            refreshToken: result.user.refreshToken,
+        };
+    }
+    async signInWithRedirect(provider, options) {
+        if (provider === 'google') {
+            const googleProvider = new GoogleAuthProvider();
+            googleProvider.addScope('email');
+            googleProvider.addScope('profile');
+            googleProvider.setCustomParameters({ prompt: 'select_account' });
+            await signInWithRedirect(this.auth, googleProvider);
+            return;
+        }
+        const appleProvider = new OAuthProvider('apple.com');
+        appleProvider.addScope('email');
+        appleProvider.addScope('name');
+        const rawNonce = options?.nonce || generateNonce(32);
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem('apple_auth_nonce', rawNonce);
+        }
+        appleProvider.setCustomParameters({ nonce: await sha256(rawNonce) });
+        await signInWithRedirect(this.auth, appleProvider);
+    }
+    async consumeRedirectResult() {
+        if (this.redirectResultConsumed) {
+            authDebugLog('[PLUTO-RTC][AUTH-HOST] consumeRedirectResult skipped (already consumed)');
+            return null;
+        }
+        if (this.redirectResultPromise) {
+            return this.redirectResultPromise;
+        }
+        this.redirectResultPromise = (async () => {
+            try {
+                authDebugLog('[PLUTO-RTC][AUTH-HOST] consumeRedirectResult start');
+                const result = await getRedirectResult(this.auth);
+                if (!result) {
+                    authDebugLog('[PLUTO-RTC][AUTH-HOST] consumeRedirectResult: no redirect result');
+                    return {
+                        fromRedirect: false,
+                        user: null,
+                    };
+                }
+                this.redirectResultConsumed = true;
+                const idToken = await firebaseGetIdToken(result.user, true).catch(() => null);
+                const providerId = result.providerId || result.user.providerData?.[0]?.providerId || null;
+                authDebugLog('[PLUTO-RTC][AUTH-HOST] consumeRedirectResult success', {
+                    uid: result.user.uid,
+                    providerId,
+                    hasIdToken: !!idToken,
+                });
+                return {
+                    fromRedirect: true,
+                    user: result.user,
+                    providerId,
+                    idToken,
+                };
+            }
+            finally {
+                this.redirectResultPromise = null;
+            }
+        })();
+        return this.redirectResultPromise;
+    }
+    async startGoogleSignIn() {
+        await this.signInWithRedirect('google');
+    }
+    async startAppleSignIn() {
+        await this.signInWithRedirect('apple');
+    }
+    async mintSessionToken() {
+        const callable = httpsCallable(this.functions, 'mintSessionToken');
+        const result = await callable();
+        const payload = result.data;
+        if (!payload?.token) {
+            throw new Error('mintSessionToken did not return a token');
+        }
+        return payload.token;
+    }
+}
+let authHostInstance = null;
+export function getAuthHost() {
+    if (!authHostInstance) {
+        authHostInstance = new AuthHost();
+    }
+    return authHostInstance;
+}
+export const authHost = new Proxy({}, {
+    get(_target, prop, _receiver) {
+        const host = getAuthHost();
+        const value = host[prop];
+        return typeof value === 'function' ? value.bind(host) : value;
+    },
+});

package/dist/auth/index.d.ts

@@ -0,0 +1 @@
+export { getAuthHost, authHost } from './host';

package/dist/auth/index.js

@@ -0,0 +1 @@
+export { getAuthHost, authHost } from './host';