@oxyhq/core 4.0.1 → 5.0.0

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

@@ -5,7 +5,7 @@
  * and Express.js authentication middleware
  */
 import { jwtDecode } from 'jwt-decode';
-import { loadNodeCrypto } from '../utils/platformCrypto.js';
+import { loadNodeCrypto } from '@oxyhq/protocol';
 import { logger } from '../utils/loggerUtils.js';
 import { CACHE_TIMES } from './mixinHelpers.js';
 /**
@@ -47,8 +47,6 @@ export function OxyServicesUtilityMixin(Base) {
         // monorepo-wide refactor of the mixin pipeline.
         constructor(...args) {
             super(...args);
-            /** @internal In-memory cache for acting-as verification results (TTL: 5 min) */
-            this._actingAsCache = new Map();
             /**
              * In-memory cache for service-acting-as verification.
              * Negative results are cached for 1min to avoid hammering the verify
@@ -58,46 +56,6 @@ export function OxyServicesUtilityMixin(Base) {
              */
             this._serviceActingAsCache = new Map();
         }
-        /**
-         * Verify that a user is authorized to act as an account (direct membership
-         * or inherited via an ancestor). Backed by `GET /accounts/verify-acting-as`.
-         * Results are cached in-memory for 5 minutes to avoid repeated API calls.
-         *
-         * @internal Used by the auth() middleware — not part of the public API
-         */
-        async verifyActingAs(userId, accountId) {
-            const cacheKey = `${userId}:${accountId}`;
-            const now = Date.now();
-            // Check cache
-            const cached = this._actingAsCache.get(cacheKey);
-            if (cached && cached.expiresAt > now) {
-                return cached.result;
-            }
-            // Query the API
-            try {
-                const result = await this.makeRequest('GET', '/accounts/verify-acting-as', { accountId, userId }, { cache: false, retry: false, timeout: 5000 });
-                // Cache successful result for 5 minutes
-                this._actingAsCache.set(cacheKey, {
-                    result: result && result.authorized ? result : null,
-                    expiresAt: now + 5 * 60 * 1000,
-                });
-                return result && result.authorized ? result : null;
-            }
-            catch (error) {
-                logger.warn('[oxy.auth] verifyActingAs lookup failed — caching negative result', {
-                    component: 'auth',
-                    method: 'verifyActingAs',
-                    userId,
-                    accountId,
-                }, error);
-                // Cache negative result for 1 minute to avoid hammering on transient errors
-                this._actingAsCache.set(cacheKey, {
-                    result: null,
-                    expiresAt: now + 1 * 60 * 1000,
-                });
-                return null;
-            }
-        }
         /**
          * Verify that a service app holds an active delegation grant authorising
          * it to act on behalf of `userId`. Returns the grant (with allowed scopes)
@@ -218,47 +176,6 @@ export function OxyServicesUtilityMixin(Base) {
             const oxyInstance = this;
             // Return an async middleware function
             return async (req, res, next) => {
-                // Process X-Acting-As header for managed account identity delegation.
-                // Called after successful authentication, before next(). If the header
-                // is present, verifies authorization and swaps the request identity to
-                // the managed account, preserving the original user for audit trails.
-                const processActingAs = async () => {
-                    const actingAsUserId = req.headers['x-acting-as'];
-                    if (!actingAsUserId || typeof actingAsUserId !== 'string')
-                        return true; // No header, proceed normally
-                    const currentUserId = req.userId;
-                    if (!currentUserId)
-                        return true; // No authenticated user yet — nothing to swap
-                    const verification = await oxyInstance.verifyActingAs(currentUserId, actingAsUserId);
-                    if (!verification) {
-                        const error = {
-                            error: 'ACTING_AS_UNAUTHORIZED',
-                            message: 'Not authorized to act as this account',
-                            code: 'ACTING_AS_UNAUTHORIZED',
-                            status: 403,
-                        };
-                        if (onError) {
-                            onError(error);
-                        }
-                        else {
-                            res.status(403).json(error);
-                        }
-                        return false;
-                    }
-                    // Preserve original user for audit trails
-                    req.originalUser = { id: currentUserId, ...(req.user ?? {}) };
-                    req.actingAs = { userId: actingAsUserId, role: verification.role };
-                    // Swap user identity to the managed account
-                    req.userId = actingAsUserId;
-                    req.user = { id: actingAsUserId, _id: actingAsUserId };
-                    if (debug) {
-                        logger.debug(`[oxy.auth] Acting as ${actingAsUserId} (role=${verification.role}) original=${currentUserId}`, {
-                            component: 'auth',
-                            method: 'auth.processActingAs',
-                        });
-                    }
-                    return true;
-                };
                 try {
                     // Extract token from Authorization header.
                     // Node/Express normalizes `Authorization` to a string; we guard
@@ -340,9 +257,9 @@ export function OxyServicesUtilityMixin(Base) {
                         // Signature verification uses a manual HMAC-SHA256 compare because
                         // this file ships into RN/web bundles where `jsonwebtoken` is
                         // unavailable. The middleware only ever runs on Node hosts (see
-                        // platformCrypto's doc-comment), and `loadNodeCrypto` is per-
-                        // platform: the RN variant throws so Metro never bundles a Node
-                        // built-in reference.
+                        // `@oxyhq/protocol`'s `platform/crypto` doc-comment), and
+                        // `loadNodeCrypto` is per-platform: the RN variant throws so Metro
+                        // never bundles a Node built-in reference.
                         try {
                             await verifyServiceTokenSignature(token, jwtSecret);
                             verifyServiceTokenClaims(decoded, {
@@ -551,10 +468,7 @@ export function OxyServicesUtilityMixin(Base) {
                                     method: 'auth',
                                 });
                             }
-                            // Process X-Acting-As header before proceeding
-                            if (await processActingAs())
-                                return next();
-                            return;
+                            return next();
                         }
                         catch (validationError) {
                             if (debug) {
@@ -618,9 +532,7 @@ export function OxyServicesUtilityMixin(Base) {
                             method: 'auth',
                         });
                     }
-                    // Process X-Acting-As header before proceeding
-                    if (await processActingAs())
-                        next();
+                    next();
                 }
                 catch (error) {
                     const handled = oxyInstance.handleError(error);

package/dist/esm/utils/cacheKey.js

@@ -3,8 +3,8 @@
  *
  * Extracted from {@link HttpService} so the identity-tag derivation is a pure,
  * independently testable function with no dependency on instance/token state.
- * The HTTP service injects the live access token and acting-as id; everything
- * here is referentially transparent given those inputs.
+ * The HTTP service injects the live access token; everything here is
+ * referentially transparent given that input.
  */
 import { jwtDecode } from 'jwt-decode';
 /**
@@ -58,25 +58,23 @@ export function fnv1a32(str) {
  *
  * We use the decoded user id rather than the raw JWT so the token never lands
  * in a cache key (no token leakage through any cache-key logging, no key bloat).
- * The acting-as id is folded in because managed-account responses differ per
- * acting identity — and `X-Acting-As` already changes the server response for
- * the same bearer token.
+ * Switching into a managed account mints a REAL new session whose access token
+ * carries the target account's id, so the identity tag changes naturally on a
+ * switch — there is no separate acting-as discriminator to fold in.
  *
  * @param accessToken The current bearer access token, or `null` when anonymous.
- * @param actingAsUserId The active managed-account id, or `null`.
  */
-export function computeIdentityTag(accessToken, actingAsUserId) {
-    let principal = ANON_IDENTITY;
-    if (accessToken) {
-        try {
-            const decoded = jwtDecode(accessToken);
-            principal = decoded.userId || decoded.id || `t${fnv1a32(accessToken)}`;
-        }
-        catch {
-            // Undecodable token — still partition it away from anon and from other
-            // tokens via a hash. Never silently fall back to ANON_IDENTITY.
-            principal = `t${fnv1a32(accessToken)}`;
-        }
+export function computeIdentityTag(accessToken) {
+    if (!accessToken) {
+        return ANON_IDENTITY;
+    }
+    try {
+        const decoded = jwtDecode(accessToken);
+        return decoded.userId || decoded.id || `t${fnv1a32(accessToken)}`;
+    }
+    catch {
+        // Undecodable token — still partition it away from anon and from other
+        // tokens via a hash. Never silently fall back to ANON_IDENTITY.
+        return `t${fnv1a32(accessToken)}`;
     }
-    return actingAsUserId ? `${principal}~as${actingAsUserId}` : principal;
 }

package/dist/esm/utils/deviceManager.js

@@ -1,4 +1,4 @@
-import { loadAsyncStorage } from './platformCrypto.js';
+import { loadAsyncStorage } from '@oxyhq/protocol';
 /**
  * Client-side device management utility
  * Handles persistent device identification across app sessions

package/dist/esm/utils/platform.js

@@ -74,18 +74,6 @@ export function isIOS() {
 export function isAndroid() {
     return getPlatformOS() === 'android';
 }
-/**
- * Check if running in React Native
- */
-export function isReactNative() {
-    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-}
-/**
- * Check if running in Node.js
- */
-export function isNodeJS() {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-}
 /**
  * Set the platform OS explicitly
  * Called by React Native entry point to register the platform