@oxyhq/services 5.16.39 → 5.16.41

package/src/adapters/expo/storage.ts

@@ -0,0 +1,228 @@
+/**
+ * Expo 54 Storage Adapter
+ * 
+ * Handles storage for React Native (expo-secure-store + AsyncStorage) and Web (localStorage)
+ */
+
+import { Platform } from 'react-native';
+import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
+
+// Lazy imports
+let SecureStore: typeof import('expo-secure-store') | null = null;
+let AsyncStorage: AsyncStorageStatic | null = null;
+
+/**
+ * Initialize expo-secure-store (React Native only)
+ */
+async function initSecureStore(): Promise<typeof import('expo-secure-store')> {
+  if (!SecureStore) {
+    try {
+      SecureStore = await import('expo-secure-store');
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load expo-secure-store: ${errorMessage}`);
+    }
+  }
+  return SecureStore;
+}
+
+/**
+ * Initialize AsyncStorage (React Native only)
+ */
+async function initAsyncStorage(): Promise<AsyncStorageStatic> {
+  if (!AsyncStorage) {
+    try {
+      const module = await import('@react-native-async-storage/async-storage');
+      AsyncStorage = (module.default as unknown) as AsyncStorageStatic;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load AsyncStorage: ${errorMessage}`);
+    }
+  }
+  return AsyncStorage;
+}
+
+/**
+ * Check if we're on React Native (not Web)
+ */
+function isReactNative(): boolean {
+  try {
+    return Platform.OS !== 'web';
+  } catch {
+    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+  }
+}
+
+/**
+ * Check if we're on Web
+ */
+function isWeb(): boolean {
+  try {
+    return Platform.OS === 'web';
+  } catch {
+    return typeof window !== 'undefined' && typeof navigator !== 'undefined' && navigator.product !== 'ReactNative';
+  }
+}
+
+/**
+ * Storage Adapter Interface
+ */
+export interface StorageAdapter {
+  // Secure storage (para claves privadas) - SOLO NATIVE
+  secureGet(key: string): Promise<string | null>;
+  secureSet(key: string, value: string): Promise<void>;
+  secureDelete(key: string): Promise<void>;
+  isSecureStorageAvailable(): boolean;
+  
+  // Regular storage (para sesiones, etc.) - Native + Web
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+/**
+ * Create Expo Storage Adapter
+ */
+export async function createExpoStorageAdapter(): Promise<StorageAdapter> {
+  const isNative = isReactNative();
+  const isWebPlatform = isWeb();
+
+  if (isNative) {
+    // React Native: Use expo-secure-store + AsyncStorage
+    const secureStore = await initSecureStore();
+    const asyncStorage = await initAsyncStorage();
+
+    return {
+      // Secure storage (expo-secure-store)
+      async secureGet(key: string): Promise<string | null> {
+        try {
+          return await secureStore.getItemAsync(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to get secure item:', error);
+          return null;
+        }
+      },
+
+      async secureSet(key: string, value: string): Promise<void> {
+        try {
+          await secureStore.setItemAsync(key, value, {
+            keychainAccessible: secureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+          });
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to set secure item:', error);
+          throw error;
+        }
+      },
+
+      async secureDelete(key: string): Promise<void> {
+        try {
+          await secureStore.deleteItemAsync(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to delete secure item:', error);
+        }
+      },
+
+      isSecureStorageAvailable(): boolean {
+        return true;
+      },
+
+      // Regular storage (AsyncStorage)
+      async get(key: string): Promise<string | null> {
+        try {
+          return await asyncStorage.getItem(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to get item:', error);
+          return null;
+        }
+      },
+
+      async set(key: string, value: string): Promise<void> {
+        try {
+          await asyncStorage.setItem(key, value);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to set item:', error);
+          throw error;
+        }
+      },
+
+      async remove(key: string): Promise<void> {
+        try {
+          await asyncStorage.removeItem(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to remove item:', error);
+        }
+      },
+
+      async clear(): Promise<void> {
+        try {
+          await asyncStorage.clear();
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to clear storage:', error);
+        }
+      },
+    };
+  } else if (isWebPlatform) {
+    // Web: Use localStorage only (no secure storage)
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+      throw new Error('localStorage is not available in this environment');
+    }
+
+    return {
+      // Secure storage not available on Web
+      async secureGet(_key: string): Promise<string | null> {
+        return null;
+      },
+
+      async secureSet(_key: string, _value: string): Promise<void> {
+        // No-op on Web
+      },
+
+      async secureDelete(_key: string): Promise<void> {
+        // No-op on Web
+      },
+
+      isSecureStorageAvailable(): boolean {
+        return false;
+      },
+
+      // Regular storage (localStorage)
+      async get(key: string): Promise<string | null> {
+        try {
+          return window.localStorage.getItem(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to get item:', error);
+          return null;
+        }
+      },
+
+      async set(key: string, value: string): Promise<void> {
+        try {
+          window.localStorage.setItem(key, value);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to set item:', error);
+          throw error;
+        }
+      },
+
+      async remove(key: string): Promise<void> {
+        try {
+          window.localStorage.removeItem(key);
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to remove item:', error);
+        }
+      },
+
+      async clear(): Promise<void> {
+        try {
+          window.localStorage.clear();
+        } catch (error) {
+          console.warn('[ExpoStorage] Failed to clear storage:', error);
+        }
+      },
+    };
+  } else {
+    throw new Error('Unknown platform for Expo storage adapter');
+  }
+}
+

package/src/adapters/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Platform Adapters
+ * 
+ * Factory function to create the appropriate platform adapter
+ */
+
+import { createExpoAdapter, type PlatformAdapter as ExpoPlatformAdapter } from './expo';
+import { createNodeAdapter, type PlatformAdapter as NodePlatformAdapter } from './node';
+
+export type PlatformAdapter = ExpoPlatformAdapter | NodePlatformAdapter;
+
+/**
+ * Detect platform and create appropriate adapter
+ */
+export async function createPlatformAdapter(): Promise<PlatformAdapter> {
+  // Check if we're in Node.js
+  if (typeof process !== 'undefined' && process.versions != null && process.versions.node != null) {
+    // Check if we're in a React Native/Expo environment
+    try {
+      // Try to detect React Native
+      if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return await createExpoAdapter();
+      }
+      
+      // Check for Expo in Node (unlikely but possible)
+      const Platform = await import('react-native').then(m => m.Platform).catch(() => null);
+      if (Platform) {
+        return await createExpoAdapter();
+      }
+    } catch {
+      // Not React Native, use Node adapter
+    }
+    
+    return await createNodeAdapter();
+  }
+  
+  // Default to Expo adapter (React Native or Web)
+  return await createExpoAdapter();
+}
+

package/src/adapters/node/crypto.ts

@@ -0,0 +1,39 @@
+/**
+ * Node.js Crypto Adapter
+ * 
+ * Uses Node's built-in crypto module
+ */
+
+import * as crypto from 'crypto';
+
+/**
+ * Crypto Adapter Interface
+ */
+export interface CryptoAdapter {
+  getRandomBytes(length: number): Promise<Uint8Array>;
+  digestStringAsync(algorithm: 'SHA256' | 'SHA512', data: string): Promise<string>;
+}
+
+/**
+ * Create Node Crypto Adapter
+ */
+export async function createNodeCryptoAdapter(): Promise<CryptoAdapter> {
+  return {
+    /**
+     * Generate cryptographically secure random bytes
+     */
+    async getRandomBytes(length: number): Promise<Uint8Array> {
+      return new Uint8Array(crypto.randomBytes(length));
+    },
+
+    /**
+     * Hash a string using the specified algorithm
+     */
+    async digestStringAsync(algorithm: 'SHA256' | 'SHA512', data: string): Promise<string> {
+      const hash = crypto.createHash(algorithm.toLowerCase());
+      hash.update(data);
+      return hash.digest('hex');
+    },
+  };
+}
+

package/src/adapters/node/fetch.ts

@@ -0,0 +1,59 @@
+/**
+ * Node.js Fetch Adapter
+ * 
+ * Uses node-fetch or native fetch (Node 18+)
+ */
+
+// Lazy import
+let nodeFetch: { default: typeof fetch } | null = null;
+
+/**
+ * Initialize node-fetch
+ */
+async function initNodeFetch(): Promise<{ default: typeof fetch }> {
+  if (!nodeFetch) {
+    try {
+      // Try native fetch first (Node 18+)
+      if (typeof fetch !== 'undefined') {
+        // Use a wrapper to match the interface
+        nodeFetch = {
+          default: fetch,
+        };
+        return nodeFetch;
+      }
+      
+      // Fallback to node-fetch (dynamic import to avoid type errors if not installed)
+      // @ts-ignore - node-fetch may not be installed, handled at runtime
+      const nodeFetchModule = await import('node-fetch');
+      nodeFetch = {
+        default: (nodeFetchModule.default || nodeFetchModule) as unknown as typeof fetch,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load fetch: ${errorMessage}. Please use Node.js 18+ or install node-fetch`);
+    }
+  }
+  return nodeFetch;
+}
+
+/**
+ * Fetch Adapter Interface
+ */
+export interface FetchAdapter {
+  fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+
+/**
+ * Create Node Fetch Adapter
+ */
+export async function createNodeFetchAdapter(): Promise<FetchAdapter> {
+  const fetchModule = await initNodeFetch();
+  const fetchFn = (fetchModule as any).default || fetchModule;
+
+  return {
+    fetch(url: string, options?: RequestInit): Promise<Response> {
+      return fetchFn(url, options);
+    },
+  };
+}
+

package/src/adapters/node/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Node.js Platform Adapter
+ * 
+ * Provides storage, crypto, and fetch adapters for Node.js
+ */
+
+import { createNodeStorageAdapter, type StorageAdapter } from './storage';
+import { createNodeCryptoAdapter, type CryptoAdapter } from './crypto';
+import { createNodeFetchAdapter, type FetchAdapter } from './fetch';
+import type { Platform as PlatformType } from '../../core/identity-session/types';
+
+/**
+ * Platform Adapter Interface
+ */
+export interface PlatformAdapter {
+  storage: StorageAdapter;
+  crypto: CryptoAdapter;
+  fetch: FetchAdapter;
+  platform: PlatformType;
+}
+
+/**
+ * Create Node Platform Adapter
+ */
+export async function createNodeAdapter(): Promise<PlatformAdapter> {
+  const storage = await createNodeStorageAdapter();
+  const crypto = await createNodeCryptoAdapter();
+  const fetchAdapter = await createNodeFetchAdapter();
+
+  return {
+    storage,
+    crypto,
+    fetch: fetchAdapter,
+    platform: 'node',
+  };
+}
+

package/src/adapters/node/storage.ts

@@ -0,0 +1,170 @@
+/**
+ * Node.js Storage Adapter
+ * 
+ * Uses filesystem for storage
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * Storage Adapter Interface
+ */
+export interface StorageAdapter {
+  // Secure storage (for private keys)
+  secureGet(key: string): Promise<string | null>;
+  secureSet(key: string, value: string): Promise<void>;
+  secureDelete(key: string): Promise<void>;
+  isSecureStorageAvailable(): boolean;
+  
+  // Regular storage
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+/**
+ * Get storage directory
+ */
+function getStorageDir(): string {
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.oxy', 'storage');
+}
+
+/**
+ * Get secure storage directory
+ */
+function getSecureStorageDir(): string {
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.oxy', 'secure');
+}
+
+/**
+ * Ensure directory exists
+ */
+async function ensureDir(dirPath: string): Promise<void> {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    // Ignore if already exists
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Get file path for a key
+ */
+function getFilePath(key: string, secure: boolean = false): string {
+  const baseDir = secure ? getSecureStorageDir() : getStorageDir();
+  // Sanitize key to prevent directory traversal
+  const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(baseDir, `${sanitizedKey}.json`);
+}
+
+/**
+ * Create Node Storage Adapter
+ */
+export async function createNodeStorageAdapter(): Promise<StorageAdapter> {
+  // Ensure directories exist
+  await ensureDir(getStorageDir());
+  await ensureDir(getSecureStorageDir());
+
+  return {
+    // Secure storage
+    async secureGet(key: string): Promise<string | null> {
+      try {
+        const filePath = getFilePath(key, true);
+        const data = await fs.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(data);
+        return parsed.value || null;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+          return null;
+        }
+        console.warn('[NodeStorage] Failed to get secure item:', error);
+        return null;
+      }
+    },
+
+    async secureSet(key: string, value: string): Promise<void> {
+      try {
+        const filePath = getFilePath(key, true);
+        const data = JSON.stringify({ value, timestamp: Date.now() });
+        await fs.writeFile(filePath, data, { mode: 0o600 }); // Read/write for owner only
+      } catch (error) {
+        console.warn('[NodeStorage] Failed to set secure item:', error);
+        throw error;
+      }
+    },
+
+    async secureDelete(key: string): Promise<void> {
+      try {
+        const filePath = getFilePath(key, true);
+        await fs.unlink(filePath);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+          console.warn('[NodeStorage] Failed to delete secure item:', error);
+        }
+      }
+    },
+
+    isSecureStorageAvailable(): boolean {
+      return true;
+    },
+
+    // Regular storage
+    async get(key: string): Promise<string | null> {
+      try {
+        const filePath = getFilePath(key, false);
+        const data = await fs.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(data);
+        return parsed.value || null;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+          return null;
+        }
+        console.warn('[NodeStorage] Failed to get item:', error);
+        return null;
+      }
+    },
+
+    async set(key: string, value: string): Promise<void> {
+      try {
+        const filePath = getFilePath(key, false);
+        const data = JSON.stringify({ value, timestamp: Date.now() });
+        await fs.writeFile(filePath, data);
+      } catch (error) {
+        console.warn('[NodeStorage] Failed to set item:', error);
+        throw error;
+      }
+    },
+
+    async remove(key: string): Promise<void> {
+      try {
+        const filePath = getFilePath(key, false);
+        await fs.unlink(filePath);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+          console.warn('[NodeStorage] Failed to remove item:', error);
+        }
+      }
+    },
+
+    async clear(): Promise<void> {
+      try {
+        const storageDir = getStorageDir();
+        const files = await fs.readdir(storageDir);
+        await Promise.all(
+          files.map(file => fs.unlink(path.join(storageDir, file)))
+        );
+      } catch (error) {
+        console.warn('[NodeStorage] Failed to clear storage:', error);
+      }
+    },
+  };
+}
+