@onairos/react-native 1.0.0

package/src/utils/crypto.js

@@ -0,0 +1,60 @@
+import { RSA } from 'react-native-rsa-native';
+import { sha256 as cryptoSha256 } from 'react-native-crypto-js';
+
+/**
+ * Encrypt data using RSA
+ * @param {string} publicKey - The RSA public key
+ * @param {string} data - The data to encrypt
+ * @returns {Promise<string>} - The encrypted data
+ */
+export const rsaEncrypt = async (publicKey, data) => {
+  try {
+    // Clean the public key format
+    const cleanedKey = publicKey
+      .replace(/\\n/g, '')
+      .replace(/^\s+|\s+$/g, '')
+      .replace('-----BEGIN PUBLIC KEY-----', '')
+      .replace('-----END PUBLIC KEY-----', '')
+      .trim();
+    
+    // Format the key properly for the library
+    const formattedKey = `-----BEGIN PUBLIC KEY-----\n${cleanedKey}\n-----END PUBLIC KEY-----`;
+    
+    // Encrypt the data
+    const encrypted = await RSA.encrypt(data, formattedKey);
+    return encrypted;
+  } catch (error) {
+    console.error('RSA encryption failed:', error);
+    throw error;
+  }
+};
+
+/**
+ * Hash data using SHA-256
+ * @param {string} data - The data to hash
+ * @returns {string} - The hashed data
+ */
+export const sha256 = (data) => {
+  return cryptoSha256(data).toString();
+};
+
+/**
+ * Convert a base64 string to a buffer
+ * @param {string} base64String - The base64 string to convert
+ * @returns {ArrayBuffer} - The converted buffer
+ */
+export const base64ToBuffer = (base64String) => {
+  try {
+    const binaryString = Buffer.from(base64String, 'base64').toString('binary');
+    const bytes = new Uint8Array(binaryString.length);
+    
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    
+    return bytes.buffer;
+  } catch (error) {
+    console.error('Error converting base64 to buffer:', error);
+    throw error;
+  }
+}; 

package/src/utils/debugHelper.ts

@@ -0,0 +1,53 @@
+/**
+ * Debug utility functions for Onairos React Native SDK
+ */
+
+// Determine if we're in dev mode
+const __DEV__ = process.env.NODE_ENV !== 'production';
+
+/**
+ * Log debug message to console when in development mode
+ * @param label Label for the debug message
+ * @param data Data to log
+ */
+export const logDebug = (label: string, data?: any): void => {
+  if (__DEV__) {
+    console.log(`[Onairos Debug] ${label}:`, data || '');
+  }
+};
+
+/**
+ * Log error message to console
+ * @param label Label for the error message
+ * @param error Error object or message
+ */
+export const logError = (label: string, error: any): void => {
+  if (__DEV__) {
+    console.error(`[Onairos Error] ${label}:`, error);
+  }
+};
+
+/**
+ * Check if debug mode is enabled
+ * @param debug Debug flag passed to component
+ * @returns Whether debug mode is enabled
+ */
+export const isDebugMode = (debug?: boolean): boolean => {
+  return debug === true || __DEV__;
+};
+
+/**
+ * Format and log API request details
+ * @param method HTTP method
+ * @param url API URL
+ * @param data Request data
+ */
+export const logApiRequest = (method: string, url: string, data?: any): void => {
+  if (__DEV__) {
+    logDebug('API Request', {
+      method,
+      url,
+      data: data || {},
+    });
+  }
+};

package/src/utils/onairosApi.ts

@@ -0,0 +1,303 @@
+import { Platform } from 'react-native';
+import NetInfo from '@react-native-community/netinfo';
+import { OnairosCredentials } from './secureStorage';
+import { logDebug } from './debugHelper';
+
+// API configuration
+const API_CONFIG = {
+  baseUrl: 'https://api2.onairos.uk',
+  version: 'v1',
+  timeout: 30000, // 30 seconds
+};
+
+// API response types
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: {
+    code: string;
+    message: string;
+    details?: any;
+  };
+}
+
+// Error types
+export type ApiErrorType = 
+  | 'network_error'
+  | 'timeout_error'
+  | 'auth_error' 
+  | 'server_error' 
+  | 'validation_error' 
+  | 'unknown_error';
+
+// API error structure
+export class ApiError extends Error {
+  type: ApiErrorType;
+  code?: string;
+  details?: any;
+  
+  constructor(message: string, type: ApiErrorType, code?: string, details?: any) {
+    super(message);
+    this.type = type;
+    this.code = code;
+    this.details = details;
+    this.name = 'ApiError';
+  }
+}
+
+/**
+ * Check if the device has an active network connection
+ */
+const checkNetworkConnection = async (): Promise<boolean> => {
+  const networkState = await NetInfo.fetch();
+  return networkState.isConnected === true;
+};
+
+/**
+ * Build API request headers
+ */
+const buildHeaders = (accessToken?: string, additionalHeaders = {}): Record<string, string> => {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+    'User-Agent': `OnairosReactNative/${Platform.OS}/${Platform.Version}`,
+    ...additionalHeaders,
+  };
+  
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+  
+  return headers;
+};
+
+/**
+ * Make API request with proper error handling
+ */
+const apiRequest = async <T>(
+  endpoint: string,
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
+  options: {
+    data?: any;
+    accessToken?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    debug?: boolean;
+  } = {}
+): Promise<ApiResponse<T>> => {
+  const {
+    data,
+    accessToken,
+    headers = {},
+    timeout = API_CONFIG.timeout,
+    debug = false,
+  } = options;
+  
+  try {
+    // Check for network connectivity
+    const isConnected = await checkNetworkConnection();
+    if (!isConnected) {
+      throw new ApiError(
+        'No network connection available',
+        'network_error'
+      );
+    }
+    
+    // Build request URL
+    const url = `${API_CONFIG.baseUrl}/${API_CONFIG.version}/${endpoint}`;
+    
+    // Log request information if debug mode is enabled
+    if (debug) {
+      logDebug('API Request', {
+        url,
+        method,
+        headers: { ...buildHeaders(accessToken, headers), Authorization: accessToken ? '[REDACTED]' : undefined },
+        data: data || null,
+      });
+    }
+    
+    // Set up request options
+    const fetchOptions: RequestInit = {
+      method,
+      headers: buildHeaders(accessToken, headers),
+      ...(data ? { body: JSON.stringify(data) } : {}),
+    };
+    
+    // Create fetch request with timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    
+    // Execute request
+    const response = await fetch(url, {
+      ...fetchOptions,
+      signal: controller.signal,
+    });
+    
+    // Clear timeout
+    clearTimeout(timeoutId);
+    
+    // Parse response as JSON
+    const responseData = await response.json();
+    
+    // Log response if debug mode is enabled
+    if (debug) {
+      logDebug('API Response', {
+        status: response.status,
+        data: responseData,
+      });
+    }
+    
+    // Handle API error responses
+    if (!response.ok) {
+      const errorType: ApiErrorType = 
+        response.status === 401 || response.status === 403 ? 'auth_error' :
+        response.status === 400 ? 'validation_error' :
+        response.status >= 500 ? 'server_error' : 'unknown_error';
+      
+      throw new ApiError(
+        responseData.error?.message || 'API request failed',
+        errorType,
+        responseData.error?.code,
+        responseData.error?.details
+      );
+    }
+    
+    return responseData as ApiResponse<T>;
+  } catch (error) {
+    // Handle specific error types
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    
+    if (error.name === 'AbortError') {
+      throw new ApiError('Request timed out', 'timeout_error');
+    }
+    
+    // Log error if debug mode is enabled
+    if (debug) {
+      logDebug('API Error', {
+        endpoint,
+        method,
+        error: error.message || 'Unknown error',
+      });
+    }
+    
+    // Return a generic error for all other cases
+    throw new ApiError(
+      error.message || 'An unexpected error occurred',
+      'unknown_error'
+    );
+  }
+};
+
+/**
+ * Validate user credentials with the API
+ */
+export const validateCredentials = async (
+  username: string,
+  options = { debug: false }
+): Promise<{ isValid: boolean; message?: string }> => {
+  try {
+    const response = await apiRequest<{ isValid: boolean }>('auth/validate', 'POST', {
+      data: { username },
+      debug: options.debug,
+    });
+    
+    return {
+      isValid: response.success && response.data?.isValid === true,
+      message: response.error?.message,
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      message: error.message,
+    };
+  }
+};
+
+/**
+ * Create a new user account
+ */
+export const createAccount = async (
+  credentials: Partial<OnairosCredentials>,
+  options = { debug: false }
+): Promise<ApiResponse<{ accessToken: string; userId: string }>> => {
+  return apiRequest('auth/register', 'POST', {
+    data: {
+      username: credentials.username,
+      platforms: credentials.platforms,
+    },
+    debug: options.debug,
+  });
+};
+
+/**
+ * Authenticate with the API using credentials
+ */
+export const authenticate = async (
+  credentials: Partial<OnairosCredentials>,
+  options = { debug: false }
+): Promise<ApiResponse<{ accessToken: string; refreshToken: string }>> => {
+  return apiRequest('auth/login', 'POST', {
+    data: {
+      username: credentials.username,
+      pin: credentials.userPin,
+    },
+    debug: options.debug,
+  });
+};
+
+/**
+ * Refresh authentication token
+ */
+export const refreshToken = async (
+  refreshToken: string,
+  options = { debug: false }
+): Promise<ApiResponse<{ accessToken: string; refreshToken: string }>> => {
+  return apiRequest('auth/refresh', 'POST', {
+    data: { refreshToken },
+    debug: options.debug,
+  });
+};
+
+/**
+ * Get user's connected platform data
+ */
+export const getPlatformData = async (
+  accessToken: string,
+  platform: string,
+  options = { debug: false }
+): Promise<ApiResponse<any>> => {
+  return apiRequest(`platforms/${platform}/data`, 'GET', {
+    accessToken,
+    debug: options.debug,
+  });
+};
+
+/**
+ * Get user profile information
+ */
+export const getUserProfile = async (
+  accessToken: string,
+  options = { debug: false }
+): Promise<ApiResponse<any>> => {
+  return apiRequest('user/profile', 'GET', {
+    accessToken,
+    debug: options.debug,
+  });
+};
+
+/**
+ * Update user platform connections
+ */
+export const updatePlatformConnections = async (
+  accessToken: string,
+  platforms: Record<string, any>,
+  options = { debug: false }
+): Promise<ApiResponse<any>> => {
+  return apiRequest('user/platforms', 'PUT', {
+    accessToken,
+    data: { platforms },
+    debug: options.debug,
+  });
+};

package/src/utils/secureStorage.ts

@@ -0,0 +1,230 @@
+import * as Keychain from 'react-native-keychain';
+import { Platform } from 'react-native';
+import { sha256 } from './crypto';
+
+export interface OnairosCredentials {
+  username: 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 };
+  };
+  createdAt: number;
+}
+
+export interface StorageOptions {
+  useBiometrics?: boolean;
+  biometricPrompt?: {
+    title: string;
+    subtitle?: string;
+  };
+}
+
+const CREDENTIALS_KEY = 'onairos_credentials';
+
+/**
+ * Store credentials securely in the device keychain with optional biometric protection
+ */
+export const storeCredentials = async (
+  credentials: OnairosCredentials,
+  options: StorageOptions = {}
+): Promise<boolean> => {
+  try {
+    const { useBiometrics = true, biometricPrompt } = options;
+    
+    // Create a JSON string of the credentials
+    const credentialsString = JSON.stringify(credentials);
+    
+    // Configure security options based on platform
+    const securityOptions: Keychain.Options = {
+      service: CREDENTIALS_KEY,
+      accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+    };
+    
+    // Add biometric protection if requested
+    if (useBiometrics) {
+      // iOS specific options
+      if (Platform.OS === 'ios') {
+        securityOptions.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY_OR_DEVICE_PASSCODE;
+      }
+      
+      // Android specific options
+      if (Platform.OS === 'android') {
+        securityOptions.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY;
+        if (biometricPrompt) {
+          securityOptions.authenticationType = Keychain.AUTHENTICATION_TYPE.BIOMETRIC;
+          securityOptions.authenticationPrompt = {
+            title: biometricPrompt.title || 'Biometric Authentication',
+            subtitle: biometricPrompt.subtitle,
+            description: 'Please authenticate to access your Onairos credentials',
+            cancel: 'Cancel',
+          };
+        }
+      }
+    }
+    
+    // Store in the secure keychain
+    await Keychain.setGenericPassword(
+      credentials.username,
+      credentialsString,
+      securityOptions
+    );
+    
+    return true;
+  } catch (error) {
+    console.error('Error storing credentials:', error);
+    return false;
+  }
+};
+
+/**
+ * Retrieve credentials from secure storage, potentially requiring biometric authentication
+ */
+export const getCredentials = async (
+  options: StorageOptions = {}
+): Promise<OnairosCredentials | null> => {
+  try {
+    const { useBiometrics = true, biometricPrompt } = options;
+    
+    // Configure security options
+    const securityOptions: Keychain.Options = {
+      service: CREDENTIALS_KEY,
+    };
+    
+    // Add biometric prompt if required
+    if (useBiometrics && biometricPrompt) {
+      securityOptions.authenticationPrompt = {
+        title: biometricPrompt.title || 'Biometric Authentication',
+        subtitle: biometricPrompt.subtitle,
+        description: 'Please authenticate to access your Onairos credentials',
+        cancel: 'Cancel',
+      };
+    }
+    
+    // Retrieve from keychain
+    const result = await Keychain.getGenericPassword(securityOptions);
+    
+    if (!result) {
+      return null;
+    }
+    
+    // Parse the stored JSON
+    const credentials: OnairosCredentials = JSON.parse(result.password);
+    return credentials;
+  } catch (error) {
+    console.error('Error retrieving credentials:', error);
+    return null;
+  }
+};
+
+/**
+ * Check if the user has stored credentials
+ */
+export const hasCredentials = async (): Promise<boolean> => {
+  try {
+    const result = await Keychain.getGenericPassword({
+      service: CREDENTIALS_KEY,
+    });
+    
+    return !!result;
+  } catch (error) {
+    console.error('Error checking for credentials:', error);
+    return false;
+  }
+};
+
+/**
+ * Delete stored credentials
+ */
+export const deleteCredentials = async (): Promise<boolean> => {
+  try {
+    await Keychain.resetGenericPassword({ service: CREDENTIALS_KEY });
+    return true;
+  } catch (error) {
+    console.error('Error deleting credentials:', error);
+    return false;
+  }
+};
+
+/**
+ * Update specific fields in the stored credentials
+ */
+export const updateCredentials = async (
+  updates: Partial<OnairosCredentials>,
+  options: StorageOptions = {}
+): Promise<boolean> => {
+  try {
+    // Get current credentials
+    const currentCredentials = await getCredentials(options);
+    
+    if (!currentCredentials) {
+      return false;
+    }
+    
+    // Merge updates with current credentials
+    const updatedCredentials: OnairosCredentials = {
+      ...currentCredentials,
+      ...updates,
+    };
+    
+    // Store updated credentials
+    return await storeCredentials(updatedCredentials, options);
+  } catch (error) {
+    console.error('Error updating credentials:', error);
+    return false;
+  }
+};
+
+/**
+ * Generate a device-specific unique username
+ */
+export const generateDeviceUsername = async (): Promise<string> => {
+  try {
+    // Get a device-specific identifier that we can use
+    // This is a simplified example - in production you might want to use
+    // a more robust device identifier method
+    const deviceInfo = `${Platform.OS}-${Platform.Version}-${Date.now()}`;
+    
+    // Hash it to create a unique identifier
+    const username = `onairos_${sha256(deviceInfo).substring(0, 10)}`;
+    
+    return username;
+  } catch (error) {
+    console.error('Error generating device username:', error);
+    // Fallback to a timestamp-based username if there's an error
+    return `onairos_${Date.now().toString(36)}`;
+  }
+};
+
+/**
+ * Verify if credentials are valid (not expired, etc.)
+ */
+export const verifyCredentials = async (
+  credentials: OnairosCredentials
+): Promise<boolean> => {
+  try {
+    // Basic verification - check if credentials exist and aren't too old
+    if (!credentials || !credentials.accessToken || !credentials.username) {
+      return false;
+    }
+    
+    // Check for expiration (example: credentials expire after 30 days)
+    const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000;
+    const isExpired = Date.now() - credentials.createdAt > thirtyDaysMs;
+    
+    if (isExpired) {
+      return false;
+    }
+    
+    // Add any additional verification logic here
+    
+    return true;
+  } catch (error) {
+    console.error('Error verifying credentials:', error);
+    return false;
+  }
+};