@oxyhq/core 1.11.11 → 1.11.12

package/dist/cjs/HttpService.js

@@ -19,7 +19,6 @@ const cache_1 = require("./utils/cache");
 const requestUtils_1 = require("./utils/requestUtils");
 const asyncUtils_1 = require("./utils/asyncUtils");
 const errorUtils_1 = require("./utils/errorUtils");
-const debugUtils_1 = require("./shared/utils/debugUtils");
 const jwt_decode_1 = require("jwt-decode");
 const platform_1 = require("./utils/platform");
 /**
@@ -190,9 +189,12 @@ class HttpService {
                 if (isNativeApp && isStateChangingMethod) {
                     headers['X-Native-App'] = 'true';
                 }
-                // Debug logging for CSRF issues
-                if (isStateChangingMethod && (0, debugUtils_1.isDev)()) {
-                    console.log('[HttpService] CSRF Debug:', {
+                // Debug logging for CSRF issues — routed through the SimpleLogger so
+                // it only fires when consumers opt in via `enableLogging`. Previously
+                // this was a bare console.log that leaked noise into every host app's
+                // stdout in development.
+                if (isStateChangingMethod) {
+                    this.logger.debug('CSRF Debug:', {
                         url,
                         method,
                         isNativeApp,
@@ -412,23 +414,20 @@ class HttpService {
         // Return cached token if available
         const cachedToken = this.tokenStore.getCsrfToken();
         if (cachedToken) {
-            if ((0, debugUtils_1.isDev)())
-                console.log('[HttpService] Using cached CSRF token');
+            this.logger.debug('Using cached CSRF token');
             return cachedToken;
         }
         // Deduplicate concurrent CSRF token fetches
         const existingPromise = this.tokenStore.getCsrfTokenFetchPromise();
         if (existingPromise) {
-            if ((0, debugUtils_1.isDev)())
-                console.log('[HttpService] Waiting for existing CSRF fetch');
+            this.logger.debug('Waiting for existing CSRF fetch');
             return existingPromise;
         }
         const fetchPromise = (async () => {
             const maxAttempts = 2;
             for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                 try {
-                    if ((0, debugUtils_1.isDev)())
-                        console.log('[HttpService] Fetching CSRF token from:', `${this.baseURL}/csrf-token`, `(attempt ${attempt})`);
+                    this.logger.debug('Fetching CSRF token from:', `${this.baseURL}/csrf-token`, `(attempt ${attempt})`);
                     // Use AbortController for timeout (more compatible than AbortSignal.timeout)
                     const controller = new AbortController();
                     const timeoutId = setTimeout(() => controller.abort(), 5000);
@@ -439,12 +438,10 @@ class HttpService {
                         signal: controller.signal,
                     });
                     clearTimeout(timeoutId);
-                    if ((0, debugUtils_1.isDev)())
-                        console.log('[HttpService] CSRF fetch response:', response.status, response.ok);
+                    this.logger.debug('CSRF fetch response:', response.status, response.ok);
                     if (response.ok) {
                         const data = await response.json();
-                        if ((0, debugUtils_1.isDev)())
-                            console.log('[HttpService] CSRF response data:', data);
+                        this.logger.debug('CSRF response data:', data);
                         const token = data.csrfToken || null;
                         this.tokenStore.setCsrfToken(token);
                         this.logger.debug('CSRF token fetched');
@@ -457,13 +454,11 @@ class HttpService {
                         this.logger.debug('CSRF token from header');
                         return headerToken;
                     }
-                    if ((0, debugUtils_1.isDev)())
-                        console.log('[HttpService] CSRF fetch failed with status:', response.status);
+                    this.logger.debug('CSRF fetch failed with status:', response.status);
                     this.logger.warn('Failed to fetch CSRF token:', response.status);
                 }
                 catch (error) {
-                    if ((0, debugUtils_1.isDev)())
-                        console.log('[HttpService] CSRF fetch error:', error);
+                    this.logger.debug('CSRF fetch error:', error);
                     this.logger.warn('CSRF token fetch error:', error);
                 }
                 // Wait before retry (500ms)

package/dist/cjs/crypto/signatureService.js

@@ -43,20 +43,24 @@ exports.SignatureService = void 0;
 const elliptic_1 = require("elliptic");
 const keyManager_1 = require("./keyManager");
 const platform_1 = require("../utils/platform");
-// Lazy import for expo-crypto
+// Lazy imports for platform-specific crypto
 let ExpoCrypto = null;
+let NodeCrypto = null;
 const ec = new elliptic_1.ec('secp256k1');
-/**
- * Initialize expo-crypto module
- */
 async function initExpoCrypto() {
     if (!ExpoCrypto) {
-        // Variable indirection prevents bundlers (Vite, webpack) from statically resolving this
         const moduleName = 'expo-crypto';
         ExpoCrypto = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
     }
     return ExpoCrypto;
 }
+async function initNodeCrypto() {
+    if (!NodeCrypto) {
+        const moduleName = 'crypto';
+        NodeCrypto = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+    }
+    return NodeCrypto;
+}
 /**
  * Compute SHA-256 hash of a string
  */
@@ -66,10 +70,9 @@ async function sha256(message) {
         const Crypto = await initExpoCrypto();
         return Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, message);
     }
-    // In Node.js, use Node's crypto module
     if ((0, platform_1.isNodeJS)()) {
         try {
-            const nodeCrypto = await Promise.resolve().then(() => __importStar(require('crypto')));
+            const nodeCrypto = await initNodeCrypto();
             return nodeCrypto.createHash('sha256').update(message).digest('hex');
         }
         catch {
@@ -97,12 +100,9 @@ class SignatureService {
                 .map((b) => b.toString(16).padStart(2, '0'))
                 .join('');
         }
-        // In Node.js, use Node's crypto module
-        // Variable indirection prevents bundlers (Vite, webpack) from statically resolving this
         if ((0, platform_1.isNodeJS)()) {
             try {
-                const cryptoModuleName = 'crypto';
-                const nodeCrypto = await Promise.resolve(`${cryptoModuleName}`).then(s => __importStar(require(s)));
+                const nodeCrypto = await initNodeCrypto();
                 return nodeCrypto.randomBytes(32).toString('hex');
             }
             catch {

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

@@ -21,6 +21,17 @@ function OxyServicesUserMixin(Base) {
                 throw this.handleError(error);
             }
         }
+        /**
+         * Lightweight username lookup for login flows.
+         * Returns minimal public info: exists, color, avatar, displayName.
+         * Faster than getProfileByUsername — no stats, no formatting.
+         */
+        async lookupUsername(username) {
+            return await this.makeRequest('GET', `/auth/lookup/${encodeURIComponent(username)}`, undefined, {
+                cache: true,
+                cacheTTL: 60 * 1000, // 1 minute cache
+            });
+        }
         /**
          * Search user profiles
          */

package/dist/cjs/utils/asyncUtils.js

@@ -44,18 +44,47 @@ async function parallelWithErrorHandling(operations, errorHandler) {
     const results = await Promise.allSettled(operations.map((op, index) => withErrorHandling(op, error => errorHandler?.(error, index))));
     return results.map(result => result.status === 'fulfilled' ? result.value : null);
 }
+/**
+ * Extract an HTTP status code from an error value, tolerating both the
+ * axios-style nested shape (`error.response.status`) and the flat shape
+ * produced by {@link handleHttpError} / fetch-based clients (`error.status`).
+ *
+ * Centralising this lookup prevents retry predicates from silently falling
+ * through when one of the two shapes is missing, which previously caused
+ * @oxyhq/core to retry 4xx responses and turn sub-10ms failures into
+ * multi-second stalls for every missing-resource lookup.
+ */
+function extractHttpStatus(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const candidate = error;
+    const flat = candidate.status;
+    if (typeof flat === 'number' && Number.isFinite(flat))
+        return flat;
+    const nested = candidate.response?.status;
+    if (typeof nested === 'number' && Number.isFinite(nested))
+        return nested;
+    return undefined;
+}
 /**
  * Retry an async operation with exponential backoff
  *
- * By default, does not retry on 4xx errors (client errors).
- * Use shouldRetry callback to customize retry behavior.
+ * By default, does not retry on 4xx errors (client errors). The default
+ * predicate accepts both the axios-style `error.response.status` and the
+ * flat `error.status` shape produced by {@link handleHttpError}, so callers
+ * never accidentally retry a deterministic client failure.
+ *
+ * Use the `shouldRetry` callback to customize retry behavior.
  */
 async function retryAsync(operation, maxRetries = 3, baseDelay = 1000, shouldRetry) {
     let lastError;
-    // Default shouldRetry: don't retry on 4xx errors
+    // Default shouldRetry: don't retry on 4xx errors (client errors).
+    // Checks BOTH `error.status` (flat shape from handleHttpError / fetch
+    // clients) AND `error.response.status` (axios-style shape) so neither
+    // representation can leak a client error into the retry loop.
     const defaultShouldRetry = (error) => {
-        // Don't retry on 4xx errors (client errors)
-        if (error?.response?.status >= 400 && error?.response?.status < 500) {
+        const status = extractHttpStatus(error);
+        if (status !== undefined && status >= 400 && status < 500) {
             return false;
         }
         return true;