@onairos/react-native 3.0.1 → 3.0.4

package/src/types/ambient.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Ambient type declarations to fix Node.js module conflicts
+ */
+
+// These modules are not used directly in React Native, but are referenced by types
+// Providing empty declarations prevents TypeScript from trying to use Node.js types
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): any;
+    once(event: string, listener: (...args: any[]) => void): any;
+    prependOnceListener(event: string, listener: (...args: any[]) => void): any;
+  }
+}
+
+declare module 'node:https' {}
+declare module 'node:http' {}
+declare module 'node:crypto' {}
+declare module 'process' {
+  global {
+    namespace NodeJS {
+      interface Process {
+        env: {
+          NODE_ENV?: string;
+          [key: string]: string | undefined;
+        };
+      }
+    }
+  }
+} 

package/src/types/index.d.ts

@@ -9,27 +9,47 @@ declare module '@onairos/react-native' {
   }
 
   export interface OnairosButtonProps {
+    /** Return link after authentication (used for web-based flows) */
     returnLink?: string;
+    /** Prefill URL for the authentication process */
     prefillUrl?: string;
-    AppName: string;
+    /** Application name to display in dialogs */
+    AppName?: string;
+    /** Button type - 'normal' or 'pill' */
     buttonType?: 'normal' | 'pill';
+    /** Data requests for user consent */
     requestData?: {
-      Small: DataTier;
-      Medium: DataTier;
-      Large: DataTier;
+      [key: string]: {
+        type: string;
+        descriptions: string;
+        reward: string;
+      };
     };
-    buttonWidth?: number;
+    /** Button width in pixels or percentage */
+    buttonWidth?: number | string;
+    /** Button height in pixels */
     buttonHeight?: number;
+    /** Whether to show stroke/border around button */
     hasStroke?: boolean;
+    /** Whether the button is enabled */
     enabled?: boolean;
-    buttonForm?: 'default' | 'login' | 'signup';
-    onRejection?: () => void;
-    onResolved?: (apiUrl: string, token: string, userData: any) => void;
+    /** Button form/shape style */
+    buttonForm?: 'default' | 'rounded' | 'square';
+    /** Callback when user rejects or cancels */
+    onRejection?: (reason: string) => void;
+    /** Callback when authentication is resolved */
+    onResolved?: (apiUrl: string, accessToken: string, data: any) => void;
+    /** Function to check before starting authentication */
     preCheck?: () => Promise<boolean>;
+    /** Button background color */
     color?: string;
+    /** Whether to apply a slight rotation effect */
     swerv?: boolean;
+    /** Enable debug mode */
     debug?: boolean;
+    /** Preferred platform for authentication */
     preferredPlatform?: string;
+    /** Enable test mode */
     testMode?: boolean;
   }
 
@@ -110,4 +130,24 @@ declare module '@onairos/react-native' {
   export class PinInput extends Component<PinInputProps> {}
   export class TrainingModal extends Component<TrainingModalProps> {}
   export class OAuthWebView extends Component<OAuthWebViewProps> {}
+}
+
+// Fix for Node.js type conflicts
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): this;
+  }
+}
+
+// Override any problematic Node.js types
+declare module 'node:https' {
+  export * from 'https';
+}
+
+declare module 'node:http' {
+  export * from 'http';
+}
+
+declare module 'node:crypto' {
+  export * from 'crypto';
 } 

package/src/types/index.ts

@@ -7,14 +7,16 @@ export interface DataTier {
 export interface OnairosButtonProps {
   returnLink?: string;
   prefillUrl?: string;
-  AppName: string;
+  AppName?: string;
   buttonType?: 'normal' | 'pill';
   requestData?: {
-    Small: DataTier;
-    Medium: DataTier;
-    Large: DataTier;
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
   };
-  buttonWidth?: number;
+  buttonWidth?: number | string;
   buttonHeight?: number;
   hasStroke?: boolean;
   enabled?: boolean;
@@ -34,9 +36,11 @@ export interface UniversalOnboardingProps {
   onClose: () => void;
   AppName: string;
   requestData?: {
-    Small: DataTier;
-    Medium: DataTier;
-    Large: DataTier;
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
   };
   returnLink?: string;
   onComplete: (apiUrl: string, token: string, userData: any) => void;
@@ -81,6 +85,13 @@ export interface OAuthWebViewProps {
   onClose: () => void;
 }
 
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
 export interface OnairosCredentials {
   username: string;
   accessToken?: string;
@@ -106,13 +117,8 @@ export interface OverlayProps {
   username: string;
   modelKey: string;
   onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
-}
-
-export interface PlatformConfig {
-  name: string;
-  icon: string;
-  color: string;
-  description?: string;
+  appName?: string;
+  darkMode?: boolean;
 }
 
 export interface BiometricOptions {

package/src/types/node-fix.d.ts

@@ -0,0 +1,19 @@
+// Fix for Node.js type conflicts
+declare module 'https' {
+  interface Server {
+    prependListener(event: string, listener: (...args: any[]) => void): this;
+  }
+}
+
+// Override any problematic Node.js types
+declare module 'node:https' {
+  export * from 'https';
+}
+
+declare module 'node:http' {
+  export * from 'http';
+}
+
+declare module 'node:crypto' {
+  export * from 'crypto';
+} 

package/src/types/node-override.d.ts

@@ -0,0 +1,24 @@
+// Override for Node.js HTTPS module to fix type errors
+declare module 'node:https' {
+  import * as http from 'http';
+  import * as tls from 'tls';
+  
+  interface ServerOptions {
+    // Define simplified options
+  }
+  
+  class Server extends tls.Server {
+    // Override problematic methods with any type
+    prependListener(event: string, listener: any): this;
+    prependOnceListener(event: string, listener: any): this;
+    once(event: string, listener: any): this;
+  }
+  
+  function createServer(options?: ServerOptions, requestListener?: any): Server;
+  function createServer(requestListener?: any): Server;
+}
+
+// Also override node:http
+declare module 'node:http' {
+  export * from 'http';
+} 

package/src/types/types.d.ts

@@ -0,0 +1,18 @@
+declare module '@onairos/react-native' {
+  import { Component } from 'react';
+  import { ViewStyle } from 'react-native';
+
+  // Re-export all the types from our index.ts
+  export * from '../types';
+  
+  // Components
+  export class Onairos extends Component<any> {}
+  export class OnairosButton extends Component<import('../types').OnairosButtonProps> {}
+  export class OnairosOverlay extends Component<import('../types').OverlayProps> {}
+  export class UniversalOnboarding extends Component<import('../types').UniversalOnboardingProps> {}
+}
+
+// Fix for Node.js type conflicts by providing empty declarations
+declare module 'node:https' {}
+declare module 'node:http' {}
+declare module 'node:crypto' {} 

package/src/types.ts

@@ -20,10 +20,130 @@ export interface UniversalOnboardingProps {
   test?: boolean;
   buttonType?: 'default' | 'pill';
   buttonForm?: 'signup' | 'login';
+  preferredPlatform?: string;
 }
 
 export interface ConnectionStatus {
-  [key: string]: boolean;
+  [key: string]: {
+    userName: string;
+    connected: boolean;
+  };
+}
+
+export interface OnairosButtonProps {
+  returnLink?: string;
+  prefillUrl?: string;
+  AppName: string;
+  buttonType?: 'normal' | 'pill';
+  requestData?: {
+    Small: DataTier;
+    Medium: DataTier;
+    Large: DataTier;
+  };
+  buttonWidth?: number;
+  buttonHeight?: number;
+  hasStroke?: boolean;
+  enabled?: boolean;
+  buttonForm?: 'default' | 'login' | 'signup';
+  onRejection?: (error?: string) => void;
+  onResolved?: (apiUrl: string, token: string, userData: any) => void;
+  preCheck?: () => Promise<boolean>;
+  color?: string;
+  swerv?: boolean;
+  debug?: boolean;
+  preferredPlatform?: string;
+  testMode?: boolean;
+}
+
+export interface PlatformListProps {
+  platforms?: string[];
+  onSelect?: (platform: string) => void;
+  selectedPlatform?: string;
+  connections?: ConnectionStatus;
+  onToggle?: (platform: string, connect: boolean) => void;
+  isLoading?: boolean;
+  canProceed?: boolean;
+  onProceed?: () => void;
+}
+
+export interface PinInputProps {
+  onComplete?: (pin: string) => void;
+  length?: number;
+  secure?: boolean;
+  title?: string;
+  subtitle?: string;
+  verification?: boolean;
+  initialPin?: string;
+  onSubmit: (pin: string) => void;
+  minLength?: number;
+  requireSpecialChar?: boolean;
+  requireNumber?: boolean;
+}
+
+export interface TrainingModalProps {
+  visible: boolean;
+  onClose: () => void;
+  onComplete: () => void;
+  modelKey: string;
+  username: string;
+  progress?: number;
+  eta?: string;
+  onCancel?: () => void;
+}
+
+export interface OAuthWebViewProps {
+  url: string;
+  onClose: () => void;
+  onSuccess: (code: string) => void;
+  platform?: string;
+  onComplete?: () => void;
+}
+
+export interface PlatformConfig {
+  name: string;
+  icon: string;
+  color: string;
+  description?: string;
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  publicKey?: string;
+}
+
+export interface CredentialsResult {
+  success: boolean;
+  credentials?: any;
+  error?: string;
+  isValid?: boolean;
+}
+
+export interface OverlayProps {
+  data: {
+    [key: string]: {
+      type: string;
+      descriptions: string;
+      reward: string;
+    };
+  };
+  username: string;
+  modelKey: string;
+  onResolved: (apiUrl: string, accessToken: string, loginDetails: any) => void;
+}
+
+export interface BiometricOptions {
+  enableBiometrics?: boolean;
+  biometricPrompt?: string;
+}
+
+export interface PinRequirements {
+  minLength: number;
+  requireUppercase: boolean;
+  requireLowercase: boolean;
+  requireNumber: boolean;
+  requireSpecialChar: boolean;
 }
 
 // ... rest of the existing types ... 

package/src/utils/encryption.ts

@@ -1,5 +1,6 @@
 import { onairosApi } from '../api';
 import RSA from 'react-native-rsa-native';
+import { ApiResponse } from '../types';
 
 /**
  * Encrypt a model key using RSA with a public key
@@ -33,10 +34,14 @@ export const encryptModelKey = (publicKey: string, modelKey: string): string =>
  */
 export const getServerPublicKey = async (): Promise<string> => {
   try {
+    // Use the API without generics to prevent TypeScript errors
     const response = await onairosApi.get('public/getPublicKey');
     
-    if (response && response.publicKey) {
-      return response.publicKey;
+    // Check for the public key in the response data
+    if (response?.data?.data?.publicKey) {
+      return response.data.data.publicKey;
+    } else if (response?.data?.publicKey) {
+      return response.data.publicKey;
     } else {
       throw new Error('No public key found in response');
     }

package/src/utils/secureStorage.ts

@@ -1,41 +1,153 @@
 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?: any;
+  accessible?: any;
+}
+
+// Create a mock storage for environments without Keychain access (like Expo Go)
+const mockStorage: Record<string, { username: string; password: string }> = {};
+
+// Try to import Keychain, but provide fallbacks if not available
+let Keychain: any = null;
+try {
+  // This import might fail in Expo Go or environments without native modules
+  Keychain = require('react-native-keychain');
+} catch (error) {
+  console.warn('react-native-keychain module not available, using mock storage');
+  // Create minimal mock implementation
+  Keychain = {
+    ACCESS_CONTROL: { BIOMETRY_ANY_OR_DEVICE_PASSCODE: 'mock' },
+    ACCESSIBLE: { WHEN_UNLOCKED: 'mock' },
+    getGenericPassword: async () => null,
+    setGenericPassword: async () => true,
+    resetGenericPassword: async () => true,
   };
 }
 
-// Temporary in-memory storage
-let mockStorage: { [key: string]: string } = {};
+// Check if Keychain is properly initialized and available
+const isKeychainAvailable = () => {
+  try {
+    return Keychain && typeof Keychain.getGenericPassword === 'function';
+  } catch (e) {
+    return false;
+  }
+};
+
+// Wrapper for getGenericPassword that falls back to mock storage
+const safeGetGenericPassword = async (options: any) => {
+  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?: any
+) => {
+  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?: any) => {
+  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: any = {
+      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 +158,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 +178,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 +193,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 +207,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);