@onairos/react-native 3.0.0 → 3.0.2

package/src/types/index.ts

@@ -132,4 +132,9 @@ export interface ApiResponse<T> {
   success: boolean;
   data?: T;
   error?: string;
+}
+
+export interface CredentialsResult {
+  isValid: boolean;
+  credentials?: any;
 } 

package/src/utils/secureStorage.ts

@@ -1,41 +1,137 @@
+import * as Keychain from 'react-native-keychain';
 import { Platform } from 'react-native';
 import { sha256 } from './crypto';
+import { STORAGE_KEYS } from '../constants';
 
+// Define OnairosCredentials interface locally to avoid circular dependencies
 export interface OnairosCredentials {
   username: string;
-  accessToken: string;
+  accessToken?: string;
   refreshToken?: string;
   userPin?: string;
   platforms?: {
-    instagram?: { token: string; username: string };
-    youtube?: { token: string; username: string };
-    pinterest?: { token: string; username: string };
-    reddit?: { token: string; username: string };
+    instagram?: { token: string; username: string; userId?: string };
+    youtube?: { token: string; username: string; userId?: string };
+    pinterest?: { token: string; username: string; userId?: string };
+    reddit?: { token: string; username: string; userId?: string };
   };
   createdAt: number;
 }
 
 export interface StorageOptions {
-  useBiometrics?: boolean;
-  biometricPrompt?: {
-    title: string;
-    subtitle?: string;
-  };
+  service?: string;
+  accessControl?: Keychain.ACCESS_CONTROL;
+  accessible?: Keychain.ACCESSIBLE;
 }
 
-// Temporary in-memory storage
-let mockStorage: { [key: string]: string } = {};
+// Create a mock storage for environments without Keychain access (like Expo Go)
+const mockStorage: Record<string, { username: string; password: string }> = {};
+
+// Check if running in Expo Go or environments without native module access
+const isKeychainAvailable = () => {
+  try {
+    return typeof Keychain.getGenericPassword === 'function';
+  } catch (e) {
+    return false;
+  }
+};
+
+// Wrapper for getGenericPassword that falls back to mock storage
+const safeGetGenericPassword = async (options: Keychain.Options) => {
+  try {
+    if (isKeychainAvailable()) {
+      return await Keychain.getGenericPassword(options);
+    } else {
+      // Fall back to mock storage in memory
+      const key = options?.service || 'default';
+      return mockStorage[key] || null;
+    }
+  } catch (error) {
+    console.warn('Keychain access failed, using mock storage', error);
+    // Fall back to mock storage on error
+    const key = options?.service || 'default';
+    return mockStorage[key] || null;
+  }
+};
+
+// Wrapper for setGenericPassword that falls back to mock storage
+const safeSetGenericPassword = async (
+  username: string,
+  password: string,
+  options?: Keychain.Options
+) => {
+  try {
+    if (isKeychainAvailable()) {
+      return await Keychain.setGenericPassword(username, password, options);
+    } else {
+      // Fall back to mock storage in memory
+      const key = options?.service || 'default';
+      mockStorage[key] = { username, password };
+      return true;
+    }
+  } catch (error) {
+    console.warn('Keychain access failed, using mock storage', error);
+    // Fall back to mock storage on error
+    const key = options?.service || 'default';
+    mockStorage[key] = { username, password };
+    return true;
+  }
+};
+
+// Wrapper for resetGenericPassword that falls back to mock storage
+const safeResetGenericPassword = async (options?: Keychain.Options) => {
+  try {
+    if (isKeychainAvailable()) {
+      return await Keychain.resetGenericPassword(options);
+    } else {
+      // Fall back to mock storage in memory
+      const key = options?.service || 'default';
+      delete mockStorage[key];
+      return true;
+    }
+  } catch (error) {
+    console.warn('Keychain access failed, using mock storage', error);
+    // Fall back to mock storage on error
+    const key = options?.service || 'default';
+    delete mockStorage[key];
+    return true;
+  }
+};
 
 /**
  * Store credentials in memory (temporary solution)
  */
 export const storeCredentials = async (
-  credentials: OnairosCredentials,
-  options: StorageOptions = {}
+  credentials: Partial<OnairosCredentials>
 ): Promise<boolean> => {
   try {
-    console.log('[Mock] Storing credentials:', credentials.username);
-    mockStorage[credentials.username] = JSON.stringify(credentials);
+    const existingCredentials = await getCredentials();
+    const updatedCredentials: OnairosCredentials = {
+      ...existingCredentials,
+      ...credentials,
+      createdAt: existingCredentials?.createdAt || Date.now(),
+    } as OnairosCredentials;
+
+    const username = updatedCredentials.username;
+    if (!username) {
+      throw new Error('Username is required for storing credentials');
+    }
+
+    const options: Keychain.Options = {
+      service: STORAGE_KEYS.credentials,
+    };
+
+    // Only use secure storage options on real devices
+    if (Platform.OS !== 'web' && isKeychainAvailable()) {
+      options.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY_OR_DEVICE_PASSCODE;
+      options.accessible = Keychain.ACCESSIBLE.WHEN_UNLOCKED;
+    }
+
+    await safeSetGenericPassword(
+      username,
+      JSON.stringify(updatedCredentials),
+      options
+    );
     return true;
   } catch (error) {
     console.error('Error storing credentials:', error);
@@ -46,18 +142,17 @@ export const storeCredentials = async (
 /**
  * Retrieve credentials from memory (temporary solution)
  */
-export const getCredentials = async (
-  options: StorageOptions = {}
-): Promise<OnairosCredentials | null> => {
+export const getCredentials = async (): Promise<OnairosCredentials | null> => {
   try {
-    // Get the first stored credential (temporary solution)
-    const storedCredential = Object.values(mockStorage)[0];
-    if (!storedCredential) {
-      return null;
+    const credentials = await safeGetGenericPassword({
+      service: STORAGE_KEYS.credentials,
+    });
+    if (credentials) {
+      return JSON.parse(credentials.password);
     }
-    return JSON.parse(storedCredential);
+    return null;
   } catch (error) {
-    console.error('Error retrieving credentials:', error);
+    console.error('Error getting credentials:', error);
     return null;
   }
 };
@@ -67,9 +162,12 @@ export const getCredentials = async (
  */
 export const hasCredentials = async (): Promise<boolean> => {
   try {
-    return Object.keys(mockStorage).length > 0;
+    const credentials = await safeGetGenericPassword({
+      service: STORAGE_KEYS.credentials,
+    });
+    return !!credentials;
   } catch (error) {
-    console.error('Error checking for credentials:', error);
+    console.error('Error checking credentials:', error);
     return false;
   }
 };
@@ -79,7 +177,9 @@ export const hasCredentials = async (): Promise<boolean> => {
  */
 export const deleteCredentials = async (): Promise<boolean> => {
   try {
-    mockStorage = {};
+    await safeResetGenericPassword({
+      service: STORAGE_KEYS.credentials,
+    });
     return true;
   } catch (error) {
     console.error('Error deleting credentials:', error);
@@ -91,47 +191,30 @@ export const deleteCredentials = async (): Promise<boolean> => {
  * Update specific fields in the stored credentials
  */
 export const updateCredentials = async (
-  updates: Partial<OnairosCredentials>,
-  options: StorageOptions = {}
+  credentials: Partial<OnairosCredentials>
 ): Promise<boolean> => {
-  try {
-    const currentCredentials = await getCredentials(options);
-    if (!currentCredentials) {
-      return false;
-    }
-    const updatedCredentials: OnairosCredentials = {
-      ...currentCredentials,
-      ...updates,
-    };
-    return await storeCredentials(updatedCredentials, options);
-  } catch (error) {
-    console.error('Error updating credentials:', error);
-    return false;
-  }
+  return storeCredentials(credentials);
 };
 
 /**
  * Generate a device-specific unique username
  */
-export const generateDeviceUsername = async (): Promise<string> => {
-  try {
-    const deviceInfo = `${Platform.OS}-${Platform.Version}-${Date.now()}`;
-    const username = `onairos_${sha256(deviceInfo).substring(0, 10)}`;
-    return username;
-  } catch (error) {
-    console.error('Error generating device username:', error);
-    return `onairos_${Date.now().toString(36)}`;
-  }
+export const generateDeviceUsername = (): string => {
+  const randomId = Math.random().toString(36).substring(2, 10);
+  return `dev_${randomId}`;
 };
 
 /**
  * Verify credentials (temporary mock implementation)
  */
-export const verifyCredentials = async (
-  credentials: OnairosCredentials
-): Promise<boolean> => {
+export const verifyCredentials = async (username: string): Promise<boolean> => {
   try {
-    console.log('[Mock] Verifying credentials for:', credentials.username);
+    // For Expo Go or development, always return true
+    if (!isKeychainAvailable()) {
+      return true;
+    }
+    
+    // TODO: Implement actual verification with API
     return true;
   } catch (error) {
     console.error('Error verifying credentials:', error);