@sparkvault/sdk 1.11.3 → 1.21.4

package/dist/sparkvault.esm.js

@@ -829,26 +829,16 @@ class IdentityApi {
     }
     /**
      * Send SparkLink email for identity verification.
-     * Includes openerOrigin for postMessage-based completion notification.
+     * Includes connectionId for WebSocket push notification of verification result.
      */
-    async sendSparkLink(email, authContext) {
+    async sendSparkLink(email, connectionId, authContext) {
         return this.request('POST', '/sparklink/send', {
             email,
             type: 'verify_identity',
-            // Send opener origin for postMessage on verification completion
-            // This allows the ceremony page to notify the SDK directly instead of polling
-            openerOrigin: typeof window !== 'undefined' ? window.location.origin : undefined,
+            connection_id: connectionId,
             ...this.buildAuthContextParams(authContext),
         });
     }
-    /**
-     * Check SparkLink verification status (polling endpoint)
-     */
-    async checkSparkLinkStatus(sparkId, _authContext) {
-        // For GET requests with auth context, we'd need query params, but the status endpoint
-        // doesn't need auth context - it's already stored in the sparklink record
-        return this.request('GET', `/sparklink/status/${sparkId}`);
-    }
 }
 class IdentityApiError extends Error {
     constructor(message, code, statusCode) {
@@ -1490,7 +1480,7 @@ class TotpHandler {
                 success: false,
                 newKindling: response.kindling,
                 retryAfter: response.retry_after,
-                backoffExpires: response.expires_at,
+                backoffExpires: response.retry_after, // When backoff ends (not code expiry)
                 error: 'Invalid code. Please try again.',
             };
         }
@@ -1507,11 +1497,11 @@ class TotpHandler {
 /**
  * SparkLink Handler
  *
- * Single responsibility: SparkLink sending and status polling.
- * Extracts SparkLink logic from IdentityRenderer for better separation of concerns.
+ * Single responsibility: SparkLink sending.
+ * Verification is handled via WebSocket push (no polling, no iframe).
  */
 /**
- * Handles SparkLink sending and verification polling
+ * Handles SparkLink sending
  */
 class SparkLinkHandler {
     constructor(api, state) {
@@ -1520,10 +1510,11 @@ class SparkLinkHandler {
     }
     /**
      * Send SparkLink to the user's email
+     * @param connectionId - WebSocket connectionId for push notification
      */
-    async send() {
+    async send(connectionId) {
         try {
-            const result = await this.api.sendSparkLink(this.state.recipient, this.state.authContext);
+            const result = await this.api.sendSparkLink(this.state.recipient, connectionId, this.state.authContext);
             return {
                 success: true,
                 sparkId: result.sparkId,
@@ -1538,26 +1529,6 @@ class SparkLinkHandler {
             };
         }
     }
-    /**
-     * Check SparkLink verification status
-     * Called periodically by the renderer to poll for completion
-     */
-    async checkStatus(sparkId) {
-        try {
-            const result = await this.api.checkSparkLinkStatus(sparkId);
-            return {
-                verified: result.verified,
-                token: result.token,
-                identity: result.identity,
-                identityType: result.identityType,
-                redirect: result.redirect,
-            };
-        }
-        catch {
-            // On error, return not verified (polling will continue)
-            return { verified: false };
-        }
-    }
 }
 
 /**
@@ -4230,7 +4201,7 @@ class SparkLinkWaitingView {
      * Switch to expired state - static icon, no animation, helpful message
      */
     showExpiredState() {
-        // Notify renderer to stop polling
+        // Notify renderer to clean up WebSocket connection
         this.props.onExpired();
         // Update waiting section: replace spinner with expired icon
         if (this.waitingSection) {
@@ -4377,9 +4348,8 @@ class IdentityRenderer {
         // View management
         this.currentView = null;
         this.focusTimeoutId = null;
-        // SparkLink polling and postMessage listener
-        this.pollingInterval = null;
-        this.messageListener = null;
+        // SparkLink WebSocket
+        this.sparkLinkWs = null;
         this.container = container;
         this.api = api;
         this.options = options;
@@ -4478,7 +4448,7 @@ class IdentityRenderer {
             clearTimeout(this.focusTimeoutId);
             this.focusTimeoutId = null;
         }
-        this.stopSparkLinkPolling();
+        this.cleanupSparkLink();
         this.destroyCurrentView();
         this.container.destroy();
     }
@@ -4583,7 +4553,7 @@ class IdentityRenderer {
                     onResend: () => this.handleSparkLinkResend(),
                     onFallback: () => this.handleSparkLinkFallback(),
                     onBack: () => this.showMethodSelect(),
-                    onExpired: () => this.stopSparkLinkPolling(),
+                    onExpired: () => this.cleanupSparkLink(),
                 });
             case 'oauth-pending':
                 return new LoadingView({ message: `Connecting to ${state.provider}...` });
@@ -4713,8 +4683,20 @@ class IdentityRenderer {
                 }
                 case 'sparklink': {
                     this.setState({ view: 'loading' });
-                    const result = await this.sparkLinkHandler.send();
+                    // Open WebSocket and get connectionId before sending
+                    const connectionId = await this.openSparkLinkWebSocket();
+                    if (!connectionId) {
+                        this.cleanupSparkLink();
+                        this.setState({
+                            view: 'error',
+                            message: 'Failed to establish connection',
+                            code: 'sparklink_ws_failed',
+                        });
+                        return;
+                    }
+                    const result = await this.sparkLinkHandler.send(connectionId);
                     if (!result.success) {
+                        this.cleanupSparkLink();
                         this.setState({
                             view: 'error',
                             message: result.error ?? 'Failed to send SparkLink',
@@ -4725,10 +4707,8 @@ class IdentityRenderer {
                     this.setState({
                         view: 'sparklink-waiting',
                         email: this.recipient,
-                        sparkId: result.sparkId,
                         expiresAt: result.expiresAt,
                     });
-                    this.startSparkLinkPolling(result.sparkId);
                     break;
                 }
                 case 'social': {
@@ -5014,51 +4994,110 @@ class IdentityRenderer {
         this.callbacks.onSuccess(pendingResult);
     }
     /**
-     * Start listening for SparkLink verification completion.
-     * Uses postMessage as primary mechanism (instant notification from ceremony page),
-     * with polling as fallback for edge cases where postMessage might fail.
+     * Open a WebSocket connection and return the connectionId.
+     * The server echoes back the connectionId on init; this is used to route
+     * the SparkLink verification result back to this SDK instance.
      */
-    startSparkLinkPolling(sparkId) {
-        this.stopSparkLinkPolling();
-        // Primary: Listen for postMessage from ceremony page
-        // This is faster and more reliable than polling
-        this.messageListener = (event) => {
-            // Validate message structure and type
-            if (!event.data || typeof event.data !== 'object')
-                return;
-            if (event.data.type !== 'sparklink_verified')
-                return;
-            const { token, identity, identityType, redirect } = event.data;
-            // Validate required fields
-            if (!token || !identity)
+    openSparkLinkWebSocket() {
+        this.cleanupSparkLink();
+        const wsDomain = this.sdkConfig?.wsDomain || 'ws.sparkvault.com';
+        const wsUrl = `wss://${wsDomain}`;
+        return new Promise((resolve) => {
+            let resolved = false;
+            const ws = new WebSocket(wsUrl);
+            this.sparkLinkWs = ws;
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    ws.close();
+                    resolve(null);
+                }
+            }, 10000);
+            ws.onopen = () => {
+                ws.send(JSON.stringify({ action: 'init' }));
+            };
+            ws.onmessage = (event) => {
+                let data;
+                try {
+                    data = JSON.parse(event.data);
+                }
+                catch {
+                    return;
+                }
+                if (!resolved && data.type === 'connection' && typeof data.connectionId === 'string') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.setupSparkLinkWsHandler(ws);
+                    resolve(data.connectionId);
+                    return;
+                }
+            };
+            ws.onerror = () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    resolve(null);
+                }
+            };
+            ws.onclose = () => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    resolve(null);
+                }
+            };
+        });
+    }
+    /**
+     * Set up WebSocket message handler for SparkLink verification results.
+     * Handles: sparklink_verified, sparklink_failed, sparklink_resent.
+     */
+    setupSparkLinkWsHandler(ws) {
+        ws.onmessage = (event) => {
+            let data;
+            try {
+                data = JSON.parse(event.data);
+            }
+            catch {
                 return;
-            this.handleSparkLinkVerified({
-                token,
-                identity,
-                identityType: identityType || 'email',
-                redirect,
-            });
-        };
-        window.addEventListener('message', this.messageListener);
-        // Fallback: Poll status endpoint every 2 seconds
-        // This catches cases where postMessage might not work (popup blockers, etc)
-        this.pollingInterval = setInterval(async () => {
-            const status = await this.sparkLinkHandler.checkStatus(sparkId);
-            if (status.verified && status.token && status.identity) {
-                this.handleSparkLinkVerified({
-                    token: status.token,
-                    identity: status.identity,
-                    identityType: status.identityType || 'email',
-                    redirect: status.redirect,
-                });
             }
-        }, 2000);
+            switch (data.type) {
+                case 'sparklink_verified':
+                    this.handleSparkLinkVerified({
+                        token: data.token,
+                        identity: data.identity,
+                        identityType: data.identityType || 'email',
+                    });
+                    break;
+                case 'sparklink_failed':
+                    this.cleanupSparkLink();
+                    this.setState({
+                        view: 'error',
+                        message: 'Verification failed. Please try again or choose a different method.',
+                        code: 'sparklink_failed',
+                    });
+                    break;
+                case 'sparklink_resent':
+                    // Server auto-resent a new link — update countdown timer
+                    if (typeof data.expiresAt === 'number') {
+                        this.setState({
+                            view: 'sparklink-waiting',
+                            email: this.recipient,
+                            expiresAt: data.expiresAt,
+                        });
+                    }
+                    break;
+            }
+        };
+        ws.onclose = () => {
+            this.sparkLinkWs = null;
+        };
     }
     /**
-     * Handle successful SparkLink verification (from either postMessage or polling).
+     * Handle successful SparkLink verification via WebSocket push.
      */
     async handleSparkLinkVerified(result) {
-        this.stopSparkLinkPolling();
+        this.cleanupSparkLink();
         // Handle redirect for OIDC/simple mode flows
         if (result.redirect) {
             this.close();
@@ -5078,39 +5117,44 @@ class IdentityRenderer {
         this.callbacks.onSuccess(result);
     }
     /**
-     * Stop SparkLink polling and message listener.
+     * Clean up SparkLink WebSocket connection.
      */
-    stopSparkLinkPolling() {
-        if (this.pollingInterval) {
-            clearInterval(this.pollingInterval);
-            this.pollingInterval = null;
-        }
-        if (this.messageListener) {
-            window.removeEventListener('message', this.messageListener);
-            this.messageListener = null;
+    cleanupSparkLink() {
+        if (this.sparkLinkWs) {
+            this.sparkLinkWs.onmessage = null;
+            this.sparkLinkWs.onclose = null;
+            this.sparkLinkWs.onerror = null;
+            this.sparkLinkWs.close();
+            this.sparkLinkWs = null;
         }
     }
     /**
      * Handle resending SparkLink.
      */
     async handleSparkLinkResend() {
-        const result = await this.sparkLinkHandler.send();
-        if (result.success && result.sparkId) {
-            this.stopSparkLinkPolling();
+        // Open new WebSocket for the resend
+        const connectionId = await this.openSparkLinkWebSocket();
+        if (!connectionId) {
+            this.cleanupSparkLink();
+            return;
+        }
+        const result = await this.sparkLinkHandler.send(connectionId);
+        if (result.success) {
             this.setState({
                 view: 'sparklink-waiting',
                 email: this.recipient,
-                sparkId: result.sparkId,
                 expiresAt: result.expiresAt,
             });
-            this.startSparkLinkPolling(result.sparkId);
+        }
+        else {
+            this.cleanupSparkLink();
         }
     }
     /**
      * Handle fallback from SparkLink to TOTP verification code.
      */
     async handleSparkLinkFallback() {
-        this.stopSparkLinkPolling();
+        this.cleanupSparkLink();
         this.setState({ view: 'loading' });
         const result = await this.totpHandler.send('email');
         if (!result.success) {