@oxyhq/core 10.1.4 → 10.1.5

package/dist/cjs/session/SessionClient.js

@@ -311,6 +311,9 @@ class SessionClient {
                 });
             }
         });
+        socket.on(contracts_1.SESSION_ACCOUNTS_CHANGED_EVENT, (payload) => {
+            this.onSessionAccountsChanged(payload);
+        });
         this.socket = socket;
         // (Re)bind app-facing server-event subscriptions on the fresh socket.
         this.boundServerEvents.clear();
@@ -318,6 +321,38 @@ class SessionClient {
             this.bindServerEvent(event);
         }
     }
+    /**
+     * Handle the token-free `session_accounts_changed` signal (room `user:<userId>`).
+     *
+     * Unlike `session_state` (device-scoped, carries the new state to APPLY), this
+     * reaches ALL of a user's connected sockets across their devices/origins and is
+     * a pure SIGNAL: it carries no token, no secret, and no account bodies. The only
+     * trustworthy bit is "something changed for this user", so — matching the
+     * `session_state` contract's guidance — we re-fetch our OWN authoritative device
+     * state (`bootstrap` → `GET /session/device/state`) and let the existing
+     * `applyState` revision guard reconcile it. We never trust any field on the event
+     * beyond routing it to the current user.
+     *
+     * The refetch is a private (bearer) call: the socket only joins `user:<userId>`
+     * when authenticated, so a signed-out client never receives this — but we guard
+     * the bearer anyway so a race at sign-out can't 401.
+     */
+    onSessionAccountsChanged(payload) {
+        const event = (0, contracts_1.safeParseContract)(contracts_1.sessionAccountsChangedEventSchema, payload);
+        if (!event) {
+            loggerUtils_1.logger.warn('[SessionClient] discarded invalid session_accounts_changed', { component: 'SessionClient' });
+            return;
+        }
+        // The socket is in `user:<activeUserId>` for the planted bearer, so this should
+        // always be the current user; ignore a foreign id defensively (out-of-band relay).
+        if (event.userId !== this.host.getCurrentAccountId())
+            return;
+        if (!this.host.getAccessToken())
+            return;
+        void this.bootstrap().catch((error) => {
+            loggerUtils_1.logger.warn('[SessionClient] session_accounts_changed refetch failed', { component: 'SessionClient' }, error);
+        });
+    }
     /**
      * Open the same-origin `BroadcastChannel` (web only). A sibling tab that
      * commits an account switch / sign-out posts a wake ping; on receipt an

package/dist/cjs/session/accountDialogController.js

@@ -34,7 +34,15 @@ const errorUtils_1 = require("../utils/errorUtils");
 const authWebUrl_1 = require("../utils/authWebUrl");
 const oauthPkce_1 = require("../utils/oauthPkce");
 const accountProjection_1 = require("./accountProjection");
-const DEFAULT_POLL_INTERVAL_MS = 3000;
+/**
+ * Slow FALLBACK poll cadence for the QR flow. The `/auth-session` socket delivers
+ * the approval instantly via `auth_update`; this poll only covers the case where
+ * the socket can't connect, so it is deliberately slow (was 3000 when polling was
+ * the sole mechanism).
+ */
+const DEFAULT_POLL_INTERVAL_MS = 12000;
+/** Socket.IO namespace the API emits QR-flow approval (`auth_update`) events on. */
+const AUTH_SESSION_NAMESPACE = '/auth-session';
 /**
  * Commons's custom URL scheme. Probed via the injected `canOpenApp` to detect an
  * installed Commons on the same device; the `oxycommons://approve?...` deep link
@@ -66,6 +74,18 @@ class AccountDialogController {
         /** The secret device-flow token of the active QR flow (never surfaced). */
         this.signInToken = null;
         this.pollTimer = null;
+        /**
+         * The `/auth-session` socket for the active QR flow, or null (poll-only). Its
+         * `auth_update` event wakes {@link pollOnce} instantly instead of waiting for the
+         * slow fallback timer.
+         */
+        this.authSessionSocket = null;
+        /**
+         * Guards {@link pollOnce} against re-entrancy: the fallback timer and a socket
+         * `auth_update` wake can fire together — without this both could claim the
+         * single-use token concurrently.
+         */
+        this.pollInFlight = false;
         // --- Store plumbing ---
         this.unsubscribeSession = null;
         this.unsubscribeTokens = null;
@@ -84,6 +104,7 @@ class AccountDialogController {
         this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
         this.openUrl = options.openUrl;
         this.canOpenApp = options.canOpenApp;
+        this.socketFactory = options.socketFactory;
         this.snapshot = this.computeSnapshot();
     }
     // =========================================================================
@@ -151,6 +172,8 @@ class AccountDialogController {
             this.unsubscribeTokens = null;
         }
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
+        this.signInToken = null;
         this.listeners.clear();
     }
     // =========================================================================
@@ -424,6 +447,10 @@ class AccountDialogController {
                 expiresAt: handle.expiresAt,
                 error: null,
             });
+            // Primary path: an instant `auth_update` wake over the `/auth-session`
+            // socket. The poll below is only the fallback for when the socket can't
+            // connect, so it now runs at the slow fallback cadence.
+            this.openAuthSessionSocket(handle.sessionToken);
             this.scheduleNextPoll(handle.sessionToken);
             // Same-device convenience: if Commons is installed (native only — `canOpenApp`
             // is undefined/false on web), deep-link straight into its approve screen with
@@ -453,9 +480,10 @@ class AccountDialogController {
             loggerUtils_1.logger.debug('[AccountDialogController] Commons deep-link probe failed (QR fallback active)', { component: 'AccountDialogController' }, error);
         }
     }
-    /** Tear down the active sign-in device flow (timers + token) and reset to idle. */
+    /** Tear down the active sign-in device flow (timers + socket + token) and reset to idle. */
     cancelSignIn() {
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
         this.signInToken = null;
         if (this.signIn !== IDLE_SIGN_IN) {
             this.setSignIn(IDLE_SIGN_IN);
@@ -510,39 +538,52 @@ class AccountDialogController {
             void this.pollOnce(sessionToken);
         }, this.pollIntervalMs);
     }
+    /**
+     * Run one status check + (on approval) claim. Triggered by the fallback timer
+     * AND by the `/auth-session` socket's `auth_update` wake, so it is guarded
+     * against concurrent entry: whichever fires first claims the single-use token;
+     * the other no-ops. The `auth_update` payload is never trusted — this always
+     * re-checks the authoritative status via `pollCommonsSignIn`.
+     */
     async pollOnce(sessionToken) {
-        // A superseded / cancelled flow must not act.
-        if (this.signInToken !== sessionToken)
-            return;
-        const expiresAt = this.signIn.expiresAt;
-        if (typeof expiresAt === 'number' && Date.now() > expiresAt) {
-            this.failSignIn('Session expired. Please try again.');
+        // A superseded / cancelled flow must not act; a poll already running owns the claim.
+        if (this.signInToken !== sessionToken || this.pollInFlight)
             return;
-        }
+        this.pollInFlight = true;
         try {
-            const status = await this.oxyServices.pollCommonsSignIn(sessionToken);
-            if (this.signInToken !== sessionToken)
-                return; // cancelled mid-request
-            if (status.authorized && status.sessionId) {
-                this.clearPollTimer();
-                await this.claimAndComplete(status.sessionId, sessionToken);
+            const expiresAt = this.signIn.expiresAt;
+            if (typeof expiresAt === 'number' && Date.now() > expiresAt) {
+                this.failSignIn('Session expired. Please try again.');
                 return;
             }
-            if (status.status === 'cancelled') {
-                this.failSignIn('Authorization was denied.');
-                return;
+            try {
+                const status = await this.oxyServices.pollCommonsSignIn(sessionToken);
+                if (this.signInToken !== sessionToken)
+                    return; // cancelled mid-request
+                if (status.authorized && status.sessionId) {
+                    this.clearPollTimer();
+                    await this.claimAndComplete(status.sessionId, sessionToken);
+                    return;
+                }
+                if (status.status === 'cancelled') {
+                    this.failSignIn('Authorization was denied.');
+                    return;
+                }
+                if (status.status === 'expired') {
+                    this.failSignIn('Session expired. Please try again.');
+                    return;
+                }
             }
-            if (status.status === 'expired') {
-                this.failSignIn('Session expired. Please try again.');
-                return;
+            catch (error) {
+                // Transient poll error — the next tick retries. Logged, never thrown.
+                loggerUtils_1.logger.debug('[AccountDialogController] poll error (will retry)', { component: 'AccountDialogController' }, error);
+            }
+            if (this.signInToken === sessionToken) {
+                this.scheduleNextPoll(sessionToken);
             }
         }
-        catch (error) {
-            // Transient poll error — the next tick retries. Logged, never thrown.
-            loggerUtils_1.logger.debug('[AccountDialogController] poll error (will retry)', { component: 'AccountDialogController' }, error);
-        }
-        if (this.signInToken === sessionToken) {
-            this.scheduleNextPoll(sessionToken);
+        finally {
+            this.pollInFlight = false;
         }
     }
     async claimAndComplete(sessionId, sessionToken) {
@@ -590,6 +631,7 @@ class AccountDialogController {
         await this.commitAuthorizedSession(session, user);
         this.signInToken = null;
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
         this.signIn = IDLE_SIGN_IN;
         this.view = 'accounts';
         this.emit();
@@ -611,6 +653,7 @@ class AccountDialogController {
     }
     failSignIn(message) {
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
         this.signInToken = null;
         this.setSignIn({ ...IDLE_SIGN_IN, phase: 'error', error: message });
     }
@@ -621,6 +664,77 @@ class AccountDialogController {
         }
     }
     // =========================================================================
+    // /auth-session socket (instant QR approval wake — replaces 3s polling)
+    // =========================================================================
+    /**
+     * Subscribe the active QR flow to the `/auth-session` namespace so the API's
+     * `auth_update` event wakes {@link pollOnce} the instant the approval lands.
+     *
+     * The join is keyed by the secret `sessionToken` (the server's `auth:<token>`
+     * room, joined by emitting `join`) and re-issued on every (re)connect so it
+     * survives socket drops. `auth_update` is treated as a pure SIGNAL — the payload
+     * is never trusted; `pollOnce` re-checks the authoritative status and claims.
+     *
+     * No-op (poll-only) when no `socketFactory` was injected (web without a bundled
+     * `io`, headless/core usage, tests). The namespace needs no auth.
+     */
+    openAuthSessionSocket(sessionToken) {
+        this.closeAuthSessionSocket();
+        if (!this.socketFactory)
+            return;
+        let socket;
+        try {
+            socket = this.socketFactory(`${this.oxyServices.getBaseURL()}${AUTH_SESSION_NAMESPACE}`, {
+                transports: ['websocket'],
+                autoConnect: true,
+                reconnection: true,
+                reconnectionAttempts: Number.POSITIVE_INFINITY,
+                reconnectionDelay: 1000,
+                reconnectionDelayMax: 10000,
+            });
+        }
+        catch (error) {
+            // Socket unavailable — the fallback poll still completes the flow.
+            loggerUtils_1.logger.debug('[AccountDialogController] auth-session socket create failed (poll fallback)', { component: 'AccountDialogController' }, error);
+            return;
+        }
+        const join = () => {
+            if (this.signInToken !== sessionToken)
+                return;
+            try {
+                socket.emit('join', sessionToken);
+            }
+            catch (error) {
+                loggerUtils_1.logger.debug('[AccountDialogController] auth-session join failed', { component: 'AccountDialogController' }, error);
+            }
+        };
+        socket.on('connect', join);
+        if (socket.connected)
+            join();
+        socket.on('auth_update', () => {
+            if (this.signInToken !== sessionToken)
+                return;
+            // Pure wake signal — re-check the authoritative status + claim the poll would have.
+            void this.pollOnce(sessionToken);
+        });
+        this.authSessionSocket = socket;
+    }
+    /** Tear down the `/auth-session` socket, if any. Idempotent. */
+    closeAuthSessionSocket() {
+        const socket = this.authSessionSocket;
+        if (!socket)
+            return;
+        this.authSessionSocket = null;
+        try {
+            socket.off('auth_update');
+            socket.off('connect');
+            socket.disconnect();
+        }
+        catch (error) {
+            loggerUtils_1.logger.debug('[AccountDialogController] auth-session socket close failed', { component: 'AccountDialogController' }, error);
+        }
+    }
+    // =========================================================================
     // Snapshot plumbing
     // =========================================================================
     setSignIn(next) {