@onairos/react-native 3.0.0 → 3.0.1

package/src/services/oauthService.ts

@@ -1,534 +1,419 @@
-import { Linking, Platform } from 'react-native';
-import { updateCredentials, OnairosCredentials } from '../utils/secureStorage';
-import { sha256 } from '../utils/crypto';
-import { onairosApi } from '../api';
-
-// Define OAuth configuration types
-export interface OAuthConfig {
-  clientId: string;
-  redirectUri: string;
-  scope: string;
-  authorizationEndpoint: string;
-  tokenEndpoint: string;
-  responseType: string;
-}
-
-// Platform-specific OAuth configurations
-const OAUTH_CONFIGS: Record<string, OAuthConfig> = {
-  instagram: {
-    clientId: 'YOUR_INSTAGRAM_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosreact://auth/instagram',
-    scope: 'user_profile,user_media',
-    authorizationEndpoint: 'https://api.instagram.com/oauth/authorize',
-    tokenEndpoint: 'https://api.instagram.com/oauth/access_token',
-    responseType: 'code',
-  },
-  youtube: {
-    clientId: 'YOUR_YOUTUBE_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosreact://auth/youtube',
-    scope: 'https://www.googleapis.com/auth/youtube.readonly',
-    authorizationEndpoint: 'https://accounts.google.com/o/oauth2/auth',
-    tokenEndpoint: 'https://oauth2.googleapis.com/token',
-    responseType: 'code',
-  },
-  pinterest: {
-    clientId: 'YOUR_PINTEREST_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosreact://auth/pinterest',
-    scope: 'boards:read,pins:read',
-    authorizationEndpoint: 'https://www.pinterest.com/oauth/',
-    tokenEndpoint: 'https://api.pinterest.com/v5/oauth/token',
-    responseType: 'code',
-  },
-  reddit: {
-    clientId: 'YOUR_REDDIT_CLIENT_ID', // Replace with actual client ID
-    redirectUri: 'onairosreact://auth/reddit',
-    scope: 'identity,read',
-    authorizationEndpoint: 'https://www.reddit.com/api/v1/authorize',
-    tokenEndpoint: 'https://www.reddit.com/api/v1/access_token',
-    responseType: 'code',
-  },
-};
-
-/**
- * Generate a state value for OAuth to prevent CSRF attacks
- */
-const generateState = (): string => {
-  const randomValue = Math.random().toString(36).substring(2, 15);
-  return sha256(randomValue).substring(0, 10);
-};
-
-/**
- * Initialize OAuth service handlers and listeners
- */
-export const initializeOAuthService = (): void => {
-  // Set up deep linking handlers for OAuth redirects
-  Linking.addEventListener('url', handleDeepLink);
-};
-
-/**
- * Clean up OAuth service handlers and listeners
- */
-export const cleanupOAuthService = (): void => {
-  // Clean up deep linking handlers
-  if (Platform.OS === 'android') {
-    Linking.removeEventListener('url', handleDeepLink);
-  }
-};
-
-// Keep track of current OAuth state and callbacks
-let currentOAuthState: string | null = null;
-let currentOAuthPlatform: string | null = null;
-let currentOAuthResolve: ((value: any) => void) | null = null;
-let currentOAuthReject: ((error: Error) => void) | null = null;
-
-/**
- * Handle deep link callbacks from OAuth providers
- */
-const handleDeepLink = async (event: { url: string }): Promise<void> => {
-  try {
-    const { url } = event;
-    
-    // Check if this is an OAuth callback URL
-    if (!url.startsWith('onairosreact://auth/')) {
-      return;
-    }
-    
-    // Extract platform from URL path
-    const platform = url.split('onairosreact://auth/')[1].split('?')[0];
-    
-    // Only handle if it matches current OAuth flow
-    if (platform !== currentOAuthPlatform) {
-      return;
-    }
-    
-    // Parse URL parameters
-    const params = new URL(url).searchParams;
-    const code = params.get('code');
-    const state = params.get('state');
-    const error = params.get('error');
-    
-    // Validate state to prevent CSRF attacks
-    if (state !== currentOAuthState) {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error('OAuth state mismatch - possible CSRF attack'));
-      }
-      return;
-    }
-    
-    // Handle errors
-    if (error) {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error(`OAuth error: ${error}`));
-      }
-      return;
-    }
-    
-    // Proceed with token exchange if code is present
-    if (code) {
-      const tokenResult = await exchangeCodeForToken(platform, code);
-      
-      if (currentOAuthResolve) {
-        currentOAuthResolve(tokenResult);
-      }
-    } else {
-      if (currentOAuthReject) {
-        currentOAuthReject(new Error('No authorization code received'));
-      }
-    }
-  } catch (error) {
-    console.error('Error handling OAuth deep link:', error);
-    if (currentOAuthReject) {
-      currentOAuthReject(error as Error);
-    }
-  } finally {
-    // Reset state
-    currentOAuthState = null;
-    currentOAuthPlatform = null;
-    currentOAuthResolve = null;
-    currentOAuthReject = null;
-  }
-};
-
-/**
- * Exchange OAuth authorization code for access token
- */
-const exchangeCodeForToken = async (platform: string, code: string): Promise<any> => {
-  try {
-    const config = OAUTH_CONFIGS[platform];
-    
-    if (!config) {
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-    
-    // Prepare token request parameters
-    const params = new URLSearchParams({
-      grant_type: 'authorization_code',
-      code,
-      redirect_uri: config.redirectUri,
-      client_id: config.clientId,
-    });
-    
-    // Exchange code for token
-    const response = await fetch(config.tokenEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: params.toString(),
-    });
-    
-    const data = await response.json();
-    
-    if (!response.ok) {
-      throw new Error(data.error || 'Failed to exchange code for token');
-    }
-    
-    // Fetch user information based on the platform
-    const userInfo = await fetchUserInfo(platform, data.access_token);
-    
-    return {
-      token: data.access_token,
-      refreshToken: data.refresh_token,
-      expiresIn: data.expires_in,
-      username: userInfo.username,
-      userId: userInfo.id,
-    };
-  } catch (error) {
-    console.error(`Error exchanging code for token (${platform}):`, error);
-    throw error;
-  }
-};
-
-/**
- * Fetch user information from the connected platform
- */
-const fetchUserInfo = async (platform: string, accessToken: string): Promise<any> => {
-  try {
-    let endpoint;
-    let headers: Record<string, string> = {
-      Authorization: `Bearer ${accessToken}`,
-    };
-    
-    // Platform-specific API endpoints for user info
-    switch (platform) {
-      case 'instagram':
-        endpoint = 'https://graph.instagram.com/me?fields=id,username';
-        break;
-      case 'youtube':
-        endpoint = 'https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true';
-        break;
-      case 'pinterest':
-        endpoint = 'https://api.pinterest.com/v5/user_account';
-        break;
-      case 'reddit':
-        endpoint = 'https://oauth.reddit.com/api/v1/me';
-        break;
-      default:
-        throw new Error(`Unsupported platform: ${platform}`);
-    }
-    
-    const response = await fetch(endpoint, { headers });
-    const data = await response.json();
-    
-    if (!response.ok) {
-      throw new Error(data.error || 'Failed to fetch user info');
-    }
-    
-    // Extract user information based on platform-specific response format
-    switch (platform) {
-      case 'instagram':
-        return { id: data.id, username: data.username };
-      case 'youtube':
-        return { 
-          id: data.items[0].id, 
-          username: data.items[0].snippet.title 
-        };
-      case 'pinterest':
-        return { 
-          id: data.id, 
-          username: data.username || data.full_name 
-        };
-      case 'reddit':
-        return { id: data.id, username: data.name };
-      default:
-        throw new Error(`Unsupported platform: ${platform}`);
-    }
-  } catch (error) {
-    console.error(`Error fetching user info (${platform}):`, error);
-    throw error;
-  }
-};
-
-/**
- * Initiate OAuth flow for a specific platform
- */
-export const connectPlatform = (platform: string): Promise<any> => {
-  return new Promise((resolve, reject) => {
-    try {
-      const config = OAUTH_CONFIGS[platform];
-      
-      if (!config) {
-        reject(new Error(`Unsupported platform: ${platform}`));
-        return;
-      }
-      
-      // Generate and save state for CSRF protection
-      const state = generateState();
-      currentOAuthState = state;
-      currentOAuthPlatform = platform;
-      currentOAuthResolve = resolve;
-      currentOAuthReject = reject;
-      
-      // Build OAuth URL
-      const authUrl = new URL(config.authorizationEndpoint);
-      authUrl.searchParams.append('client_id', config.clientId);
-      authUrl.searchParams.append('redirect_uri', config.redirectUri);
-      authUrl.searchParams.append('response_type', config.responseType);
-      authUrl.searchParams.append('scope', config.scope);
-      authUrl.searchParams.append('state', state);
-      
-      // Open browser to start OAuth flow
-      Linking.openURL(authUrl.toString());
-    } catch (error) {
-      reject(error);
-      
-      // Reset state on error
-      currentOAuthState = null;
-      currentOAuthPlatform = null;
-      currentOAuthResolve = null;
-      currentOAuthReject = null;
-    }
-  });
-};
-
-/**
- * Disconnect a platform by removing its credentials
- */
-export const disconnectPlatform = async (
-  platform: string, 
-  credentials: OnairosCredentials
-): Promise<boolean> => {
-  try {
-    if (!credentials.platforms) {
-      return false;
-    }
-    
-    // Create new credentials object with the platform removed
-    const updatedPlatforms = { ...credentials.platforms };
-    delete updatedPlatforms[platform as keyof typeof updatedPlatforms];
-    
-    // Update stored credentials
-    const result = await updateCredentials({
-      platforms: updatedPlatforms,
-    });
-    
-    return result;
-  } catch (error) {
-    console.error(`Error disconnecting platform (${platform}):`, error);
-    return false;
-  }
-};
-
-/**
- * Store platform connection in credentials
- */
-export const storePlatformConnection = async (
-  platform: string,
-  connectionData: any,
-  credentials: OnairosCredentials
-): Promise<boolean> => {
-  try {
-    // Create updated platforms object
-    const updatedPlatforms = {
-      ...credentials.platforms,
-      [platform]: {
-        token: connectionData.token,
-        username: connectionData.username,
-        userId: connectionData.userId,
-      },
-    };
-    
-    // Update stored credentials
-    const result = await updateCredentials({
-      platforms: updatedPlatforms,
-    });
-    
-    return result;
-  } catch (error) {
-    console.error(`Error storing platform connection (${platform}):`, error);
-    return false;
-  }
-};
-
-export interface AuthorizationData {
-  accountName: string;
-  authUrl: string;
-}
-
-export interface PlatformConnectionResult {
-  success: boolean;
-  userName?: string;
-  error?: string;
-}
-
-/**
- * Service for handling OAuth connections to various platforms
- */
-export const OAuthService = {
-  // Base API URL
-  _apiBaseUrl: 'https://api2.onairos.uk',
-  
-  /**
-   * Connect to a specific platform using OAuth
-   * @param platform The platform to connect to (e.g., 'instagram', 'youtube')
-   * @returns A promise that resolves to a connection result
-   */
-  connectPlatform: async (platform: string): Promise<PlatformConnectionResult> => {
-    try {
-      console.log(`[OAuth] Initiating connection to ${platform}`);
-      
-      // Get authorization data from API
-      const authData = await OAuthService._getAuthorizationData(platform);
-      
-      if (!authData || !authData.accountName) {
-        throw new Error(`Failed to get authorization data for ${platform}`);
-      }
-      
-      // Launch the OAuth flow in a WebView
-      const success = await OAuthService._launchOAuthFlow(
-        platform,
-        `${OAuthService._apiBaseUrl}/${authData.accountName}/authorize`,
-        `onairos://${platform.toLowerCase()}/callback`
-      );
-      
-      return {
-        success,
-        userName: success ? `User_${platform}` : undefined,
-        error: success ? undefined : `Failed to connect to ${platform}`
-      };
-    } catch (error) {
-      console.error(`${platform} connection error:`, error);
-      return { 
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  },
-  
-  /**
-   * Get authorization data for a platform from the API
-   * @param platform The platform to get authorization data for
-   * @returns Authorization data for the platform
-   */
-  _getAuthorizationData: async (platform: string): Promise<AuthorizationData> => {
-    try {
-      // For testing, we can use a mock app ID
-      let appId = 'com.onairos.mock';
-      
-      // In real implementation, we would get this from the app's package info
-      try {
-        // This would normally use react-native-device-info or similar
-        // appId = await DeviceInfo.getBundleId();
-      } catch (e) {
-        console.warn('Failed to get app identifier:', e);
-      }
-      
-      const response = await onairosApi.post('getOAuthData', {
-        platform,
-        appId: appId,
-        redirectUri: `onairos://${platform.toLowerCase()}/callback`,
-      });
-      
-      if (response && response.accountName) {
-        return {
-          accountName: response.accountName,
-          authUrl: `${OAuthService._apiBaseUrl}/${response.accountName}/authorize`,
-        };
-      } else {
-        throw new Error('Invalid response from getOAuthData');
-      }
-    } catch (error) {
-      console.error('Error getting authorization data:', error);
-      throw error;
-    }
-  },
-  
-  /**
-   * Launch the OAuth flow for a platform
-   * @param platform The platform to launch the OAuth flow for
-   * @param authUrl The URL to authorize with
-   * @param callbackUrlPattern The URL pattern to expect as a callback
-   * @returns A promise that resolves to true if the connection was successful
-   */
-  _launchOAuthFlow: async (
-    platform: string, 
-    authUrl: string, 
-    callbackUrlPattern: string
-  ): Promise<boolean> => {
-    try {
-      console.log(`[OAuth] Opening URL for ${platform}: ${authUrl}`);
-      
-      // For now, we'll use a simpler approach just to mock the flow
-      // In a real implementation, this would open a WebView in a modal
-      // and handle the OAuth callback
-      
-      // Check if we can open the URL
-      const canOpen = await Linking.canOpenURL(authUrl);
-      
-      if (!canOpen) {
-        throw new Error(`Cannot open URL: ${authUrl}`);
-      }
-      
-      // We'll simulate a successful connection after a delay
-      // In a real app, this would be handled by the WebView navigation
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      // Return success
-      return true;
-    } catch (error) {
-      console.error(`Error launching OAuth flow for ${platform}:`, error);
-      return false;
-    }
-  },
-  
-  /**
-   * Handle an OAuth callback URL
-   * @param url The callback URL to handle
-   * @returns The result of processing the callback
-   */
-  handleCallback: async (url: string): Promise<PlatformConnectionResult> => {
-    try {
-      console.log(`[OAuth] Handling callback URL: ${url}`);
-      
-      // Extract the platform and parameters from the URL
-      const urlParts = url.split('/');
-      const platform = urlParts[2]; // Assuming format is onairos://platform/callback
-      
-      // Extract query parameters
-      const params = new URLSearchParams(url.split('?')[1] || '');
-      const code = params.get('code');
-      
-      if (!code) {
-        return { 
-          success: false,
-          error: 'No authorization code found in callback URL'
-        };
-      }
-      
-      // In a real implementation, we would send the code to the API
-      // to get an access token
-      
-      // Simulate a successful connection
-      return { 
-        success: true,
-        userName: `User_${platform}` 
-      };
-    } catch (error) {
-      console.error('Error handling OAuth callback:', error);
-      return { 
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  }
-};
+import { Linking, Platform } from 'react-native';
+import { updateCredentials, OnairosCredentials } from '../utils/secureStorage';
+import { sha256 } from '../utils/crypto';
+import { onairosApi } from '../api';
+
+// Define OAuth configuration types
+export interface OAuthConfig {
+  clientId: string;
+  redirectUri: string;
+  scope: string;
+  authorizationEndpoint: string;
+  tokenEndpoint: string;
+  responseType: string;
+}
+
+// Platform-specific OAuth configurations
+const OAUTH_CONFIGS: Record<string, OAuthConfig> = {
+  instagram: {
+    clientId: 'YOUR_INSTAGRAM_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/instagram',
+    scope: 'user_profile,user_media',
+    authorizationEndpoint: 'https://api.instagram.com/oauth/authorize',
+    tokenEndpoint: 'https://api.instagram.com/oauth/access_token',
+    responseType: 'code',
+  },
+  youtube: {
+    clientId: 'YOUR_YOUTUBE_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/youtube',
+    scope: 'https://www.googleapis.com/auth/youtube.readonly',
+    authorizationEndpoint: 'https://accounts.google.com/o/oauth2/auth',
+    tokenEndpoint: 'https://oauth2.googleapis.com/token',
+    responseType: 'code',
+  },
+  pinterest: {
+    clientId: 'YOUR_PINTEREST_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/pinterest',
+    scope: 'boards:read,pins:read',
+    authorizationEndpoint: 'https://www.pinterest.com/oauth/',
+    tokenEndpoint: 'https://api.pinterest.com/v5/oauth/token',
+    responseType: 'code',
+  },
+  reddit: {
+    clientId: 'YOUR_REDDIT_CLIENT_ID', // Replace with actual client ID
+    redirectUri: 'onairosreact://auth/reddit',
+    scope: 'identity,read',
+    authorizationEndpoint: 'https://www.reddit.com/api/v1/authorize',
+    tokenEndpoint: 'https://www.reddit.com/api/v1/access_token',
+    responseType: 'code',
+  },
+};
+
+/**
+ * Generate a state value for OAuth to prevent CSRF attacks
+ */
+const generateState = (): string => {
+  const randomValue = Math.random().toString(36).substring(2, 15);
+  return sha256(randomValue).substring(0, 10);
+};
+
+/**
+ * Initialize OAuth service handlers and listeners
+ */
+export const initializeOAuthService = (): void => {
+  // Set up deep linking handlers for OAuth redirects
+  Linking.addEventListener('url', handleDeepLink);
+};
+
+/**
+ * Clean up OAuth service handlers and listeners
+ */
+export const cleanupOAuthService = (): void => {
+  // Use the modern React Native Linking API
+  if (typeof Linking.removeAllListeners === 'function') {
+    Linking.removeAllListeners('url');
+  }
+};
+
+// Keep track of current OAuth state and callbacks
+let currentOAuthState: string | null = null;
+let currentOAuthPlatform: string | null = null;
+let currentOAuthResolve: ((value: any) => void) | null = null;
+let currentOAuthReject: ((error: Error) => void) | null = null;
+
+/**
+ * Handle deep link callbacks from OAuth providers
+ */
+const handleDeepLink = async (event: { url: string }): Promise<void> => {
+  try {
+    const { url } = event;
+    
+    // Check if this is an OAuth callback URL
+    if (!url.startsWith('onairosreact://auth/')) {
+      return;
+    }
+    
+    // Extract platform from URL path
+    const platform = url.split('onairosreact://auth/')[1].split('?')[0];
+    
+    // Only handle if it matches current OAuth flow
+    if (platform !== currentOAuthPlatform) {
+      return;
+    }
+    
+    // Parse URL parameters
+    const params = new URL(url).searchParams;
+    const code = params.get('code');
+    const state = params.get('state');
+    const error = params.get('error');
+    
+    // Validate state to prevent CSRF attacks
+    if (state !== currentOAuthState) {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error('OAuth state mismatch - possible CSRF attack'));
+      }
+      return;
+    }
+    
+    // Handle errors
+    if (error) {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error(`OAuth error: ${error}`));
+      }
+      return;
+    }
+    
+    // Proceed with token exchange if code is present
+    if (code) {
+      const tokenResult = await exchangeCodeForToken(platform, code);
+      
+      if (currentOAuthResolve) {
+        currentOAuthResolve(tokenResult);
+      }
+    } else {
+      if (currentOAuthReject) {
+        currentOAuthReject(new Error('No authorization code received'));
+      }
+    }
+  } catch (error) {
+    console.error('Error handling OAuth deep link:', error);
+    if (currentOAuthReject) {
+      currentOAuthReject(error as Error);
+    }
+  } finally {
+    // Reset state
+    currentOAuthState = null;
+    currentOAuthPlatform = null;
+    currentOAuthResolve = null;
+    currentOAuthReject = null;
+  }
+};
+
+/**
+ * Exchange OAuth authorization code for access token
+ */
+const exchangeCodeForToken = async (platform: string, code: string): Promise<any> => {
+  try {
+    const config = OAUTH_CONFIGS[platform];
+    
+    if (!config) {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+    
+    // Prepare token request parameters
+    const params = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      redirect_uri: config.redirectUri,
+      client_id: config.clientId,
+    });
+    
+    // Exchange code for token
+    const response = await fetch(config.tokenEndpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: params.toString(),
+    });
+    
+    const data = await response.json();
+    
+    if (!response.ok) {
+      throw new Error(data.error || 'Failed to exchange code for token');
+    }
+    
+    // Fetch user information based on the platform
+    const userInfo = await fetchUserInfo(platform, data.access_token);
+    
+    return {
+      token: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresIn: data.expires_in,
+      username: userInfo.username,
+      userId: userInfo.id,
+    };
+  } catch (error) {
+    console.error(`Error exchanging code for token (${platform}):`, error);
+    throw error;
+  }
+};
+
+/**
+ * Fetch user information from the connected platform
+ */
+const fetchUserInfo = async (platform: string, accessToken: string): Promise<any> => {
+  try {
+    let endpoint;
+    let headers: Record<string, string> = {
+      Authorization: `Bearer ${accessToken}`,
+    };
+    
+    // Platform-specific API endpoints for user info
+    switch (platform) {
+      case 'instagram':
+        endpoint = 'https://graph.instagram.com/me?fields=id,username';
+        break;
+      case 'youtube':
+        endpoint = 'https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true';
+        break;
+      case 'pinterest':
+        endpoint = 'https://api.pinterest.com/v5/user_account';
+        break;
+      case 'reddit':
+        endpoint = 'https://oauth.reddit.com/api/v1/me';
+        break;
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+    
+    const response = await fetch(endpoint, { headers });
+    const data = await response.json();
+    
+    if (!response.ok) {
+      throw new Error(data.error || 'Failed to fetch user info');
+    }
+    
+    // Extract user information based on platform-specific response format
+    switch (platform) {
+      case 'instagram':
+        return { id: data.id, username: data.username };
+      case 'youtube':
+        return { 
+          id: data.items[0].id, 
+          username: data.items[0].snippet.title 
+        };
+      case 'pinterest':
+        return { 
+          id: data.id, 
+          username: data.username || data.full_name 
+        };
+      case 'reddit':
+        return { id: data.id, username: data.name };
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+  } catch (error) {
+    console.error(`Error fetching user info (${platform}):`, error);
+    throw error;
+  }
+};
+
+/**
+ * Connect to a platform using OAuth
+ */
+export const connectPlatform = (platform: string): Promise<any> => {
+  return new Promise((resolve, reject) => {
+    try {
+      const config = OAUTH_CONFIGS[platform];
+      
+      if (!config) {
+        throw new Error(`Unsupported platform: ${platform}`);
+      }
+      
+      // Generate state for CSRF protection
+      const state = generateState();
+      
+      // Build authorization URL
+      const authUrl = new URL(config.authorizationEndpoint);
+      authUrl.searchParams.append('client_id', config.clientId);
+      authUrl.searchParams.append('redirect_uri', config.redirectUri);
+      authUrl.searchParams.append('response_type', config.responseType);
+      authUrl.searchParams.append('scope', config.scope);
+      authUrl.searchParams.append('state', state);
+      
+      // Set up current OAuth state for callback handling
+      currentOAuthState = state;
+      currentOAuthPlatform = platform;
+      currentOAuthResolve = resolve;
+      currentOAuthReject = reject;
+      
+      // Open browser or WebView to the authorization URL
+      Linking.openURL(authUrl.toString());
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+/**
+ * Disconnect from a platform
+ */
+export const disconnectPlatform = async (
+  platform: string, 
+  credentials: OnairosCredentials
+): Promise<boolean> => {
+  try {
+    // Call Onairos API to disconnect platform
+    await onairosApi.post('/users/disconnect-platform', {
+      platform,
+      username: credentials.username,
+    });
+    
+    // Update local credentials to remove platform
+    const updatedPlatforms = { ...credentials.platforms };
+    
+    // Type-safe platform removal using keyof operator
+    if (updatedPlatforms && platform in updatedPlatforms) {
+      delete updatedPlatforms[platform as keyof typeof updatedPlatforms];
+    }
+    
+    await updateCredentials({
+      ...credentials,
+      platforms: updatedPlatforms,
+    });
+    
+    return true;
+  } catch (error) {
+    console.error(`Error disconnecting platform (${platform}):`, error);
+    return false;
+  }
+};
+
+/**
+ * Store platform connection data in user credentials
+ */
+export const storePlatformConnection = async (
+  platform: string,
+  connectionData: any,
+  credentials: OnairosCredentials
+): Promise<boolean> => {
+  try {
+    // Only accept valid platform types
+    const validPlatform = (
+      platform === 'instagram' || 
+      platform === 'youtube' || 
+      platform === 'pinterest' || 
+      platform === 'reddit'
+    );
+    
+    if (!validPlatform) {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+    
+    // Update platforms in credentials with type safety
+    const updatedPlatforms = {
+      ...credentials.platforms,
+    };
+    
+    // Type-safe assignment 
+    const platformData = {
+      username: connectionData.username,
+      userId: connectionData.userId,
+      token: connectionData.token,
+      refreshToken: connectionData.refreshToken,
+      expiresAt: connectionData.expiresIn ? 
+        Date.now() + (connectionData.expiresIn * 1000) : 
+        null,
+      connectedAt: Date.now(),
+    };
+    
+    // Assign platform data based on platform type
+    if (platform === 'instagram') updatedPlatforms.instagram = platformData;
+    else if (platform === 'youtube') updatedPlatforms.youtube = platformData;
+    else if (platform === 'pinterest') updatedPlatforms.pinterest = platformData;
+    else if (platform === 'reddit') updatedPlatforms.reddit = platformData;
+    
+    // Update stored credentials
+    await updateCredentials({
+      ...credentials,
+      platforms: updatedPlatforms,
+    });
+    
+    return true;
+  } catch (error) {
+    console.error(`Error storing platform connection (${platform}):`, error);
+    return false;
+  }
+};
+
+export interface AuthorizationData {
+  accountName: string;
+  authUrl: string;
+}
+
+export interface PlatformConnectionResult {
+  success: boolean;
+  userName?: string;
+  error?: string;
+}
+
+/**
+ * Service for handling OAuth connections to various platforms
+ */
+export const OAuthService = {
+  initializeOAuthService,
+  cleanupOAuthService,
+  connectPlatform,
+  disconnectPlatform,
+  storePlatformConnection,
+  // Base API URL
+  _apiBaseUrl: 'https://api2.onairos.uk',
+};
+
+/**
+ * Re-export from oauthService.ts with correct capitalization
+ * This file exists to solve the casing issue in imports
+ */
+
+export * from './oauthService';