@onairos/react-native 3.1.0 → 3.1.2

package/src/index.ts

@@ -22,6 +22,9 @@ export { Onairos } from './components/Onairos';
 export { 
   initializeApiKey,
   ADMIN_API_KEY,
+  extractUsernameFromJWT,
+  extractUserDataFromJWT,
+  decodeJWTPayload,
 } from './services/apiKeyService';
 
 // Authentication & PIN Management

package/src/services/apiKeyService.ts

@@ -352,6 +352,136 @@ export const clearJWT = async (): Promise<void> => {
   }
 };
 
+/**
+ * React Native compatible base64 decoder
+ * @param str Base64 encoded string
+ * @returns Decoded string
+ */
+const base64Decode = (str: string): string => {
+  // Simple base64 decoding for React Native
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  let result = '';
+  let i = 0;
+  
+  str = str.replace(/[^A-Za-z0-9+/]/g, '');
+  
+  while (i < str.length) {
+    const a = chars.indexOf(str.charAt(i++));
+    const b = chars.indexOf(str.charAt(i++));
+    const c = chars.indexOf(str.charAt(i++));
+    const d = chars.indexOf(str.charAt(i++));
+    
+    const bitmap = (a << 18) | (b << 12) | (c << 6) | d;
+    
+    result += String.fromCharCode((bitmap >> 16) & 255);
+    if (c !== 64) result += String.fromCharCode((bitmap >> 8) & 255);
+    if (d !== 64) result += String.fromCharCode(bitmap & 255);
+  }
+  
+  return result;
+};
+
+/**
+ * Decode JWT token payload (React Native compatible)
+ * @param token JWT token string
+ * @returns Decoded payload or null if invalid
+ */
+export const decodeJWTPayload = (token: string): any => {
+  try {
+    // Split JWT token (header.payload.signature)
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+      console.error('❌ Invalid JWT token format');
+      return null;
+    }
+
+    // Decode payload (base64url to base64)
+    const payload = parts[1];
+    const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+    
+    // Add padding if needed
+    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, '=');
+    
+    // Decode base64 to JSON using React Native compatible decoder
+    const decoded = base64Decode(padded);
+    return JSON.parse(decoded);
+  } catch (error) {
+    console.error('❌ Failed to decode JWT token:', error);
+    return null;
+  }
+};
+
+/**
+ * Extract username from JWT token
+ * @param token JWT token (optional, uses stored token if not provided)
+ * @returns Username or null if not found
+ */
+export const extractUsernameFromJWT = (token?: string): string | null => {
+  try {
+    const jwtToken = token || userToken;
+    if (!jwtToken) {
+      console.warn('⚠️ No JWT token available for username extraction');
+      return null;
+    }
+
+    const payload = decodeJWTPayload(jwtToken);
+    if (!payload) {
+      return null;
+    }
+
+    // Try different possible username fields in order of preference
+    const username = payload.userName || payload.username || payload.userId || payload.email;
+    
+    if (globalConfig?.enableLogging) {
+      console.log('👤 Extracted username from JWT:', username);
+    }
+
+    return username || null;
+  } catch (error) {
+    console.error('❌ Failed to extract username from JWT:', error);
+    return null;
+  }
+};
+
+/**
+ * Extract user data from JWT token
+ * @param token JWT token (optional, uses stored token if not provided)
+ * @returns User data object or null if not found
+ */
+export const extractUserDataFromJWT = (token?: string): any => {
+  try {
+    const jwtToken = token || userToken;
+    if (!jwtToken) {
+      console.warn('⚠️ No JWT token available for user data extraction');
+      return null;
+    }
+
+    const payload = decodeJWTPayload(jwtToken);
+    if (!payload) {
+      return null;
+    }
+
+    const userData = {
+      id: payload.id,
+      email: payload.email,
+      userId: payload.userId,
+      userName: payload.userName || payload.username,
+      verified: payload.verified,
+      iat: payload.iat,
+      exp: payload.exp
+    };
+
+    if (globalConfig?.enableLogging) {
+      console.log('👤 Extracted user data from JWT:', userData);
+    }
+
+    return userData;
+  } catch (error) {
+    console.error('❌ Failed to extract user data from JWT:', error);
+    return null;
+  }
+};
+
 /**
  * Check if user is authenticated with JWT token
  * @returns True if user has valid JWT token

package/src/services/platformAuthService.ts

@@ -1,7 +1,7 @@
 import { Platform, Linking } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { PlatformAuthConfig } from '../types';
-import { makeDeveloperRequest, getApiConfig, storeJWT } from './apiKeyService';
+import { makeDeveloperRequest, getApiConfig, storeJWT, extractUsernameFromJWT } from './apiKeyService';
 
 // 🔑 CRITICAL: Use two-tier authentication system
 // - Developer API key for email verification requests
@@ -332,16 +332,20 @@ export const initiateNativeAuth = async (platform: string, username?: string): P
       
       // Configure Google Sign-In with better error handling
       try {
+        const youtubeConfig = PLATFORM_AUTH_CONFIG.youtube;
+        const webClientId = youtubeConfig.clientId || '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com';
+        const iosClientId = youtubeConfig.iosClientId || webClientId;
+        
         await GoogleSignin.configure({
-          webClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
-          iosClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+          webClientId: webClientId,
+          iosClientId: iosClientId,
           scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
           offlineAccess: true,
           hostedDomain: '',
           forceCodeForRefreshToken: true,
           accountName: '',
         });
-        console.log('✅ Google Sign-In configured successfully');
+        console.log('✅ Google Sign-In configured successfully with client ID:', webClientId.substring(0, 20) + '...');
       } catch (configError) {
         console.error('❌ Google Sign-In configuration failed:', configError);
         throw new Error(`Google Sign-In configuration failed: ${configError.message || configError}`);
@@ -794,9 +798,12 @@ export const updateGoogleClientIds = (config: {
     PLATFORM_AUTH_CONFIG.youtube = {
       ...PLATFORM_AUTH_CONFIG.youtube,
       clientId: config.webClientId || PLATFORM_AUTH_CONFIG.youtube.clientId,
+      iosClientId: config.iosClientId || PLATFORM_AUTH_CONFIG.youtube.iosClientId,
     };
     
     console.log('✅ Google client IDs updated successfully');
+    console.log('  - Web Client ID:', config.webClientId ? config.webClientId.substring(0, 20) + '...' : 'not provided');
+    console.log('  - iOS Client ID:', config.iosClientId ? config.iosClientId.substring(0, 20) + '...' : 'not provided');
   }
 };
 
@@ -989,23 +996,34 @@ export const disconnectPlatform = async (platform: string, username: string): Pr
 };
 
 /**
- * Store PIN for user (uses developer API key for now, should be JWT in future)
- * @param username Username
+ * Store PIN for user (uses JWT authentication and extracts username from JWT)
  * @param pin User PIN
+ * @param username Optional username (if not provided, extracts from JWT)
  * @returns Promise with result
  */
-export const storePIN = async (username: string, pin: string): Promise<{ success: boolean; error?: string }> => {
+export const storePIN = async (pin: string, username?: string): Promise<{ success: boolean; error?: string }> => {
   try {
-    console.log('🔐 Storing PIN for user:', username);
+    // Extract username from JWT if not provided
+    const userToStore = username || extractUsernameFromJWT();
+    
+    if (!userToStore) {
+      console.error('❌ No username available - either provide username or ensure JWT token is valid');
+      return {
+        success: false,
+        error: 'No username available for PIN storage'
+      };
+    }
+
+    console.log('🔐 Storing PIN for user:', userToStore);
     
-    // Make authenticated request to store PIN
+    // Make authenticated request to store PIN (using developer API key for now)
     const response = await makeDeveloperRequest('/store-pin/web', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
       },
       body: JSON.stringify({
-        username,
+        username: userToStore,
         pin
       })
     });
@@ -1013,7 +1031,7 @@ export const storePIN = async (username: string, pin: string): Promise<{ success
     const data = await response.json();
 
     if (response.ok && data.success) {
-      console.log('✅ PIN stored successfully');
+      console.log('✅ PIN stored successfully for user:', userToStore);
       return { success: true };
     } else {
       console.error('❌ Failed to store PIN:', data.error);

package/src/types/index.d.ts

@@ -243,6 +243,11 @@ declare module '@onairos/react-native' {
   // SDK Initialization Functions
   export function initializeApiKey(config: any): Promise<void>;
   export const ADMIN_API_KEY: string;
+  
+  // JWT Token Functions
+  export function extractUsernameFromJWT(token?: string): string | null;
+  export function extractUserDataFromJWT(token?: string): any;
+  export function decodeJWTPayload(token: string): any;
 
   // Programmatic Flow
   export function executeOnairosFlow(config: any): Promise<any>;

package/src/types/index.ts

@@ -211,6 +211,7 @@ export interface PlatformAuthConfig {
   authEndpoint: string;
   color: string;
   clientId?: string;
+  iosClientId?: string;
   redirectUri?: string;
   scope?: string;
   responseType?: string;

package/src/types.ts

@@ -18,6 +18,7 @@ export interface TestModeOptions {
   // Optional tweaks
   fastTraining?: boolean; // Speed up training simulation
   skipRealConnections?: boolean; // Allow mock platform connections
+  skipApiCalls?: boolean; // Skip API calls entirely (for pure UI testing)
 }
 
 export interface ApiKeyConfig {
@@ -239,6 +240,7 @@ export interface PlatformAuthConfig {
   authEndpoint: string;
   color: string;
   clientId?: string;
+  iosClientId?: string;
   redirectUri?: string;
   scope?: string;
   responseType?: string;

package/src/utils/onairosApi.ts

@@ -2,7 +2,7 @@ import { Platform } from 'react-native';
 import NetInfo from '@react-native-community/netinfo';
 import { OnairosCredentials } from './secureStorage';
 import { logDebug } from './debugHelper';
-import { getJWT, makeUserRequest, makeDeveloperRequest, isUserAuthenticated } from '../services/apiKeyService';
+import { getJWT, makeUserRequest, makeDeveloperRequest, isUserAuthenticated, extractUsernameFromJWT } from '../services/apiKeyService';
 
 // API response types
 export interface ApiResponse<T = any> {
@@ -352,16 +352,27 @@ export const updatePlatformConnections = async (
 };
 
 /**
- * Store user PIN (uses JWT)
+ * Store user PIN (uses JWT and extracts username from JWT)
  */
 export const storePIN = async (
-  username: string,
   pin: string,
-  options = { debug: false }
+  options: { debug?: boolean; username?: string } = {}
 ): Promise<ApiResponse<any>> => {
+  const { debug = false, username } = options;
+  
+  // Extract username from JWT if not provided
+  const userToStore = username || extractUsernameFromJWT();
+  
+  if (!userToStore) {
+    throw new ApiError(
+      'No username available - either provide username or ensure JWT token is valid',
+      'auth_error'
+    );
+  }
+  
   return makeUserApiRequest('store-pin/mobile', 'POST', {
-    data: { username, pin },
-    debug: options.debug,
+    data: { username: userToStore, pin },
+    debug,
   });
 };