@trainon-inc/capacitor-clerk-native 1.22.0 → 1.24.0

package/README.md

@@ -339,19 +339,21 @@ function Profile() {
 └─────────────────────────────────────────────────┘
 ```
 
-### Android Architecture
+### Android Architecture (Web Provider)
 
 ```
 ┌─────────────────────────────────────────────────┐
 │  JavaScript/React (Capacitor WebView)           │
-│  - Uses capacitor-clerk-native hooks            │
-└─────────────────┬───────────────────────────────┘
-                  │ Capacitor Bridge
-┌─────────────────▼───────────────────────────────┐
-│  ClerkNativePlugin (Gradle Module)              │
-│  - Android library module                       │
-│  - Receives calls from JavaScript               │
-│  - Can integrate with Clerk Android SDK         │
+│  - Uses @clerk/clerk-react (web provider)       │
+│  - Full Clerk functionality via web SDK         │
+└─────────────────────────────────────────────────┘
+         (No native plugin needed for auth)
+
+┌─────────────────────────────────────────────────┐
+│  ClerkNativePlugin (Gradle Module) - Stub       │
+│  - Exists for Capacitor plugin registration     │
+│  - Returns "use web provider" for all methods   │
+│  - No native Clerk SDK dependency               │
 └─────────────────────────────────────────────────┘
 ```
 
@@ -414,80 +416,51 @@ function Profile() {
 
 ## Android Setup
 
-Android is fully supported with the native Clerk Android SDK integration. Unlike iOS, Android doesn't require a bridge pattern - the plugin directly integrates with the Clerk Android SDK.
-
-### Prerequisites
-
-- ✅ A [Clerk account](https://dashboard.clerk.com/sign-up)
-- ✅ A Clerk application set up in the dashboard
-- ✅ **Native API enabled** in Clerk Dashboard → Settings → Native Applications
-- ✅ Android Studio with Gradle 8.7+ and AGP 8.5+
-- ✅ JDK 17 or higher
-
-### 1. Register Your Android App with Clerk
-
-1. Go to the [**Native Applications**](https://dashboard.clerk.com/last-active?path=native-applications) page in Clerk Dashboard
-2. Click **"Add Application"**
-3. Select **Android** tab
-4. Enter your Android app details:
-   - **Package Name**: Your app's package name (e.g., `com.trainon.member`)
-   - **SHA256 Fingerprint**: Your app's signing certificate fingerprint (get it with `./gradlew signingReport`)
-
-### 2. Sync Capacitor
-
-After installing the plugin, sync your Android project:
+**Important**: On Android, this plugin provides a stub implementation. Android WebViews work well with web-based authentication (unlike iOS which has cookie issues), so **Android should use the web Clerk provider (`@clerk/clerk-react`)** instead of the native plugin.
 
-```bash
-npx cap sync android
-```
+### Why Web Provider for Android?
 
-This will:
-- Add the plugin to `capacitor.settings.gradle`
-- Add the plugin dependency to `capacitor.build.gradle`
-- Include the Clerk Android SDK automatically
+- ✅ Android WebViews handle cookies correctly - no authentication issues
+- ✅ The Clerk Android SDK is still in early stages (v0.1.x) with evolving APIs
+- ✅ Using `@clerk/clerk-react` provides a stable, well-tested experience
+- ✅ Simpler setup - no native configuration required
 
-### 3. Configure Clerk in Your App
+### Recommended App Setup
 
-The plugin automatically handles Clerk initialization when you call `configure()` from JavaScript. No additional Android-specific setup is required!
+Configure your app to use the native plugin only on iOS:
 
 ```typescript
-import { ClerkNative } from '@trainon-inc/capacitor-clerk-native';
-
-// Configure Clerk (call once at app startup)
-await ClerkNative.configure({
-  publishableKey: 'pk_test_your_clerk_key_here'
-});
+import { Capacitor } from "@capacitor/core";
+import { ClerkProvider as WebClerkProvider } from "@clerk/clerk-react";
+import { ClerkProvider as NativeClerkProvider } from "@trainon-inc/capacitor-clerk-native";
+
+// Use native Clerk only on iOS (due to WebView cookie issues)
+// Android WebViews work fine with web Clerk
+const isIOS = Capacitor.getPlatform() === "ios";
+const ClerkProvider = isIOS ? NativeClerkProvider : WebClerkProvider;
+
+export function App() {
+  const clerkProps = isIOS
+    ? { publishableKey: "pk_test_..." }
+    : {
+        publishableKey: "pk_test_...",
+        signInFallbackRedirectUrl: "/home",
+        signUpFallbackRedirectUrl: "/home",
+      };
 
-// Load and check for existing session
-const { user } = await ClerkNative.load();
+  return (
+    <ClerkProvider {...clerkProps}>
+      <YourApp />
+    </ClerkProvider>
+  );
+}
 ```
 
-### 4. Plugin Features
-
-The Android implementation supports all authentication methods:
-
-| Method | Description |
-|--------|-------------|
-| `configure()` | Initialize Clerk with publishable key |
-| `load()` | Load Clerk and check for existing session |
-| `signInWithPassword()` | Sign in with email and password |
-| `signInWithEmail()` | Start email code sign in flow |
-| `verifyEmailCode()` | Verify email code |
-| `signUp()` | Create a new account |
-| `verifySignUpEmail()` | Verify sign up email |
-| `getUser()` | Get current user |
-| `getToken()` | Get authentication token |
-| `signOut()` | Sign out current user |
-| `updateUser()` | Update user profile |
-| `requestPasswordReset()` | Request password reset |
-| `resetPassword()` | Reset password with code |
-| `refreshSession()` | Refresh session token |
-
-### 5. Build Requirements
+### Build Requirements
 
 - **Gradle**: 8.11.1+
-- **Android Gradle Plugin**: 8.7.2+
-- **Java/Kotlin**: 17+
+- **Android Gradle Plugin**: 8.5.0+
+- **Java**: 17+
 - **Min SDK**: 23 (Android 6.0)
 - **Target SDK**: 35 (Android 15)
 
@@ -499,14 +472,14 @@ Could not resolve project :trainon-inc-capacitor-clerk-native
 No matching variant of project was found. No variants exist.
 ```
 
-**Solution**: Ensure you have the latest version of the plugin which includes the required build files:
+**Solution**: Update to the latest plugin version:
 ```bash
 npm update @trainon-inc/capacitor-clerk-native
 npx cap sync android
 ```
 
 #### "invalid source release: 21" error
-The plugin uses Java 17 by default. Ensure your Android Studio uses JDK 17+:
+The plugin uses Java 17. Ensure your Android Studio uses JDK 17+:
 - **File → Project Structure → SDK Location → Gradle JDK** → Select JDK 17+
 
 #### Gradle sync fails
@@ -514,12 +487,6 @@ The plugin uses Java 17 by default. Ensure your Android Studio uses JDK 17+:
 - Invalidate caches: **File → Invalidate Caches / Restart**
 - Delete `.gradle` folder and re-sync
 
-#### Network errors
-Ensure INTERNET permission is in your `AndroidManifest.xml`:
-```xml
-<uses-permission android:name="android.permission.INTERNET" />
-```
-
 ## Contributing
 
 Contributions are welcome! This plugin was created to solve a real problem we encountered, and we'd love to make it better.

package/android/build.gradle

@@ -3,7 +3,6 @@ ext {
     androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
     androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
     androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
-    kotlinVersion = project.hasProperty('kotlinVersion') ? rootProject.ext.kotlinVersion : '1.9.25'
 }
 
 buildscript {
@@ -13,12 +12,10 @@ buildscript {
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:8.7.2'
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25"
     }
 }
 
 apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
 
 android {
     namespace "com.trainon.capacitor.clerk"
@@ -43,9 +40,6 @@ android {
         sourceCompatibility JavaVersion.VERSION_17
         targetCompatibility JavaVersion.VERSION_17
     }
-    kotlinOptions {
-        jvmTarget = '17'
-    }
 }
 
 repositories {
@@ -58,14 +52,9 @@ dependencies {
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     
-    // Kotlin
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
-    
-    // Clerk Android SDK
-    implementation "com.clerk:clerk-android:0.8.0"
+    // OkHttp for making HTTP requests to Clerk API
+    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
     
-    // Testing
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

package/android/src/main/java/com/trainon/capacitor/clerk/ClerkNativePlugin.java

@@ -0,0 +1,558 @@
+package com.trainon.capacitor.clerk;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+/**
+ * Android implementation of Clerk Native plugin.
+ * 
+ * Makes HTTP requests directly to Clerk's Frontend API, bypassing WebView origin restrictions.
+ * This allows the custom Clerk proxy domain to work on Android.
+ */
+@CapacitorPlugin(name = "ClerkNative")
+public class ClerkNativePlugin extends Plugin {
+
+    private static final String TAG = "ClerkNativePlugin";
+    private static final String PREFS_NAME = "ClerkNativePrefs";
+    private static final String PREF_SESSION_TOKEN = "session_token";
+    private static final String PREF_CLIENT_TOKEN = "client_token";
+    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
+
+    private OkHttpClient client;
+    private ExecutorService executor;
+    private String publishableKey;
+    private String clerkDomain;
+    private String clientToken;
+    private String sessionToken;
+    private JSONObject currentUser;
+
+    @Override
+    public void load() {
+        super.load();
+        client = new OkHttpClient();
+        executor = Executors.newSingleThreadExecutor();
+        
+        // Load saved tokens
+        SharedPreferences prefs = getContext().getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        clientToken = prefs.getString(PREF_CLIENT_TOKEN, null);
+        sessionToken = prefs.getString(PREF_SESSION_TOKEN, null);
+    }
+
+    private void saveTokens() {
+        SharedPreferences prefs = getContext().getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = prefs.edit();
+        editor.putString(PREF_CLIENT_TOKEN, clientToken);
+        editor.putString(PREF_SESSION_TOKEN, sessionToken);
+        editor.apply();
+    }
+
+    private void clearTokens() {
+        clientToken = null;
+        sessionToken = null;
+        currentUser = null;
+        SharedPreferences prefs = getContext().getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        prefs.edit().clear().apply();
+    }
+
+    private String getClerkApiUrl(String path) {
+        return "https://" + clerkDomain + path;
+    }
+
+    private Request.Builder createRequestBuilder(String url) {
+        Request.Builder builder = new Request.Builder()
+            .url(url)
+            .header("Content-Type", "application/json")
+            .header("Authorization", publishableKey)
+            .header("Origin", "https://app.trainonapp.com")  // Spoof origin to match web
+            .header("User-Agent", "Mozilla/5.0 (Linux; Android) ClerkNative/1.0");
+        
+        if (clientToken != null) {
+            builder.header("Cookie", "__client=" + clientToken);
+        }
+        
+        return builder;
+    }
+
+    @PluginMethod
+    public void configure(PluginCall call) {
+        publishableKey = call.getString("publishableKey");
+        
+        if (publishableKey == null || publishableKey.isEmpty()) {
+            call.reject("Publishable key is required");
+            return;
+        }
+
+        // Extract domain from publishable key (base64 decode)
+        try {
+            String decoded = new String(android.util.Base64.decode(
+                publishableKey.replace("pk_live_", "").replace("pk_test_", ""),
+                android.util.Base64.DEFAULT
+            ));
+            // Remove trailing $ if present
+            clerkDomain = decoded.replace("$", "").trim();
+            Log.d(TAG, "Configured with domain: " + clerkDomain);
+        } catch (Exception e) {
+            // Fallback to default domain
+            clerkDomain = "clerk.trainonapp.com";
+            Log.w(TAG, "Could not decode domain from key, using default: " + clerkDomain);
+        }
+
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void load(PluginCall call) {
+        executor.execute(() -> {
+            try {
+                // First, get or create a client
+                if (clientToken == null) {
+                    createClient(call);
+                } else {
+                    // Verify existing session
+                    fetchClientAndUser(call);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Load error", e);
+                call.reject("Failed to load: " + e.getMessage());
+            }
+        });
+    }
+
+    private void createClient(PluginCall call) throws IOException, JSONException {
+        String url = getClerkApiUrl("/v1/client?_clerk_js_version=5.117.0");
+        
+        Request request = createRequestBuilder(url)
+            .post(RequestBody.create("{}", JSON))
+            .build();
+
+        try (Response response = client.newCall(request).execute()) {
+            String body = response.body().string();
+            Log.d(TAG, "Create client response: " + response.code());
+            
+            if (!response.isSuccessful()) {
+                call.reject("Failed to create client: " + response.code() + " - " + body);
+                return;
+            }
+
+            JSONObject json = new JSONObject(body);
+            JSONObject responseObj = json.optJSONObject("response");
+            
+            if (responseObj != null) {
+                clientToken = responseObj.optString("id", null);
+                
+                // Check for active session
+                JSONArray sessions = responseObj.optJSONArray("sessions");
+                if (sessions != null && sessions.length() > 0) {
+                    JSONObject session = sessions.getJSONObject(0);
+                    sessionToken = session.optString("last_active_token", null);
+                    currentUser = session.optJSONObject("user");
+                }
+                
+                saveTokens();
+            }
+
+            JSObject result = new JSObject();
+            if (currentUser != null) {
+                result.put("user", convertUser(currentUser));
+            } else {
+                result.put("user", JSObject.NULL);
+            }
+            call.resolve(result);
+        }
+    }
+
+    private void fetchClientAndUser(PluginCall call) throws IOException, JSONException {
+        String url = getClerkApiUrl("/v1/client?_clerk_js_version=5.117.0");
+        
+        Request request = createRequestBuilder(url)
+            .get()
+            .build();
+
+        try (Response response = client.newCall(request).execute()) {
+            String body = response.body().string();
+            Log.d(TAG, "Fetch client response: " + response.code());
+            
+            if (!response.isSuccessful()) {
+                // Token might be invalid, clear and retry
+                clearTokens();
+                createClient(call);
+                return;
+            }
+
+            JSONObject json = new JSONObject(body);
+            JSONObject responseObj = json.optJSONObject("response");
+            
+            if (responseObj != null) {
+                // Check for active session
+                JSONArray sessions = responseObj.optJSONArray("sessions");
+                if (sessions != null && sessions.length() > 0) {
+                    JSONObject session = sessions.getJSONObject(0);
+                    JSONObject lastToken = session.optJSONObject("last_active_token");
+                    if (lastToken != null) {
+                        sessionToken = lastToken.optString("jwt", null);
+                    }
+                    currentUser = session.optJSONObject("user");
+                }
+                
+                saveTokens();
+            }
+
+            JSObject result = new JSObject();
+            if (currentUser != null) {
+                result.put("user", convertUser(currentUser));
+            } else {
+                result.put("user", JSObject.NULL);
+            }
+            call.resolve(result);
+        }
+    }
+
+    @PluginMethod
+    public void signInWithPassword(PluginCall call) {
+        String email = call.getString("email");
+        String password = call.getString("password");
+
+        if (email == null || password == null) {
+            call.reject("Email and password are required");
+            return;
+        }
+
+        executor.execute(() -> {
+            try {
+                // Step 1: Create sign-in attempt
+                String createUrl = getClerkApiUrl("/v1/client/sign_ins?_clerk_js_version=5.117.0");
+                
+                JSONObject createBody = new JSONObject();
+                createBody.put("identifier", email);
+                
+                Request createRequest = createRequestBuilder(createUrl)
+                    .post(RequestBody.create(createBody.toString(), JSON))
+                    .build();
+
+                String signInId;
+                try (Response response = client.newCall(createRequest).execute()) {
+                    String body = response.body().string();
+                    Log.d(TAG, "Create sign-in response: " + response.code());
+                    
+                    if (!response.isSuccessful()) {
+                        call.reject("Failed to start sign in: " + body);
+                        return;
+                    }
+
+                    JSONObject json = new JSONObject(body);
+                    JSONObject responseObj = json.optJSONObject("response");
+                    signInId = responseObj.optString("id");
+                    
+                    // Update client token from response
+                    JSONObject clientObj = json.optJSONObject("client");
+                    if (clientObj != null) {
+                        clientToken = clientObj.optString("id", clientToken);
+                    }
+                }
+
+                // Step 2: Attempt with password
+                String attemptUrl = getClerkApiUrl("/v1/client/sign_ins/" + signInId + "/attempt_first_factor?_clerk_js_version=5.117.0");
+                
+                JSONObject attemptBody = new JSONObject();
+                attemptBody.put("strategy", "password");
+                attemptBody.put("password", password);
+                
+                Request attemptRequest = createRequestBuilder(attemptUrl)
+                    .post(RequestBody.create(attemptBody.toString(), JSON))
+                    .build();
+
+                try (Response response = client.newCall(attemptRequest).execute()) {
+                    String body = response.body().string();
+                    Log.d(TAG, "Attempt password response: " + response.code());
+                    
+                    if (!response.isSuccessful()) {
+                        JSONObject errorJson = new JSONObject(body);
+                        JSONArray errors = errorJson.optJSONArray("errors");
+                        if (errors != null && errors.length() > 0) {
+                            String message = errors.getJSONObject(0).optString("message", "Sign in failed");
+                            call.reject(message);
+                        } else {
+                            call.reject("Sign in failed: " + body);
+                        }
+                        return;
+                    }
+
+                    JSONObject json = new JSONObject(body);
+                    
+                    // Extract session and user from response
+                    JSONObject clientObj = json.optJSONObject("client");
+                    if (clientObj != null) {
+                        clientToken = clientObj.optString("id", clientToken);
+                        
+                        JSONArray sessions = clientObj.optJSONArray("sessions");
+                        if (sessions != null && sessions.length() > 0) {
+                            JSONObject session = sessions.getJSONObject(0);
+                            JSONObject lastToken = session.optJSONObject("last_active_token");
+                            if (lastToken != null) {
+                                sessionToken = lastToken.optString("jwt", null);
+                            }
+                            currentUser = session.optJSONObject("user");
+                        }
+                    }
+                    
+                    saveTokens();
+
+                    JSObject result = new JSObject();
+                    if (currentUser != null) {
+                        result.put("user", convertUser(currentUser));
+                    } else {
+                        result.put("user", JSObject.NULL);
+                    }
+                    call.resolve(result);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Sign in error", e);
+                call.reject("Sign in failed: " + e.getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void getUser(PluginCall call) {
+        JSObject result = new JSObject();
+        if (currentUser != null) {
+            try {
+                result.put("user", convertUser(currentUser));
+            } catch (JSONException e) {
+                result.put("user", JSObject.NULL);
+            }
+        } else {
+            result.put("user", JSObject.NULL);
+        }
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void getToken(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("token", sessionToken != null ? sessionToken : JSObject.NULL);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void signOut(PluginCall call) {
+        if (clientToken == null) {
+            clearTokens();
+            call.resolve();
+            return;
+        }
+
+        executor.execute(() -> {
+            try {
+                String url = getClerkApiUrl("/v1/client/sessions?_clerk_js_version=5.117.0");
+                
+                Request request = createRequestBuilder(url)
+                    .delete()
+                    .build();
+
+                try (Response response = client.newCall(request).execute()) {
+                    Log.d(TAG, "Sign out response: " + response.code());
+                    // Clear tokens regardless of response
+                    clearTokens();
+                    call.resolve();
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Sign out error", e);
+                clearTokens();
+                call.resolve(); // Still resolve since we cleared local state
+            }
+        });
+    }
+
+    @PluginMethod
+    public void signInWithEmail(PluginCall call) {
+        String email = call.getString("email");
+
+        if (email == null) {
+            call.reject("Email is required");
+            return;
+        }
+
+        executor.execute(() -> {
+            try {
+                String createUrl = getClerkApiUrl("/v1/client/sign_ins?_clerk_js_version=5.117.0");
+                
+                JSONObject createBody = new JSONObject();
+                createBody.put("identifier", email);
+                
+                Request request = createRequestBuilder(createUrl)
+                    .post(RequestBody.create(createBody.toString(), JSON))
+                    .build();
+
+                try (Response response = client.newCall(request).execute()) {
+                    String body = response.body().string();
+                    Log.d(TAG, "Sign in with email response: " + response.code());
+                    
+                    if (!response.isSuccessful()) {
+                        call.reject("Failed to start sign in: " + body);
+                        return;
+                    }
+
+                    // TODO: Prepare email code flow
+                    // For now, return that code is required
+                    JSObject result = new JSObject();
+                    result.put("requiresCode", true);
+                    call.resolve(result);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Sign in with email error", e);
+                call.reject("Failed: " + e.getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void verifyEmailCode(PluginCall call) {
+        // TODO: Implement email code verification
+        call.reject("Email code verification not yet implemented on Android");
+    }
+
+    @PluginMethod
+    public void signUp(PluginCall call) {
+        String email = call.getString("emailAddress");
+        String password = call.getString("password");
+        String firstName = call.getString("firstName");
+        String lastName = call.getString("lastName");
+
+        if (email == null || password == null) {
+            call.reject("Email and password are required");
+            return;
+        }
+
+        executor.execute(() -> {
+            try {
+                String url = getClerkApiUrl("/v1/client/sign_ups?_clerk_js_version=5.117.0");
+                
+                JSONObject body = new JSONObject();
+                body.put("email_address", email);
+                body.put("password", password);
+                if (firstName != null) body.put("first_name", firstName);
+                if (lastName != null) body.put("last_name", lastName);
+                
+                Request request = createRequestBuilder(url)
+                    .post(RequestBody.create(body.toString(), JSON))
+                    .build();
+
+                try (Response response = client.newCall(request).execute()) {
+                    String responseBody = response.body().string();
+                    Log.d(TAG, "Sign up response: " + response.code());
+                    
+                    if (!response.isSuccessful()) {
+                        JSONObject errorJson = new JSONObject(responseBody);
+                        JSONArray errors = errorJson.optJSONArray("errors");
+                        if (errors != null && errors.length() > 0) {
+                            String message = errors.getJSONObject(0).optString("message", "Sign up failed");
+                            call.reject(message);
+                        } else {
+                            call.reject("Sign up failed: " + responseBody);
+                        }
+                        return;
+                    }
+
+                    JSONObject json = new JSONObject(responseBody);
+                    
+                    // Check if email verification is required
+                    JSONObject responseObj = json.optJSONObject("response");
+                    boolean requiresVerification = false;
+                    if (responseObj != null) {
+                        JSONArray verifications = responseObj.optJSONArray("verifications");
+                        if (verifications != null) {
+                            requiresVerification = true;
+                        }
+                    }
+
+                    JSObject result = new JSObject();
+                    result.put("requiresVerification", requiresVerification);
+                    if (currentUser != null) {
+                        result.put("user", convertUser(currentUser));
+                    } else {
+                        result.put("user", JSObject.NULL);
+                    }
+                    call.resolve(result);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Sign up error", e);
+                call.reject("Sign up failed: " + e.getMessage());
+            }
+        });
+    }
+
+    @PluginMethod
+    public void verifySignUpEmail(PluginCall call) {
+        call.reject("Sign up email verification not yet implemented on Android");
+    }
+
+    @PluginMethod
+    public void updateUser(PluginCall call) {
+        call.reject("Update user not yet implemented on Android");
+    }
+
+    @PluginMethod
+    public void requestPasswordReset(PluginCall call) {
+        call.reject("Password reset not yet implemented on Android");
+    }
+
+    @PluginMethod
+    public void resetPassword(PluginCall call) {
+        call.reject("Password reset not yet implemented on Android");
+    }
+
+    @PluginMethod
+    public void refreshSession(PluginCall call) {
+        call.reject("Refresh session not yet implemented on Android");
+    }
+
+    private JSObject convertUser(JSONObject clerkUser) throws JSONException {
+        JSObject user = new JSObject();
+        user.put("id", clerkUser.optString("id", null));
+        user.put("firstName", clerkUser.optString("first_name", null));
+        user.put("lastName", clerkUser.optString("last_name", null));
+        user.put("imageUrl", clerkUser.optString("image_url", null));
+        user.put("username", clerkUser.optString("username", null));
+        
+        // Get primary email
+        JSONArray emailAddresses = clerkUser.optJSONArray("email_addresses");
+        if (emailAddresses != null && emailAddresses.length() > 0) {
+            String primaryEmailId = clerkUser.optString("primary_email_address_id", null);
+            for (int i = 0; i < emailAddresses.length(); i++) {
+                JSONObject emailObj = emailAddresses.getJSONObject(i);
+                if (primaryEmailId != null && primaryEmailId.equals(emailObj.optString("id"))) {
+                    user.put("emailAddress", emailObj.optString("email_address", null));
+                    break;
+                }
+            }
+            // Fallback to first email if no primary found
+            if (user.optString("emailAddress", null) == null) {
+                user.put("emailAddress", emailAddresses.getJSONObject(0).optString("email_address", null));
+            }
+        }
+        
+        return user;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainon-inc/capacitor-clerk-native",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "Capacitor plugin for Clerk native authentication using bridge pattern to integrate Clerk iOS/Android SDKs with CocoaPods/Gradle",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/android/src/main/java/com/trainon/capacitor/clerk/ClerkNativePlugin.kt

@@ -1,509 +0,0 @@
-package com.trainon.capacitor.clerk
-
-import android.util.Log
-import com.clerk.android.Clerk
-import com.clerk.android.models.Session
-import com.clerk.android.models.SignIn
-import com.clerk.android.models.SignUp
-import com.clerk.android.models.User
-import com.getcapacitor.JSObject
-import com.getcapacitor.Plugin
-import com.getcapacitor.PluginCall
-import com.getcapacitor.PluginMethod
-import com.getcapacitor.annotation.CapacitorPlugin
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-
-@CapacitorPlugin(name = "ClerkNative")
-class ClerkNativePlugin : Plugin() {
-    
-    private val TAG = "ClerkNativePlugin"
-    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-    private var isConfigured = false
-
-    @PluginMethod
-    fun configure(call: PluginCall) {
-        val publishableKey = call.getString("publishableKey")
-        
-        if (publishableKey.isNullOrEmpty()) {
-            call.reject("Must provide publishableKey")
-            return
-        }
-
-        try {
-            // Initialize Clerk with the publishable key
-            Clerk.configure(context, publishableKey)
-            isConfigured = true
-            Log.d(TAG, "Clerk configured successfully")
-            call.resolve()
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to configure Clerk", e)
-            call.reject("Failed to configure Clerk: ${e.message}")
-        }
-    }
-
-    @PluginMethod
-    fun load(call: PluginCall) {
-        if (!isConfigured) {
-            call.reject("Clerk not configured. Call configure() first.")
-            return
-        }
-
-        scope.launch {
-            try {
-                val user = Clerk.user
-                val result = JSObject()
-                if (user != null) {
-                    result.put("user", userToJSObject(user))
-                } else {
-                    result.put("user", null)
-                }
-                call.resolve(result)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to load Clerk", e)
-                call.reject("Failed to load Clerk: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun signInWithEmail(call: PluginCall) {
-        val email = call.getString("email")
-        
-        if (email.isNullOrEmpty()) {
-            call.reject("Must provide email")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signIn = SignIn.create(identifier = email)
-                signIn.onSuccess { si ->
-                    // Prepare email code verification
-                    si.prepareFirstFactor(
-                        strategy = SignIn.PrepareFirstFactorStrategy.EmailCode(
-                            emailAddressId = si.supportedFirstFactors
-                                ?.filterIsInstance<SignIn.Factor.EmailCode>()
-                                ?.firstOrNull()
-                                ?.emailAddressId ?: ""
-                        )
-                    ).onSuccess {
-                        val result = JSObject()
-                        result.put("requiresCode", true)
-                        call.resolve(result)
-                    }.onFailure { error ->
-                        call.reject("Failed to prepare email code: ${error.message}")
-                    }
-                }.onFailure { error ->
-                    call.reject("Sign in with email failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Sign in with email failed", e)
-                call.reject("Sign in with email failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun verifyEmailCode(call: PluginCall) {
-        val code = call.getString("code")
-        
-        if (code.isNullOrEmpty()) {
-            call.reject("Must provide code")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signIn = Clerk.client?.signIn
-                if (signIn == null) {
-                    call.reject("No active sign in session")
-                    return@launch
-                }
-
-                signIn.attemptFirstFactor(
-                    strategy = SignIn.AttemptFirstFactorStrategy.EmailCode(code = code)
-                ).onSuccess { si ->
-                    if (si.status == SignIn.Status.COMPLETE) {
-                        // Set active session
-                        Clerk.client?.activeSessions?.firstOrNull()?.let { session ->
-                            Clerk.setActive(sessionId = session.id)
-                        }
-                        
-                        val user = Clerk.user
-                        val result = JSObject()
-                        result.put("user", user?.let { userToJSObject(it) })
-                        call.resolve(result)
-                    } else {
-                        call.reject("Verification incomplete")
-                    }
-                }.onFailure { error ->
-                    call.reject("Email code verification failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Email code verification failed", e)
-                call.reject("Email code verification failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun signInWithPassword(call: PluginCall) {
-        val email = call.getString("email")
-        val password = call.getString("password")
-        
-        if (email.isNullOrEmpty() || password.isNullOrEmpty()) {
-            call.reject("Must provide email and password")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signIn = SignIn.create(identifier = email)
-                signIn.onSuccess { si ->
-                    si.attemptFirstFactor(
-                        strategy = SignIn.AttemptFirstFactorStrategy.Password(password = password)
-                    ).onSuccess { completedSignIn ->
-                        if (completedSignIn.status == SignIn.Status.COMPLETE) {
-                            // Set active session
-                            completedSignIn.createdSessionId?.let { sessionId ->
-                                Clerk.setActive(sessionId = sessionId)
-                            }
-                            
-                            // Get user after sign in
-                            val user = Clerk.user
-                            val result = JSObject()
-                            result.put("user", user?.let { userToJSObject(it) })
-                            call.resolve(result)
-                        } else {
-                            call.reject("Sign in incomplete")
-                        }
-                    }.onFailure { error ->
-                        call.reject("Sign in failed: ${error.message}")
-                    }
-                }.onFailure { error ->
-                    call.reject("Sign in failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Sign in with password failed", e)
-                call.reject("Sign in with password failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun signUp(call: PluginCall) {
-        val emailAddress = call.getString("emailAddress")
-        val password = call.getString("password")
-        val firstName = call.getString("firstName")
-        val lastName = call.getString("lastName")
-        
-        if (emailAddress.isNullOrEmpty() || password.isNullOrEmpty()) {
-            call.reject("Must provide emailAddress and password")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signUp = SignUp.create(
-                    emailAddress = emailAddress,
-                    password = password,
-                    firstName = firstName,
-                    lastName = lastName
-                )
-                
-                signUp.onSuccess { su ->
-                    when (su.status) {
-                        SignUp.Status.COMPLETE -> {
-                            // Sign up complete, set active session
-                            su.createdSessionId?.let { sessionId ->
-                                Clerk.setActive(sessionId = sessionId)
-                            }
-                            
-                            val user = Clerk.user
-                            val result = JSObject()
-                            result.put("user", user?.let { userToJSObject(it) })
-                            result.put("requiresVerification", false)
-                            call.resolve(result)
-                        }
-                        SignUp.Status.MISSING_REQUIREMENTS -> {
-                            // Needs email verification
-                            su.prepareEmailAddressVerification().onSuccess {
-                                val result = JSObject()
-                                result.put("user", null)
-                                result.put("requiresVerification", true)
-                                call.resolve(result)
-                            }.onFailure { error ->
-                                call.reject("Failed to prepare email verification: ${error.message}")
-                            }
-                        }
-                        else -> {
-                            call.reject("Sign up incomplete: ${su.status}")
-                        }
-                    }
-                }.onFailure { error ->
-                    call.reject("Sign up failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Sign up failed", e)
-                call.reject("Sign up failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun verifySignUpEmail(call: PluginCall) {
-        val code = call.getString("code")
-        
-        if (code.isNullOrEmpty()) {
-            call.reject("Must provide code")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signUp = Clerk.client?.signUp
-                if (signUp == null) {
-                    call.reject("No active sign up session")
-                    return@launch
-                }
-
-                signUp.attemptEmailAddressVerification(code = code)
-                    .onSuccess { su ->
-                        if (su.status == SignUp.Status.COMPLETE) {
-                            su.createdSessionId?.let { sessionId ->
-                                Clerk.setActive(sessionId = sessionId)
-                            }
-                            
-                            val user = Clerk.user
-                            val result = JSObject()
-                            result.put("user", user?.let { userToJSObject(it) })
-                            call.resolve(result)
-                        } else {
-                            call.reject("Verification incomplete")
-                        }
-                    }.onFailure { error ->
-                        call.reject("Email verification failed: ${error.message}")
-                    }
-            } catch (e: Exception) {
-                Log.e(TAG, "Email verification failed", e)
-                call.reject("Email verification failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun getUser(call: PluginCall) {
-        scope.launch {
-            try {
-                val user = Clerk.user
-                val result = JSObject()
-                if (user != null) {
-                    result.put("user", userToJSObject(user))
-                } else {
-                    result.put("user", null)
-                }
-                call.resolve(result)
-            } catch (e: Exception) {
-                Log.e(TAG, "Get user failed", e)
-                call.reject("Get user failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun getToken(call: PluginCall) {
-        scope.launch {
-            try {
-                val session = Clerk.session
-                if (session == null) {
-                    val result = JSObject()
-                    result.put("token", null)
-                    call.resolve(result)
-                    return@launch
-                }
-
-                session.getToken().onSuccess { tokenResult ->
-                    val result = JSObject()
-                    result.put("token", tokenResult?.jwt)
-                    call.resolve(result)
-                }.onFailure { error ->
-                    call.reject("Get token failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Get token failed", e)
-                call.reject("Get token failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun signOut(call: PluginCall) {
-        scope.launch {
-            try {
-                val session = Clerk.session
-                if (session != null) {
-                    session.revoke().onSuccess {
-                        call.resolve()
-                    }.onFailure { error ->
-                        call.reject("Sign out failed: ${error.message}")
-                    }
-                } else {
-                    // No active session, consider it signed out
-                    call.resolve()
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Sign out failed", e)
-                call.reject("Sign out failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun updateUser(call: PluginCall) {
-        val firstName = call.getString("firstName")
-        val lastName = call.getString("lastName")
-
-        scope.launch {
-            try {
-                val user = Clerk.user
-                if (user == null) {
-                    call.reject("No user signed in")
-                    return@launch
-                }
-
-                user.update(
-                    firstName = firstName,
-                    lastName = lastName
-                ).onSuccess { updatedUser ->
-                    val result = JSObject()
-                    result.put("user", userToJSObject(updatedUser))
-                    call.resolve(result)
-                }.onFailure { error ->
-                    call.reject("Update user failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Update user failed", e)
-                call.reject("Update user failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun requestPasswordReset(call: PluginCall) {
-        val email = call.getString("email")
-        
-        if (email.isNullOrEmpty()) {
-            call.reject("Must provide email")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signIn = SignIn.create(identifier = email)
-                signIn.onSuccess { si ->
-                    si.prepareFirstFactor(
-                        strategy = SignIn.PrepareFirstFactorStrategy.ResetPasswordEmailCode(
-                            emailAddressId = si.supportedFirstFactors
-                                ?.filterIsInstance<SignIn.Factor.ResetPasswordEmailCode>()
-                                ?.firstOrNull()
-                                ?.emailAddressId ?: ""
-                        )
-                    ).onSuccess {
-                        call.resolve()
-                    }.onFailure { error ->
-                        call.reject("Failed to request password reset: ${error.message}")
-                    }
-                }.onFailure { error ->
-                    call.reject("Failed to request password reset: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Request password reset failed", e)
-                call.reject("Request password reset failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun resetPassword(call: PluginCall) {
-        val code = call.getString("code")
-        val newPassword = call.getString("newPassword")
-        
-        if (code.isNullOrEmpty() || newPassword.isNullOrEmpty()) {
-            call.reject("Must provide code and newPassword")
-            return
-        }
-
-        scope.launch {
-            try {
-                val signIn = Clerk.client?.signIn
-                if (signIn == null) {
-                    call.reject("No active sign in session")
-                    return@launch
-                }
-
-                signIn.attemptFirstFactor(
-                    strategy = SignIn.AttemptFirstFactorStrategy.ResetPasswordEmailCode(code = code)
-                ).onSuccess { si ->
-                    si.resetPassword(newPassword = newPassword).onSuccess { completedSignIn ->
-                        if (completedSignIn.status == SignIn.Status.COMPLETE) {
-                            completedSignIn.createdSessionId?.let { sessionId ->
-                                Clerk.setActive(sessionId = sessionId)
-                            }
-                            call.resolve()
-                        } else {
-                            call.reject("Password reset incomplete")
-                        }
-                    }.onFailure { error ->
-                        call.reject("Failed to reset password: ${error.message}")
-                    }
-                }.onFailure { error ->
-                    call.reject("Failed to verify reset code: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Reset password failed", e)
-                call.reject("Reset password failed: ${e.message}")
-            }
-        }
-    }
-
-    @PluginMethod
-    fun refreshSession(call: PluginCall) {
-        scope.launch {
-            try {
-                val session = Clerk.session
-                if (session == null) {
-                    val result = JSObject()
-                    result.put("token", null)
-                    call.resolve(result)
-                    return@launch
-                }
-
-                // Force refresh the token
-                session.getToken(forceRefresh = true).onSuccess { tokenResult ->
-                    val result = JSObject()
-                    result.put("token", tokenResult?.jwt)
-                    call.resolve(result)
-                }.onFailure { error ->
-                    call.reject("Refresh session failed: ${error.message}")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Refresh session failed", e)
-                call.reject("Refresh session failed: ${e.message}")
-            }
-        }
-    }
-
-    private fun userToJSObject(user: User): JSObject {
-        val jsObject = JSObject()
-        jsObject.put("id", user.id)
-        jsObject.put("firstName", user.firstName)
-        jsObject.put("lastName", user.lastName)
-        jsObject.put("emailAddress", user.primaryEmailAddress?.emailAddress)
-        jsObject.put("imageUrl", user.imageUrl)
-        jsObject.put("username", user.username)
-        return jsObject
-    }
-}