@oxyhq/core 12.4.1 → 12.5.1

package/dist/esm/crypto/polyfill.js

@@ -4,14 +4,26 @@
  * Ensures Buffer and crypto.getRandomValues are available
  * across all platforms (Node.js, Browser, React Native).
  *
- * - Browser/Node.js: Uses native crypto
- * - React Native: Uses expo-crypto (statically imported via the
- *   per-platform `platform/crypto` module in `@oxyhq/protocol` — see that
- *   file's doc-comment for how platform routing works).
+ * Guard order when installing a `getRandomValues` shim (see bottom of file and
+ * {@link cryptoPolyfill}):
+ *
+ *   1. A REAL `globalThis.crypto.getRandomValues` — used as-is (browser, Node
+ *      >= 20, modern Hermes). The shim below is only installed when the host is
+ *      missing it, so this branch is the install-time gate.
+ *   2. Node — backed by the built-in `node:crypto` module (`webcrypto`, else
+ *      `randomFillSync`). This is what a Node runtime WITHOUT a global WebCrypto
+ *      (Node 18 script entrypoints, some embedded hosts) falls back to.
+ *   3. React Native — `expo-crypto.getRandomBytes` (statically imported via the
+ *      per-platform `platform/crypto` module in `@oxyhq/protocol`).
+ *
+ * Historically step (2) delegated to `@oxyhq/protocol`'s RN-only
+ * `getRandomBytesRN`, which THROWS on Node — so any Node host lacking a global
+ * WebCrypto crashed here instead of getting randomness. It is now a proper
+ * Node-backed implementation.
  */
 import _cjs_buffer from 'buffer';
 const { Buffer } = _cjs_buffer;
-import { getRandomBytesRN } from '@oxyhq/protocol';
+import { getRandomBytesRN, isNodeJS } from '@oxyhq/protocol';
 const getGlobalObject = () => {
     if (typeof globalThis !== 'undefined')
         return globalThis;
@@ -29,23 +41,79 @@ if (!globalObject.Buffer) {
     globalObject.Buffer = Buffer;
 }
 /**
- * Synchronous random-bytes shim. On RN, this delegates to
- * `expo-crypto.getRandomBytes` (statically imported by the RN variant of
- * `@oxyhq/protocol`'s `platform/crypto`, so available without any async
- * warm-up). On Node /
- * browser, this throws — but is never called there because both platforms
- * already provide `globalThis.crypto.getRandomValues` natively.
+ * Lazily-resolved `node:crypto` module, cached after the first attempt.
+ * `undefined` = not tried yet; `null` = tried and unavailable (non-Node host).
+ */
+let cachedNodeCrypto;
+/**
+ * Synchronously load `node:crypto` on a Node runtime, or `null` elsewhere.
+ *
+ * Uses a guarded, Node-only `require`. Every runtime that actually reaches this
+ * branch has a working CommonJS `require`: `@oxyhq/core` publishes no
+ * `"type": "module"`, so Node loads it as CommonJS and the `require` free
+ * variable is present. Browsers never reach here (they own `globalThis.crypto`,
+ * so this polyfill is never installed) and React Native takes the
+ * `getRandomBytesRN` branch — so the `node:crypto` reference is dead code in
+ * those bundles, and Expo's Metro resolver shims `node:*` builtins, keeping
+ * web/native bundles green.
+ */
+function loadNodeCryptoSync() {
+    if (cachedNodeCrypto !== undefined) {
+        return cachedNodeCrypto;
+    }
+    if (typeof require !== 'function') {
+        cachedNodeCrypto = null;
+        return cachedNodeCrypto;
+    }
+    try {
+        cachedNodeCrypto = require('node:crypto');
+    }
+    catch {
+        // No Node crypto (unexpected on a real Node host) — degrade to the next
+        // mechanism rather than crash.
+        cachedNodeCrypto = null;
+    }
+    return cachedNodeCrypto;
+}
+/**
+ * Fill `array` with cryptographically-secure random bytes from `node:crypto`.
+ * Prefers `webcrypto.getRandomValues`; falls back to `randomFillSync`. Returns
+ * `false` when Node crypto is unavailable so the caller can try the next
+ * mechanism.
  */
-function getRandomBytesSync(byteCount) {
-    // `getRandomBytesRN` throws on non-RN platforms. That's fine: this
-    // function is only ever called as a fallback when the native
-    // `globalThis.crypto.getRandomValues` is missing, which on a normal
-    // Node/browser host never happens.
-    return getRandomBytesRN(byteCount);
+function fillFromNodeCrypto(array) {
+    const nodeCrypto = loadNodeCryptoSync();
+    if (!nodeCrypto) {
+        return false;
+    }
+    const webcrypto = nodeCrypto.webcrypto;
+    if (webcrypto && typeof webcrypto.getRandomValues === 'function') {
+        try {
+            webcrypto.getRandomValues(array);
+            return true;
+        }
+        catch {
+            // `webcrypto.getRandomValues` rejects non-integer views (Float*Array,
+            // DataView); fall through to `randomFillSync`, which accepts any view.
+        }
+    }
+    if (typeof nodeCrypto.randomFillSync === 'function') {
+        nodeCrypto.randomFillSync(array);
+        return true;
+    }
+    return false;
 }
 const cryptoPolyfill = {
     getRandomValues(array) {
-        const bytes = getRandomBytesSync(array.byteLength);
+        // Node: back the CSPRNG with `node:crypto`. This is the path that matters on
+        // Node runtimes shipping WITHOUT a global WebCrypto — where delegating to
+        // the RN-only expo-crypto stub would throw.
+        if (isNodeJS() && fillFromNodeCrypto(array)) {
+            return array;
+        }
+        // React Native (and any non-Node host without WebCrypto): synchronous
+        // expo-crypto via @oxyhq/protocol's RN `platform/crypto` variant.
+        const bytes = getRandomBytesRN(array.byteLength);
         const uint8View = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
         uint8View.set(bytes);
         return array;

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

@@ -437,6 +437,17 @@ export function OxyServicesUserMixin(Base) {
         async updateUserPreferences(preferences) {
             return this.updateProfile({ userPreferences: preferences });
         }
+        /**
+         * Update the authenticated user's portable theme preference (light/dark/
+         * system + Bloom color-preset key). Persisted on the User document via the
+         * SAME `PUT /users/me` settings path as the other preferences — same cache
+         * invalidation — so the next cold boot serves it on the self/session payload
+         * with no extra network call. The full object is written (both `mode` and
+         * `colorPreset` are required by the API).
+         */
+        async updateThemePreference(themePreference) {
+            return this.updateProfile({ themePreference });
+        }
         /**
          * Request account verification
          */

package/dist/esm/server/safeFetch.js

@@ -372,7 +372,7 @@ function buildRequestOptions(target, pinnedIp, pinnedFamily, method, headers, si
     };
 }
 /** Perform a single upstream request (no auto-redirect). */
-function fetchOnce(options, isHttps, headersTimeoutMs) {
+function fetchOnce(options, isHttps, headersTimeoutMs, body) {
     return new Promise((resolve, reject) => {
         const transport = isHttps ? https : http;
         const req = transport.request(options, (res) => resolve(res));
@@ -380,7 +380,7 @@ function fetchOnce(options, isHttps, headersTimeoutMs) {
             req.destroy(new UpstreamError('upstream headers timeout'));
         });
         req.on('error', (err) => reject(err));
-        req.end();
+        req.end(body);
     });
 }
 /**
@@ -395,7 +395,7 @@ function fetchOnce(options, isHttps, headersTimeoutMs) {
  * @throws {UpstreamError} on redirect-loop / malformed-redirect / timeout.
  */
 export async function safeFetch(rawUrl, options = {}) {
-    const { method = 'GET', headers: callerHeaders, maxRedirects = MAX_REDIRECTS, headersTimeoutMs = UPSTREAM_HEADERS_TIMEOUT_MS, signal, } = options;
+    const { method = 'GET', headers: callerHeaders, body, maxRedirects = MAX_REDIRECTS, headersTimeoutMs = UPSTREAM_HEADERS_TIMEOUT_MS, signal, } = options;
     // Normalize a case-insensitive header map and ensure a User-Agent default.
     const baseHeaders = {};
     if (callerHeaders) {
@@ -418,7 +418,7 @@ export async function safeFetch(rawUrl, options = {}) {
         }
         const target = new URL(currentUrl);
         const requestOptions = buildRequestOptions(target, guard.ip, guard.family, method, baseHeaders, signal);
-        const response = await fetchOnce(requestOptions, target.protocol === 'https:', headersTimeoutMs);
+        const response = await fetchOnce(requestOptions, target.protocol === 'https:', headersTimeoutMs, body);
         const status = response.statusCode ?? 0;
         if (REDIRECT_STATUS_CODES.has(status)) {
             const location = response.headers.location;