@oxyhq/core 3.9.1 → 3.10.1

package/dist/esm/i18n/locales/en-US.json

@@ -129,6 +129,15 @@
             "title": "Reputation = Trust & Growth",
             "body": "Oxy Trust is a reputation system that reacts to what you do. Helpful, respectful, constructive actions earn it. Harmful or low‑effort stuff chips it away. More reputation can unlock benefits; low reputation can limit features. It keeps things fair and rewards real contribution."
         },
+        "name": {
+            "title": "What's your name?",
+            "body": "Add your name so people know who you are.",
+            "firstLabel": "First name",
+            "firstPlaceholder": "Your first name",
+            "lastLabel": "Last name",
+            "lastPlaceholder": "Your last name",
+            "saveFailed": "Could not save your name"
+        },
         "avatar": {
             "title": "Make It Yours",
             "body": "Add an avatar so people recognize you. It will show anywhere you show up here. Skip if you want — you can add it later.",

package/dist/esm/i18n/locales/es-ES.json

@@ -849,6 +849,15 @@
             "title": "Reputación = Confianza y crecimiento",
             "body": "Oxy Trust es un sistema de reputación que reacciona a lo que haces. Las acciones útiles, respetuosas y constructivas la aumentan. Las acciones dañinas o de poco esfuerzo la reducen. Más reputación puede desbloquear beneficios; poca reputación puede limitar funciones. Mantiene la justicia y recompensa la contribución real."
         },
+        "name": {
+            "title": "¿Cuál es tu nombre?",
+            "body": "Añade tu nombre para que la gente sepa quién eres.",
+            "firstLabel": "Nombre",
+            "firstPlaceholder": "Tu nombre",
+            "lastLabel": "Apellidos",
+            "lastPlaceholder": "Tus apellidos",
+            "saveFailed": "No se pudo guardar tu nombre"
+        },
         "avatar": {
             "title": "Hazlo tuyo",
             "body": "Añade un avatar para que te reconozcan. Se mostrará donde aparezcas aquí. Puedes omitirlo — puedes añadirlo más tarde.",

package/dist/esm/i18n/locales/locales/en-US.json

@@ -129,6 +129,15 @@
       "title": "Reputation = Trust & Growth",
       "body": "Oxy Trust is a reputation system that reacts to what you do. Helpful, respectful, constructive actions earn it. Harmful or low‑effort stuff chips it away. More reputation can unlock benefits; low reputation can limit features. It keeps things fair and rewards real contribution."
     },
+    "name": {
+      "title": "What's your name?",
+      "body": "Add your name so people know who you are.",
+      "firstLabel": "First name",
+      "firstPlaceholder": "Your first name",
+      "lastLabel": "Last name",
+      "lastPlaceholder": "Your last name",
+      "saveFailed": "Could not save your name"
+    },
     "avatar": {
       "title": "Make It Yours",
       "body": "Add an avatar so people recognize you. It will show anywhere you show up here. Skip if you want — you can add it later.",

package/dist/esm/i18n/locales/locales/es-ES.json

@@ -849,6 +849,15 @@
       "title": "Reputación = Confianza y crecimiento",
       "body": "Oxy Trust es un sistema de reputación que reacciona a lo que haces. Las acciones útiles, respetuosas y constructivas la aumentan. Las acciones dañinas o de poco esfuerzo la reducen. Más reputación puede desbloquear beneficios; poca reputación puede limitar funciones. Mantiene la justicia y recompensa la contribución real."
     },
+    "name": {
+      "title": "¿Cuál es tu nombre?",
+      "body": "Añade tu nombre para que la gente sepa quién eres.",
+      "firstLabel": "Nombre",
+      "firstPlaceholder": "Tu nombre",
+      "lastLabel": "Apellidos",
+      "lastPlaceholder": "Tus apellidos",
+      "saveFailed": "No se pudo guardar tu nombre"
+    },
     "avatar": {
       "title": "Hazlo tuyo",
       "body": "Añade un avatar para que te reconozcan. Se mostrará donde aparezcas aquí. Puedes omitirlo — puedes añadirlo más tarde.",

package/dist/esm/index.js

@@ -104,7 +104,7 @@ export { buildAccountsArray, createQuickAccount, getAccountDisplayName, getAccou
 // ---------------------------------------------------------------------------
 // Cross-domain SSO infrastructure
 // ---------------------------------------------------------------------------
-export { autoDetectAuthWebUrl, registrableApex, MULTIPART_TLDS } from './utils/fapiAutoDetect.js';
+export { autoDetectAuthWebUrl, registrableApex } from './utils/fapiAutoDetect.js';
 // Central cross-domain SSO (opaque single-use code bounce via auth.oxy.so)
 export { CENTRAL_AUTH_URL, CENTRAL_IDP_APEX, resolveCentralAuthUrl } from './utils/authWebUrl.js';
 export { parseSsoReturnFragment, consumeSsoReturn } from './utils/ssoReturn.js';

package/dist/esm/mixins/OxyServices.assets.js

@@ -1,3 +1,4 @@
+import { isReactNative } from '../utils/platform.js';
 export function OxyServicesAssetsMixin(Base) {
     return class extends Base {
         constructor(...args) {
@@ -40,8 +41,8 @@ export function OxyServicesAssetsMixin(Base) {
          *
          * For a CDN-signed URL fetched from the API, use {@link getFileDownloadUrlAsync}.
          */
-        getFileDownloadUrl(fileId, variant, expiresIn) {
-            const token = this.getClient().getAccessToken();
+        getFileDownloadUrl(fileId, variant, expiresIn, options = {}) {
+            const token = options.omitToken ? undefined : this.getClient().getAccessToken();
             // Public case: no auth token and no expiry requested → clean CDN URL.
             // CloudFront serves the public media origin under `${cloudURL}/<id>`.
             if (!token && !expiresIn) {
@@ -189,10 +190,32 @@ export function OxyServicesAssetsMixin(Base) {
                     formData.append('file', file, fileName);
                 }
                 else if ('uri' in file && typeof file.uri === 'string') {
-                    // React Native file descriptor — RN's FormData handles {uri, type, name} natively.
-                    // It reads the file from disk during the multipart request — no in-JS Blob
-                    // conversion (which would fail on Hermes for ArrayBuffer-backed Blobs).
-                    formData.append('file', file, fileName);
+                    const descriptor = file;
+                    if (isReactNative()) {
+                        // React Native file descriptor — RN's FormData handles {uri, type, name} natively.
+                        // It reads the file from disk during the multipart request — no in-JS Blob
+                        // conversion (which would fail on Hermes for ArrayBuffer-backed Blobs).
+                        formData.append('file', descriptor, fileName);
+                    }
+                    else {
+                        // Web (browser/Node): the browser's FormData cannot read bytes from a plain
+                        // { uri } object — it would serialize "[object Object]" and the server would
+                        // store a 0-byte asset. Materialize the uri into a real Blob first. `fetch`
+                        // resolves blob:, data:, and http(s): uris on web, so all picker outputs work.
+                        const res = await fetch(descriptor.uri);
+                        if (!res.ok) {
+                            throw new Error(`Failed to read file from uri (status ${res.status})`);
+                        }
+                        const fetched = await res.blob();
+                        // Preserve the descriptor's declared MIME type when the fetched blob has none.
+                        const blob = fetched.type === '' && descriptor.type
+                            ? new Blob([fetched], { type: descriptor.type })
+                            : fetched;
+                        if (blob.size === 0) {
+                            throw new Error('Cannot upload an empty file');
+                        }
+                        formData.append('file', blob, fileName);
+                    }
                 }
                 else {
                     throw new Error('Unsupported file input: expected File, Blob, or { uri, type?, name?, size? } descriptor');

package/dist/esm/mixins/OxyServices.utility.js

@@ -688,33 +688,45 @@ export function OxyServicesUtilityMixin(Base) {
                         }
                         return next(new Error('Invalid token'));
                     }
-                    const userId = decoded.userId || decoded.id;
-                    if (!userId) {
+                    const claimedUserId = decoded.userId || decoded.id;
+                    if (!claimedUserId) {
                         return next(new Error('Invalid token payload'));
                     }
                     // Check expiration — reject tokens at exact expiry second (use <=)
                     if (decoded.exp && decoded.exp <= Math.floor(Date.now() / 1000)) {
                         return next(new Error('Token expired'));
                     }
-                    // Validate session if available
-                    if (decoded.sessionId) {
-                        try {
-                            const result = await oxyInstance.validateSession(decoded.sessionId, {
-                                useHeaderValidation: true,
-                            });
-                            if (!result || !result.valid) {
-                                return next(new Error('Session invalid'));
-                            }
+                    // A server-validated session is mandatory. A bare decoded JWT proves
+                    // nothing — the signature is not verified here, so without a session
+                    // round-trip a forged token could claim any user id.
+                    if (!decoded.sessionId) {
+                        return next(new Error('Session required'));
+                    }
+                    let userId = claimedUserId;
+                    try {
+                        const result = await oxyInstance.validateSession(decoded.sessionId, {
+                            useHeaderValidation: true,
+                        });
+                        if (!result || !result.valid || !result.user) {
+                            return next(new Error('Session invalid'));
                         }
-                        catch (validateErr) {
-                            if (debug) {
-                                logger.debug('[oxy.authSocket] Session validation failed', {
-                                    component: 'auth',
-                                    method: 'authSocket',
-                                }, validateErr);
-                            }
-                            return next(new Error('Session validation failed'));
+                        // The session is the source of truth. The client-claimed user id
+                        // must match the server-validated identity, otherwise a valid
+                        // session could be paired with a forged user id.
+                        const validatedUserId = getUserIdentityId(result.user);
+                        if (!validatedUserId || validatedUserId !== claimedUserId) {
+                            return next(new Error('Session user mismatch'));
                         }
+                        userId = validatedUserId;
+                    }
+                    catch (validateErr) {
+                        if (debug) {
+                            logger.debug('[oxy.authSocket] Session validation failed', {
+                                component: 'auth',
+                                method: 'authSocket',
+                            }, validateErr);
+                        }
+                        return next(new Error('Session validation failed'));
                     }
                     // Attach user data to socket. We expose BOTH `socket.data.userId`
                     // (the official Socket.IO data slot) and `socket.user` because
@@ -779,9 +791,9 @@ export function OxyServicesUtilityMixin(Base) {
          * Express.js middleware that enforces a specific service-token scope.
          *
          * Mount AFTER `auth()` / `serviceAuth()` — relies on `req.serviceApp` and
-         * (when delegation is in effect) `req.serviceActingAs.scopes`. The scope
-         * is granted if EITHER list contains it, mirroring the OAuth2 model where
-         * the app's app-level scopes and the per-user delegated scopes both count.
+         * (when delegation is in effect) `req.serviceActingAs.scopes`. App-only
+         * service requests require the app scope. Delegated user requests require
+         * BOTH the app scope and the per-user delegation scope.
          *
          * Requests authenticated as a regular user (no service token) are rejected
          * with 403 — scope-protected endpoints are service-to-service by design.
@@ -811,7 +823,12 @@ export function OxyServicesUtilityMixin(Base) {
                     });
                     return;
                 }
-                if (appScopes.includes(scope) || delegatedScopes.includes(scope)) {
+                const appHasScope = appScopes.includes(scope);
+                const delegationHasScope = delegatedScopes.includes(scope);
+                const hasRequiredScope = req.serviceActingAs
+                    ? appHasScope && delegationHasScope
+                    : appHasScope;
+                if (hasRequiredScope) {
                     next();
                     return;
                 }
@@ -869,6 +886,18 @@ async function verifyServiceTokenSignature(token, secret) {
  * access token signed by the same shared secret could be replayed as a
  * service token because no claim binding existed.
  */
+/**
+ * Resolve the canonical user id from a validated session's user object.
+ *
+ * The API serializer emits `id`, but some upstream shapes carry the raw Mongo
+ * `_id` instead. We accept either, but only a non-empty string — anything else
+ * means the validated identity is unusable and the caller must reject.
+ */
+function getUserIdentityId(user) {
+    const candidate = user.id
+        ?? user._id;
+    return typeof candidate === 'string' && candidate.length > 0 ? candidate : null;
+}
 function verifyServiceTokenClaims(decoded, expected) {
     if (decoded.type !== 'service') {
         throw new ServiceTokenClaimError(`Service token has unexpected type '${String(decoded.type)}'`);

package/dist/esm/server/cors.js

@@ -0,0 +1,152 @@
+/**
+ * Strict CORS allowlist for Oxy backends.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * App backends kept hand-rolling CORS, and the unsafe patterns recurred:
+ *   - `Access-Control-Allow-Origin: *` together with credentials (which is
+ *     spec-invalid AND a credential-leak vector), or
+ *   - a "reflect whatever Origin the request carried" fallback (effectively
+ *     `*` for credentialed requests — the Allo wildcard-fallback class).
+ *
+ * `createOxyCors` returns a self-contained Express middleware (no `cors`
+ * package dependency) that:
+ *   - allows the Oxy apex origin family (anything under `*.${CENTRAL_IDP_APEX}`,
+ *     i.e. `oxy.so` — covering `auth.oxy.so`, `api.oxy.so`, `accounts.oxy.so`,
+ *     `console.oxy.so`, `inbox.oxy.so`, the marketing site, …) reusing the
+ *     central-origin constants already in core, NOT a fresh hardcoded list,
+ *   - allows the caller's explicit `appOrigins`,
+ *   - DENIES everything else (no reflection, never a wildcard with credentials),
+ *   - echoes back the EXACT matched origin (so credentialed requests work) and
+ *     sets `Vary: Origin` for correct caching,
+ *   - answers CORS preflight (`OPTIONS`) with `204`.
+ *
+ * Node/Express-only: exported solely from `@oxyhq/core/server`.
+ */
+import { CENTRAL_IDP_APEX } from '../utils/authWebUrl.js';
+import { registrableApex } from '../utils/fapiAutoDetect.js';
+/** Default HTTP methods allowed across origins. */
+const DEFAULT_ALLOWED_METHODS = ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE', 'OPTIONS'];
+/** Default request headers a browser may send on a credentialed cross-origin call. */
+const DEFAULT_ALLOWED_HEADERS = [
+    'Content-Type',
+    'Authorization',
+    'X-Requested-With',
+    'X-Oxy-User-Id',
+    'X-Oxy-Internal',
+    'X-CSRF-Token',
+];
+/** How long (seconds) a browser may cache a successful preflight. */
+const DEFAULT_MAX_AGE_SECONDS = 86400;
+/**
+ * Whether `candidate` belongs to the Oxy apex origin family — i.e. its
+ * registrable apex equals {@link CENTRAL_IDP_APEX} (`oxy.so`). This matches the
+ * apex itself (`https://oxy.so`) and any subdomain (`https://auth.oxy.so`,
+ * `https://api.oxy.so`, …) over http or https, ports allowed. Returns false on
+ * any parse failure (fail closed).
+ */
+function isOxyFamilyOrigin(candidate) {
+    let hostname;
+    let protocol;
+    try {
+        const url = new URL(candidate);
+        hostname = url.hostname.toLowerCase();
+        protocol = url.protocol;
+    }
+    catch {
+        return false;
+    }
+    if (protocol !== 'https:' && protocol !== 'http:')
+        return false;
+    if (hostname === CENTRAL_IDP_APEX)
+        return true;
+    return registrableApex(hostname) === CENTRAL_IDP_APEX;
+}
+/** Normalize a raw origin string to its canonical `scheme://host[:port]` form. */
+function normalizeOrigin(raw) {
+    try {
+        return new URL(raw).origin;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build the origin-matching predicate: true iff `origin` is in the Oxy apex
+ * family OR exactly matches one of the configured app origins.
+ */
+function buildOriginAllowed(appOrigins) {
+    const explicit = new Set();
+    for (const raw of appOrigins) {
+        const normalized = normalizeOrigin(raw);
+        if (normalized)
+            explicit.add(normalized);
+    }
+    return (origin) => {
+        const normalized = normalizeOrigin(origin);
+        if (normalized === null)
+            return false;
+        if (explicit.has(normalized))
+            return true;
+        return isOxyFamilyOrigin(normalized);
+    };
+}
+/**
+ * Create a strict Oxy CORS middleware. See module docs.
+ *
+ * @example
+ * ```ts
+ * app.use(createOxyCors({ appOrigins: ['https://app.example.com'] }));
+ * ```
+ */
+export function createOxyCors(options = {}) {
+    const { appOrigins = [], allowCredentials = true, methods = DEFAULT_ALLOWED_METHODS, allowedHeaders = DEFAULT_ALLOWED_HEADERS, exposedHeaders = [], maxAgeSeconds = DEFAULT_MAX_AGE_SECONDS, } = options;
+    const isOriginAllowed = buildOriginAllowed(appOrigins);
+    const methodsHeader = methods.join(', ');
+    const allowedHeadersHeader = allowedHeaders.join(', ');
+    const exposedHeadersHeader = exposedHeaders.join(', ');
+    return (req, res, next) => {
+        const origin = req.headers.origin;
+        // Same-origin or non-browser requests carry no Origin header — pass through
+        // untouched (no ACAO header is emitted, which is correct for them).
+        if (typeof origin !== 'string' || origin.length === 0) {
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(204);
+                return;
+            }
+            next();
+            return;
+        }
+        // Origin is present. Caching correctness: this response varies by Origin.
+        res.setHeader('Vary', 'Origin');
+        if (!isOriginAllowed(origin)) {
+            // DENY: do NOT reflect the origin, do NOT emit a wildcard. The browser
+            // will block the cross-origin read. Preflights for denied origins get a
+            // 204 with no CORS headers (the actual request then fails CORS).
+            if (req.method === 'OPTIONS') {
+                res.sendStatus(204);
+                return;
+            }
+            next();
+            return;
+        }
+        // ALLOW: echo the EXACT matched origin — never `*`, even without credentials.
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        if (allowCredentials) {
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        }
+        if (exposedHeadersHeader) {
+            res.setHeader('Access-Control-Expose-Headers', exposedHeadersHeader);
+        }
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Methods', methodsHeader);
+            // Honour the browser's requested headers when present, else the default set.
+            const requested = req.headers['access-control-request-headers'];
+            res.setHeader('Access-Control-Allow-Headers', typeof requested === 'string' && requested.length > 0 ? requested : allowedHeadersHeader);
+            res.setHeader('Access-Control-Max-Age', String(maxAgeSeconds));
+            res.sendStatus(204);
+            return;
+        }
+        next();
+    };
+}

package/dist/esm/server/index.js

@@ -16,3 +16,9 @@
  */
 export { createOptionalOxyAuth, createOxyAuthMiddleware, getOxyUserId, getRequiredOxyUserId, isOxyAuthenticated, requireOxyAuth, } from './auth.js';
 export { createOxyRateLimit } from './rateLimit.js';
+// SSRF-safe upstream fetch + URL validation (Node-only).
+export { assertSafePublicUrl, isBlockedIp, safeFetch, SsrfRejection, UpstreamError, ALLOWED_PORTS, ALLOWED_PROTOCOLS, BLOCKED_HOSTNAMES, DEFAULT_USER_AGENT, MAX_REDIRECTS, MAX_URL_LENGTH, UPSTREAM_HEADERS_TIMEOUT_MS, } from './safeFetch.js';
+// Strict CORS allowlist (Oxy apex family + explicit app origins).
+export { createOxyCors } from './cors.js';
+// Constant-time secret comparison.
+export { verifySecret } from './verifySecret.js';