@oxyhq/core 10.1.3 → 10.1.5

package/dist/esm/session/SessionClient.js

@@ -1,4 +1,4 @@
-import { deviceSessionStateSchema, deviceSessionSyncSchema, safeParseContract, } from '@oxyhq/contracts';
+import { deviceSessionStateSchema, deviceSessionSyncSchema, safeParseContract, SESSION_ACCOUNTS_CHANGED_EVENT, sessionAccountsChangedEventSchema, } from '@oxyhq/contracts';
 import { logger } from '../utils/loggerUtils.js';
 import { getSocketIO } from './socketLoader.js';
 /**
@@ -308,6 +308,9 @@ export class SessionClient {
                 });
             }
         });
+        socket.on(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();
@@ -315,6 +318,38 @@ export 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 = safeParseContract(sessionAccountsChangedEventSchema, payload);
+        if (!event) {
+            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) => {
+            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/esm/session/accountDialogController.js

@@ -30,7 +30,15 @@ import { extractErrorStatus } from '../utils/errorUtils.js';
 import { CENTRAL_IDP_APEX } from '../utils/authWebUrl.js';
 import { generateOAuthState, generatePkcePair, normalizeOAuthRedirectUri, persistOAuthHandshake, } from '../utils/oauthPkce.js';
 import { projectSwitchableAccounts, switchableAccountIds, } from './accountProjection.js';
-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
@@ -62,6 +70,18 @@ export 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;
@@ -80,6 +100,7 @@ export 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();
     }
     // =========================================================================
@@ -147,6 +168,8 @@ export class AccountDialogController {
             this.unsubscribeTokens = null;
         }
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
+        this.signInToken = null;
         this.listeners.clear();
     }
     // =========================================================================
@@ -420,6 +443,10 @@ export 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
@@ -449,9 +476,10 @@ export class AccountDialogController {
             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);
@@ -506,39 +534,52 @@ export 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.
+                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.
-            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) {
@@ -586,6 +627,7 @@ export class AccountDialogController {
         await this.commitAuthorizedSession(session, user);
         this.signInToken = null;
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
         this.signIn = IDLE_SIGN_IN;
         this.view = 'accounts';
         this.emit();
@@ -607,6 +649,7 @@ export class AccountDialogController {
     }
     failSignIn(message) {
         this.clearPollTimer();
+        this.closeAuthSessionSocket();
         this.signInToken = null;
         this.setSignIn({ ...IDLE_SIGN_IN, phase: 'error', error: message });
     }
@@ -617,6 +660,77 @@ export 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.
+            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) {
+                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) {
+            logger.debug('[AccountDialogController] auth-session socket close failed', { component: 'AccountDialogController' }, error);
+        }
+    }
+    // =========================================================================
     // Snapshot plumbing
     // =========================================================================
     setSignIn(next) {

package/dist/esm/utils/textNormalization.js

@@ -42,28 +42,6 @@
  * the display-name character policy). These functions do exactly one thing:
  * normalize whitespace and Unicode form.
  */
-/**
- * Characters that make a value ineligible for the zero-work fast path, and the
- * whitespace shapes that a normalized INLINE value can never contain.
- *
- * A value that matches nothing here is, by construction, already normalized:
- * it holds only printable ASCII (which is NFC-stable, so `normalize('NFC')`
- * would be a no-op), its only whitespace is the plain space, it has no leading
- * or trailing space, and no run of two spaces. Returning it untouched skips
- * three string allocations — worth it because the common case in the feed
- * hydration hot path is text that is already clean.
- *
- * Non-global (safe for repeated `.test()`; a global regex is stateful).
- */
-const INLINE_NEEDS_NORMALIZATION = /[^\x20-\x7E]|^ | $| {2}/;
-/**
- * Same idea as {@link INLINE_NEEDS_NORMALIZATION}, for MULTILINE values: `\n`
- * joins the printable-ASCII fast-path alphabet, and the additional shapes a
- * normalized body can never contain are a space adjacent to a line break — on
- * either side, since every line is trimmed — and a run of three line breaks
- * (more than one blank line).
- */
-const MULTILINE_NEEDS_NORMALIZATION = /[^\x20-\x7E\n]|^[ \n]|[ \n]$| {2}| \n|\n |\n{3}/;
 /** Any run of whitespace, including tabs, line breaks and Unicode spaces. */
 const ANY_WHITESPACE_RUN = /\s+/g;
 /**
@@ -125,9 +103,6 @@ const EXCESS_BLANK_LINES = /\n{3,}/g;
  * Idempotent: `f(f(x)) === f(x)`.
  */
 export function normalizeInlineText(value) {
-    if (!INLINE_NEEDS_NORMALIZATION.test(value)) {
-        return value;
-    }
     return value.normalize('NFC').replace(ANY_WHITESPACE_RUN, ' ').trim();
 }
 /**
@@ -163,9 +138,6 @@ export function normalizeInlineText(value) {
  * Idempotent: `f(f(x)) === f(x)`.
  */
 export function normalizeMultilineText(value) {
-    if (!MULTILINE_NEEDS_NORMALIZATION.test(value)) {
-        return value;
-    }
     return value
         .normalize('NFC')
         .replace(LINE_BREAK_FORMS, '\n')