@onairos/react-native 3.0.2 → 3.0.5

package/src/services/oauthService.ts

@@ -1,419 +1,412 @@
-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'; 
+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: 'onairosanime://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: 'onairosanime://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: 'onairosanime://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: 'onairosanime://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('onairosanime://auth/')) {
+      return;
+    }
+    
+    // Extract platform from URL path
+    const platform = url.split('onairosanime://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',
+};