@userflow-tech/react-native 0.1.0 → 0.1.1

package/vendor/core/dist/transport/pairing.d.ts

@@ -0,0 +1,121 @@
+import { type PairingJoinPayload, type PairingRelayEvent, type StartFlowWithTokenRelayPayload } from '@userflow-tech/protocol';
+import type { ConnectionState, WebSocketCtor } from './phoenix.js';
+import { type Scheduler } from './scheduler.js';
+export type PairingConnectionEvent = {
+    type: 'state';
+    state: ConnectionState;
+} | {
+    type: 'joined';
+    pairingId: string;
+    deviceId: string;
+} | {
+    type: 'token_expired';
+} | {
+    type: 'device_already_paired';
+} | {
+    type: 'join_error';
+    reason: string;
+} | {
+    type: 'relay';
+    event: PairingRelayEvent;
+    payload: unknown;
+} | {
+    type: 'startFlowWithToken';
+    payload: StartFlowWithTokenRelayPayload;
+} | {
+    type: 'presence_state';
+    payload: unknown;
+} | {
+    type: 'presence_diff';
+    payload: unknown;
+};
+export type PairingConnectionListener = (event: PairingConnectionEvent) => void;
+export interface PairingConnectionOptions {
+    /** Override US-pinned pairing host (tests / local stacks). */
+    pairingEndpoint?: string;
+    scheduler?: Scheduler;
+    reconnectLadderMs?: readonly number[];
+    heartbeatIntervalMs?: number;
+    heartbeatReplyTimeoutMs?: number;
+    now?: () => number;
+    socketCtor?: WebSocketCtor;
+}
+/** Builds the Phoenix websocket URL for `/socket/pairing`. */
+export declare function buildPairingWsUrl(pairingEndpoint: string, pairingToken: string): string;
+/**
+ * Device-side Phoenix connection to `/socket/pairing`.
+ * Authenticated by pairing JWT; joins `pairing:<pairing_id>` with an ephemeral device_id.
+ */
+export declare class PairingConnection {
+    private ws;
+    private ref;
+    private pending;
+    private channelJoinRef;
+    private channelTopic;
+    private channelJoined;
+    private state;
+    private shouldBeConnected;
+    private pairingToken;
+    private claims;
+    private deviceId;
+    private joinMeta;
+    private establishPromise;
+    private pendingConnect;
+    private reconnectHandle;
+    private heartbeatHandle;
+    private heartbeatReplyHandle;
+    private pendingHeartbeatRef;
+    private readonly listeners;
+    private readonly scheduler;
+    private readonly backoff;
+    private readonly heartbeatIntervalMs;
+    private readonly heartbeatReplyTimeoutMs;
+    private readonly pairingEndpoint;
+    private readonly now;
+    private readonly socketCtor;
+    constructor(options?: PairingConnectionOptions);
+    getState(): ConnectionState;
+    getPairingId(): string | null;
+    getDeviceId(): string | null;
+    onEvent(listener: PairingConnectionListener): () => void;
+    /**
+     * Connect with a pairing JWT and join `pairing:<pairing_id>`.
+     * Replaces any existing pairing connection (warm re-scan).
+     */
+    connect(pairingToken: string, join?: Partial<PairingJoinPayload> & {
+        device_id?: string;
+    }): Promise<void>;
+    /** Push a relay event to the builder (e.g. `startFlowWithTokenResult`). */
+    push(event: PairingRelayEvent, payload: unknown): Promise<unknown>;
+    disconnect(options?: {
+        emitState?: boolean;
+    }): void;
+    ensureAlive(): void;
+    private reconnectNow;
+    private isTokenExpired;
+    private handleTokenExpired;
+    private establish;
+    private doEstablish;
+    private attemptEstablish;
+    private openSocket;
+    private joinChannel;
+    private onSocketDown;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private scheduleNextHeartbeat;
+    private clearHeartbeatTimer;
+    private clearHeartbeatReplyTimer;
+    private sendHeartbeat;
+    private handleMessage;
+    private request;
+    private nextRef;
+    private resetChannel;
+    private detachAndClose;
+    private abortPendingConnect;
+    private rejectPending;
+    private setState;
+    private emit;
+}
+//# sourceMappingURL=pairing.d.ts.map

package/vendor/core/dist/transport/pairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.d.ts","sourceRoot":"","sources":["../../src/transport/pairing.ts"],"names":[],"mappings":"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"}

package/vendor/core/dist/transport/pairing.js

@@ -0,0 +1,551 @@
+import { decodePairingJwt, isPairingJwtExpired, isPairingRelayEvent, } from '@userflow-tech/protocol';
+import { DEFAULT_PAIRING_ENDPOINT } from '../constants.js';
+import { UserflowAuthError } from '../errors.js';
+import { createBackoff } from './backoff.js';
+import { defaultScheduler } from './scheduler.js';
+const TIMEOUT_MS = 15000;
+const HEARTBEAT_INTERVAL_MS = 30000;
+const HEARTBEAT_REPLY_TIMEOUT_MS = 10000;
+const WS_OPEN = 1;
+const PHOENIX_TOPIC = 'phoenix';
+function uuid() {
+    const webcrypto = globalThis.crypto;
+    if (webcrypto?.randomUUID)
+        return webcrypto.randomUUID();
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+        const rand = (Math.random() * 16) | 0;
+        const value = char === 'x' ? rand : (rand & 0x3) | 0x8;
+        return value.toString(16);
+    });
+}
+function resolveSocketCtor(ctor) {
+    const provided = ctor ?? globalThis.WebSocket;
+    if (!provided) {
+        throw new UserflowAuthError('No WebSocket implementation is available');
+    }
+    return provided;
+}
+function joinError(response) {
+    if (response && typeof response === 'object') {
+        const err = response;
+        if (typeof err.reason === 'string')
+            return err.reason;
+        if (err.code && err.message)
+            return `${err.code}: ${err.message}`;
+        if (err.message)
+            return err.message;
+    }
+    return 'channel join rejected';
+}
+/** Builds the Phoenix websocket URL for `/socket/pairing`. */
+export function buildPairingWsUrl(pairingEndpoint, pairingToken) {
+    const host = pairingEndpoint.replace(/\/$/, '');
+    const query = `vsn=2.0.0&pairing_token=${encodeURIComponent(pairingToken)}`;
+    const path = `/socket/pairing/websocket?${query}`;
+    if (host.startsWith('http://'))
+        return `ws://${host.slice('http://'.length)}${path}`;
+    if (host.startsWith('https://'))
+        return `wss://${host.slice('https://'.length)}${path}`;
+    if (host.startsWith('ws://') || host.startsWith('wss://'))
+        return `${host}${path}`;
+    return `wss://${host}${path}`;
+}
+/**
+ * Device-side Phoenix connection to `/socket/pairing`.
+ * Authenticated by pairing JWT; joins `pairing:<pairing_id>` with an ephemeral device_id.
+ */
+export class PairingConnection {
+    constructor(options = {}) {
+        this.ws = null;
+        this.ref = 0;
+        this.pending = new Map();
+        this.channelJoinRef = null;
+        this.channelTopic = null;
+        this.channelJoined = false;
+        this.state = 'disconnected';
+        this.shouldBeConnected = false;
+        this.pairingToken = null;
+        this.claims = null;
+        this.deviceId = null;
+        this.joinMeta = {};
+        this.establishPromise = null;
+        this.pendingConnect = null;
+        this.reconnectHandle = null;
+        this.heartbeatHandle = null;
+        this.heartbeatReplyHandle = null;
+        this.pendingHeartbeatRef = null;
+        this.listeners = new Set();
+        this.pairingEndpoint = (options.pairingEndpoint ?? DEFAULT_PAIRING_ENDPOINT).replace(/\/$/, '');
+        this.scheduler = options.scheduler ?? defaultScheduler;
+        this.backoff = createBackoff(options.reconnectLadderMs);
+        this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+        this.heartbeatReplyTimeoutMs =
+            options.heartbeatReplyTimeoutMs ??
+                Math.min(HEARTBEAT_REPLY_TIMEOUT_MS, this.heartbeatIntervalMs);
+        this.now = options.now ?? Date.now;
+        this.socketCtor = options.socketCtor ?? undefined;
+    }
+    getState() {
+        return this.state;
+    }
+    getPairingId() {
+        return this.claims?.pairing_id ?? null;
+    }
+    getDeviceId() {
+        return this.deviceId;
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Connect with a pairing JWT and join `pairing:<pairing_id>`.
+     * Replaces any existing pairing connection (warm re-scan).
+     */
+    async connect(pairingToken, join = {}) {
+        const claims = decodePairingJwt(pairingToken);
+        if (!claims) {
+            throw new UserflowAuthError('Invalid pairing token');
+        }
+        if (isPairingJwtExpired(claims, this.now())) {
+            this.emit({ type: 'token_expired' });
+            throw new UserflowAuthError('Pairing token expired');
+        }
+        this.disconnect({ emitState: false });
+        this.pairingToken = pairingToken;
+        this.claims = claims;
+        this.deviceId = join.device_id ?? uuid();
+        this.joinMeta = {
+            ...(join.model !== undefined ? { model: join.model } : {}),
+            ...(join.os !== undefined ? { os: join.os } : {}),
+            ...(join.app_version !== undefined ? { app_version: join.app_version } : {}),
+        };
+        this.shouldBeConnected = true;
+        this.setState('connecting');
+        try {
+            await this.establish();
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : 'join failed';
+            if (reason.includes('device_already_paired')) {
+                this.emit({ type: 'device_already_paired' });
+            }
+            else if (reason.includes('expired') || this.isTokenExpired()) {
+                this.emit({ type: 'token_expired' });
+            }
+            else {
+                this.emit({ type: 'join_error', reason });
+            }
+            this.shouldBeConnected = false;
+            this.setState('disconnected');
+            throw error;
+        }
+    }
+    /** Push a relay event to the builder (e.g. `startFlowWithTokenResult`). */
+    push(event, payload) {
+        if (!this.channelTopic || !this.channelJoined) {
+            return Promise.reject(new UserflowAuthError('Not joined to a pairing channel'));
+        }
+        return this.request(this.channelTopic, (joinRef, ref) => [
+            joinRef,
+            ref,
+            this.channelTopic,
+            event,
+            payload,
+        ]);
+    }
+    disconnect(options = {}) {
+        const emitState = options.emitState !== false;
+        this.shouldBeConnected = false;
+        this.pairingToken = null;
+        this.claims = null;
+        this.deviceId = null;
+        this.joinMeta = {};
+        this.cancelReconnect();
+        this.stopHeartbeat();
+        this.abortPendingConnect(new UserflowAuthError('Connection closed'));
+        this.rejectPending(new UserflowAuthError('Connection closed'));
+        this.detachAndClose(this.ws);
+        this.resetChannel();
+        if (emitState)
+            this.setState('disconnected');
+        else
+            this.state = 'disconnected';
+    }
+    ensureAlive() {
+        if (!this.shouldBeConnected)
+            return;
+        if (this.isTokenExpired()) {
+            this.handleTokenExpired();
+            return;
+        }
+        if (this.state === 'connected' && this.ws) {
+            if (this.pendingHeartbeatRef !== null)
+                return;
+            this.clearHeartbeatTimer();
+            this.sendHeartbeat();
+            return;
+        }
+        this.reconnectNow();
+    }
+    reconnectNow() {
+        if (!this.shouldBeConnected)
+            return;
+        if (this.state === 'connecting' || this.state === 'connected')
+            return;
+        if (this.isTokenExpired()) {
+            this.handleTokenExpired();
+            return;
+        }
+        this.cancelReconnect();
+        this.backoff.reset();
+        this.setState('reconnecting');
+        this.attemptEstablish();
+    }
+    isTokenExpired() {
+        return this.claims != null && isPairingJwtExpired(this.claims, this.now());
+    }
+    handleTokenExpired() {
+        this.shouldBeConnected = false;
+        this.cancelReconnect();
+        this.stopHeartbeat();
+        this.detachAndClose(this.ws);
+        this.resetChannel();
+        this.setState('disconnected');
+        this.emit({ type: 'token_expired' });
+    }
+    establish() {
+        if (this.establishPromise)
+            return this.establishPromise;
+        this.establishPromise = this.doEstablish().finally(() => {
+            this.establishPromise = null;
+        });
+        return this.establishPromise;
+    }
+    async doEstablish() {
+        if (this.isTokenExpired()) {
+            throw new UserflowAuthError('Pairing token expired');
+        }
+        this.setState(this.state === 'reconnecting' ? 'reconnecting' : 'connecting');
+        await this.openSocket();
+        await this.joinChannel();
+        this.setState('connected');
+        this.backoff.reset();
+        this.startHeartbeat();
+        if (this.claims && this.deviceId) {
+            this.emit({ type: 'joined', pairingId: this.claims.pairing_id, deviceId: this.deviceId });
+        }
+    }
+    attemptEstablish() {
+        void this.establish().catch(() => {
+            if (!this.shouldBeConnected)
+                return;
+            if (this.isTokenExpired()) {
+                this.handleTokenExpired();
+                return;
+            }
+            this.setState('reconnecting');
+            this.scheduleReconnect();
+        });
+    }
+    openSocket() {
+        return new Promise((resolve, reject) => {
+            if (!this.pairingToken) {
+                reject(new UserflowAuthError('Missing pairing token'));
+                return;
+            }
+            const SocketCtor = resolveSocketCtor(this.socketCtor);
+            const ws = new SocketCtor(buildPairingWsUrl(this.pairingEndpoint, this.pairingToken));
+            this.ws = ws;
+            let settled = false;
+            const timer = this.scheduler.setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                this.pendingConnect = null;
+                this.detachAndClose(ws);
+                reject(new UserflowAuthError('WebSocket connection timed out'));
+            }, TIMEOUT_MS);
+            const finish = () => {
+                settled = true;
+                this.pendingConnect = null;
+                this.scheduler.clearTimeout(timer);
+            };
+            this.pendingConnect = {
+                reject: (error) => {
+                    if (settled)
+                        return;
+                    finish();
+                    this.detachAndClose(ws);
+                    reject(error);
+                },
+            };
+            ws.onopen = () => {
+                if (settled)
+                    return;
+                finish();
+                resolve();
+            };
+            ws.onmessage = (event) => this.handleMessage(event);
+            ws.onerror = () => {
+                if (!settled) {
+                    finish();
+                    this.detachAndClose(ws);
+                    reject(new UserflowAuthError('WebSocket connection failed'));
+                }
+                else {
+                    this.onSocketDown(ws);
+                }
+            };
+            ws.onclose = () => {
+                if (!settled) {
+                    finish();
+                    this.detachAndClose(ws);
+                    // Connect reject often means expired/invalid JWT (server closes).
+                    if (this.isTokenExpired()) {
+                        reject(new UserflowAuthError('Pairing token expired'));
+                    }
+                    else {
+                        reject(new UserflowAuthError('WebSocket closed before connect completed'));
+                    }
+                }
+                else {
+                    this.onSocketDown(ws);
+                }
+            };
+        });
+    }
+    async joinChannel() {
+        if (!this.claims || !this.deviceId) {
+            throw new UserflowAuthError('Missing pairing session');
+        }
+        const topic = `pairing:${this.claims.pairing_id}`;
+        this.channelTopic = topic;
+        const payload = {
+            device_id: this.deviceId,
+            ...this.joinMeta,
+        };
+        try {
+            await this.request(topic, (joinRef, ref) => {
+                this.channelJoinRef = joinRef;
+                return [joinRef, ref, topic, 'phx_join', payload];
+            });
+            this.channelJoined = true;
+        }
+        catch (error) {
+            this.channelJoined = false;
+            throw error;
+        }
+    }
+    onSocketDown(socket) {
+        if (this.ws !== socket)
+            return;
+        this.detachAndClose(socket);
+        this.channelJoined = false;
+        this.channelJoinRef = null;
+        this.stopHeartbeat();
+        this.rejectPending(new UserflowAuthError('Connection dropped'));
+        if (!this.shouldBeConnected) {
+            this.setState('disconnected');
+            return;
+        }
+        if (this.isTokenExpired()) {
+            this.handleTokenExpired();
+            return;
+        }
+        this.setState('reconnecting');
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.reconnectHandle !== null)
+            return;
+        const delay = this.backoff.nextDelay();
+        this.reconnectHandle = this.scheduler.setTimeout(() => {
+            this.reconnectHandle = null;
+            if (!this.shouldBeConnected)
+                return;
+            if (this.isTokenExpired()) {
+                this.handleTokenExpired();
+                return;
+            }
+            this.attemptEstablish();
+        }, delay);
+    }
+    cancelReconnect() {
+        if (this.reconnectHandle !== null) {
+            this.scheduler.clearTimeout(this.reconnectHandle);
+            this.reconnectHandle = null;
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.scheduleNextHeartbeat();
+    }
+    stopHeartbeat() {
+        this.clearHeartbeatTimer();
+        this.clearHeartbeatReplyTimer();
+        this.pendingHeartbeatRef = null;
+    }
+    scheduleNextHeartbeat() {
+        this.clearHeartbeatTimer();
+        this.heartbeatHandle = this.scheduler.setTimeout(() => this.sendHeartbeat(), this.heartbeatIntervalMs);
+    }
+    clearHeartbeatTimer() {
+        if (this.heartbeatHandle !== null) {
+            this.scheduler.clearTimeout(this.heartbeatHandle);
+            this.heartbeatHandle = null;
+        }
+    }
+    clearHeartbeatReplyTimer() {
+        if (this.heartbeatReplyHandle !== null) {
+            this.scheduler.clearTimeout(this.heartbeatReplyHandle);
+            this.heartbeatReplyHandle = null;
+        }
+    }
+    sendHeartbeat() {
+        this.heartbeatHandle = null;
+        if (this.state !== 'connected' || !this.ws)
+            return;
+        if (this.pendingHeartbeatRef !== null) {
+            this.onSocketDown(this.ws);
+            return;
+        }
+        const ref = this.nextRef();
+        this.pendingHeartbeatRef = ref;
+        this.ws.send(JSON.stringify([null, ref, PHOENIX_TOPIC, 'heartbeat', {}]));
+        this.clearHeartbeatReplyTimer();
+        this.heartbeatReplyHandle = this.scheduler.setTimeout(() => {
+            this.heartbeatReplyHandle = null;
+            if (this.state !== 'connected' || !this.ws)
+                return;
+            if (this.pendingHeartbeatRef !== null) {
+                this.onSocketDown(this.ws);
+            }
+        }, this.heartbeatReplyTimeoutMs);
+    }
+    handleMessage(event) {
+        let frame;
+        try {
+            frame = JSON.parse(String(event.data));
+        }
+        catch {
+            return;
+        }
+        if (!Array.isArray(frame) || frame.length < 5)
+            return;
+        const [, id, topic, eventName, payload] = frame;
+        if (eventName === 'presence_state') {
+            this.emit({ type: 'presence_state', payload });
+            return;
+        }
+        if (eventName === 'presence_diff') {
+            this.emit({ type: 'presence_diff', payload });
+            return;
+        }
+        if (eventName === 'phx_reply' && typeof id === 'string') {
+            if (topic === PHOENIX_TOPIC && id === this.pendingHeartbeatRef) {
+                this.pendingHeartbeatRef = null;
+                this.clearHeartbeatReplyTimer();
+                if (this.state === 'connected')
+                    this.scheduleNextHeartbeat();
+                return;
+            }
+            const wait = this.pending.get(id);
+            if (!wait || wait.topic !== topic)
+                return;
+            this.pending.delete(id);
+            this.scheduler.clearTimeout(wait.timer);
+            const reply = payload;
+            if (reply.status === 'ok') {
+                wait.ok(reply.response);
+            }
+            else {
+                wait.fail(new UserflowAuthError(`${topic}: ${joinError(reply.response)}`));
+            }
+            return;
+        }
+        if (this.channelTopic && topic === this.channelTopic && typeof eventName === 'string') {
+            if (eventName === 'startFlowWithToken') {
+                const body = (payload ?? {});
+                this.emit({ type: 'startFlowWithToken', payload: body });
+                this.emit({ type: 'relay', event: 'startFlowWithToken', payload });
+                return;
+            }
+            if (isPairingRelayEvent(eventName)) {
+                this.emit({ type: 'relay', event: eventName, payload });
+            }
+        }
+    }
+    request(topic, buildFrame) {
+        return new Promise((ok, fail) => {
+            if (!this.ws || this.ws.readyState !== WS_OPEN) {
+                fail(new UserflowAuthError('WebSocket is not open'));
+                return;
+            }
+            const joinRef = this.channelJoinRef ?? this.nextRef();
+            const ref = this.nextRef();
+            const timer = this.scheduler.setTimeout(() => {
+                const wait = this.pending.get(ref);
+                if (!wait)
+                    return;
+                this.pending.delete(ref);
+                wait.fail(new UserflowAuthError(`${topic}: reply timed out`));
+            }, TIMEOUT_MS);
+            this.pending.set(ref, { topic, timer, ok, fail });
+            this.ws.send(JSON.stringify(buildFrame(joinRef, ref)));
+        });
+    }
+    nextRef() {
+        this.ref += 1;
+        return String(this.ref);
+    }
+    resetChannel() {
+        this.channelTopic = null;
+        this.channelJoinRef = null;
+        this.channelJoined = false;
+    }
+    detachAndClose(ws) {
+        if (!ws)
+            return;
+        ws.onopen = null;
+        ws.onmessage = null;
+        ws.onerror = null;
+        ws.onclose = null;
+        try {
+            ws.close();
+        }
+        catch {
+            // ignore
+        }
+        if (this.ws === ws)
+            this.ws = null;
+    }
+    abortPendingConnect(error) {
+        this.pendingConnect?.reject(error);
+        this.pendingConnect = null;
+    }
+    rejectPending(error) {
+        for (const [, wait] of this.pending) {
+            this.scheduler.clearTimeout(wait.timer);
+            wait.fail(error);
+        }
+        this.pending.clear();
+    }
+    setState(state) {
+        this.state = state;
+        this.emit({ type: 'state', state });
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Never let a subscriber break the socket loop.
+            }
+        }
+    }
+}
+//# sourceMappingURL=pairing.js.map