@oxyhq/core 2.0.0 → 2.1.1

package/dist/esm/CrossDomainAuth.js

@@ -21,6 +21,7 @@
  * const session = await auth.signInWithPopup();
  * ```
  */
+import { logger } from './utils/loggerUtils.js';
 export class CrossDomainAuth {
     constructor(oxyServices) {
         this.oxyServices = oxyServices;
@@ -94,7 +95,7 @@ export class CrossDomainAuth {
                 return session;
             }
             catch (error) {
-                console.warn('[CrossDomainAuth] FedCM failed, trying popup...', error);
+                logger.warn('FedCM failed, trying popup', { component: 'CrossDomainAuth', method: 'autoSignIn' }, error);
             }
         }
         // 2. Try popup (good UX, widely supported)
@@ -103,7 +104,7 @@ export class CrossDomainAuth {
             return await this.signInWithPopup(options);
         }
         catch (error) {
-            console.warn('[CrossDomainAuth] Popup failed, falling back to redirect...', error);
+            logger.warn('Popup failed, falling back to redirect', { component: 'CrossDomainAuth', method: 'autoSignIn' }, error);
             // Popup path failed — close the pre-opened popup before redirecting.
             this.closeOrphanPopup(options.popup);
         }
@@ -172,7 +173,7 @@ export class CrossDomainAuth {
                 }
             }
             catch (error) {
-                console.warn('[CrossDomainAuth] FedCM silent sign-in failed:', error);
+                logger.debug('FedCM silent sign-in did not resolve', { component: 'CrossDomainAuth', method: 'silentSignIn' }, error);
             }
         }
         // Fallback to iframe-based silent auth
@@ -180,7 +181,7 @@ export class CrossDomainAuth {
             return await this.oxyServices.silentSignIn();
         }
         catch (error) {
-            console.warn('[CrossDomainAuth] Silent sign-in failed:', error);
+            logger.debug('iframe silent sign-in did not resolve', { component: 'CrossDomainAuth', method: 'silentSignIn' }, error);
             return null;
         }
     }
@@ -265,7 +266,7 @@ export class CrossDomainAuth {
                 }
             }
             catch (error) {
-                console.warn('[CrossDomainAuth] Stored session invalid:', error);
+                logger.debug('stored session invalid', { component: 'CrossDomainAuth', method: 'initialize' }, error);
             }
         }
         // 3. Try silent sign-in (check for SSO session at auth.oxy.so)

package/dist/esm/index.js

@@ -97,6 +97,11 @@ export { updateAvatarVisibility } from './utils/avatarUtils.js';
 // ---------------------------------------------------------------------------
 export { buildAccountsArray, createQuickAccount, getAccountDisplayName, getAccountFallbackHandle, formatPublicKeyHandle, mergeAccountsFromRefreshAll, getAccountColor, } from './utils/accountUtils.js';
 // ---------------------------------------------------------------------------
+// Cross-domain SSO infrastructure
+// ---------------------------------------------------------------------------
+export { autoDetectAuthWebUrl } from './utils/fapiAutoDetect.js';
+export { runColdBoot } from './utils/coldBoot.js';
+// ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 export { packageInfo } from './constants/version.js';

package/dist/esm/utils/coldBoot.js

@@ -0,0 +1,68 @@
+/**
+ * coldBoot — a pure, ordered, short-circuit runner for "cold boot"
+ * authentication resolution.
+ *
+ * On a fresh page load / app launch the SDK may have several ways to recover an
+ * existing session (silent FedCM, a persisted refresh token, a cross-domain
+ * claim, an explicit popup flow, …). They must be attempted in a *deterministic
+ * order*, and the FIRST one that yields a session wins — every later step is
+ * skipped. This module encodes exactly that contract and nothing else.
+ *
+ * Design constraints (all enforced):
+ *   - PURE: no DOM, no `navigator`, no `window`, no React, no platform globals.
+ *   - NO module-level mutable state. Every call to {@link runColdBoot} is fully
+ *     self-contained, so it is safe under bundler re-evaluation (e.g. the Metro
+ *     web bundle, which is precisely why the FedCM silent-SSO guard had to live
+ *     in consumers rather than a core singleton).
+ *   - Architecture-agnostic: both candidate cross-domain SSO designs consume
+ *     this same primitive; it knows nothing about HOW a step resolves a session.
+ *
+ * A step is skipped (without running) when its `enabled` predicate returns
+ * false. Any thrown error — from either `enabled` or `run` — is reported via
+ * `onStepError` and treated as a non-fatal skip, so one broken recovery path
+ * can never prevent a later, healthy one from succeeding.
+ */
+/**
+ * Run the ordered cold-boot steps and resolve to the first recovered session,
+ * or `unauthenticated` if none recovers one.
+ *
+ * Semantics:
+ *   1. Iterate `steps` in order.
+ *   2. If a step has an `enabled` predicate, call it inside try/catch:
+ *      - throw → report via `onStepError(id, err)` → treat as disabled → continue.
+ *      - returns false → continue (skip, `run` not called).
+ *   3. Otherwise await `step.run()` inside try/catch:
+ *      - throw → report via `onStepError(id, err)` → continue.
+ *      - `{ kind: 'session' }` → return `{ kind: 'session', via: step.id, session }`.
+ *      - `{ kind: 'skip' }` → continue.
+ *   4. After the loop with no winner → `{ kind: 'unauthenticated' }`.
+ */
+export async function runColdBoot(options) {
+    const { steps, onStepError } = options;
+    for (const step of steps) {
+        if (step.enabled) {
+            let isEnabled;
+            try {
+                isEnabled = step.enabled();
+            }
+            catch (error) {
+                onStepError?.(step.id, error);
+                continue;
+            }
+            if (!isEnabled)
+                continue;
+        }
+        let result;
+        try {
+            result = await step.run();
+        }
+        catch (error) {
+            onStepError?.(step.id, error);
+            continue;
+        }
+        if (result.kind === 'session') {
+            return { kind: 'session', via: step.id, session: result.session };
+        }
+    }
+    return { kind: 'unauthenticated' };
+}

package/dist/esm/utils/fapiAutoDetect.js

@@ -0,0 +1,85 @@
+/**
+ * Auto-detect the FAPI (IdP) URL from the current browser hostname.
+ *
+ * This is the canonical cross-domain IdP-resolution primitive for the Oxy
+ * ecosystem. Both candidate cross-domain SSO designs derive `auth.<rp-apex>`
+ * through this helper; do not fork it.
+ *
+ * Clerk-style multi-domain SSO depends on the IdP being reachable on a
+ * subdomain of the RP's own apex (e.g. `auth.mention.earth` CNAMEd to the
+ * central Oxy IdP). That way every FedCM endpoint, the session cookie,
+ * and any popup/redirect target are same-site with the RP — the only way
+ * to get first-party cookies in Safari ITP and Firefox Total Cookie
+ * Protection.
+ *
+ * This helper computes `https://auth.<rp-apex>` from
+ * `window.location.hostname` so a consuming app doesn't have to pass
+ * `authWebUrl` explicitly. Returns `undefined` for environments where
+ * auto-detection would be wrong:
+ *
+ *   - SSR / non-browser (no `window`).
+ *   - `localhost`, `127.0.0.1`, IPv4/IPv6 literals.
+ *   - Hostnames with fewer than two labels.
+ *   - Hostnames whose trailing two labels form a known multi-part public
+ *     suffix (e.g. `co.uk`), where the naive `labels.slice(-2)` apex would be
+ *     an attacker-registrable suffix like `auth.co.uk` rather than the real
+ *     registrable domain.
+ *
+ * When the page is already loaded ON the IdP itself (`auth.<anything>`),
+ * the helper returns the current origin so the SDK keeps everything
+ * same-origin instead of hopping to a different IdP host.
+ *
+ * The IdP backend independently derives `iss`, `provider_urls`, and the
+ * `fedcm.json` icon URLs from the request host
+ * (`packages/auth/server/index.ts`), so an honest CNAME pair is all that
+ * is required for end-to-end FedCM correctness — no per-RP config.
+ */
+/**
+ * Known multi-part public suffixes where the registrable domain is the LAST
+ * THREE labels, not two. Deriving an apex from `labels.slice(-2)` against any
+ * of these would yield an attacker-registrable suffix (e.g. `auth.co.uk`),
+ * so we bail out instead.
+ *
+ * This is intentionally a small, explicit allow-list rather than the full
+ * Public Suffix List — it covers the suffixes the Oxy ecosystem's RPs use.
+ * Any multi-part-TLD RP MUST extend this set (or wire in a proper PSL check)
+ * before relying on this helper, otherwise auto-detection silently bails to
+ * `undefined` and the consumer must pass `authWebUrl` explicitly.
+ */
+const MULTIPART_TLDS = new Set([
+    'co.uk',
+    'com.au',
+    'co.jp',
+    'co.nz',
+    'com.br',
+    'co.za',
+    'com.mx',
+    'co.in',
+    'co.kr',
+    'com.sg',
+]);
+export function autoDetectAuthWebUrl(location = typeof window !== 'undefined' ? window.location : undefined) {
+    if (!location)
+        return undefined;
+    const { hostname, protocol } = location;
+    if (!hostname)
+        return undefined;
+    if (protocol !== 'https:' && protocol !== 'http:')
+        return undefined;
+    if (hostname === 'localhost' || hostname === '127.0.0.1')
+        return undefined;
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname))
+        return undefined;
+    if (hostname.startsWith('['))
+        return undefined;
+    if (hostname.startsWith('auth.')) {
+        return `${protocol}//${hostname}`;
+    }
+    const labels = hostname.split('.');
+    if (labels.length < 2)
+        return undefined;
+    if (MULTIPART_TLDS.has(labels.slice(-2).join('.')))
+        return undefined;
+    const apex = labels.slice(-2).join('.');
+    return `${protocol}//auth.${apex}`;
+}