Buy on StoreKit and Play Billing, then confirm with the backend (#78) (#122)

## Summary
- The Capacitor shell buys through StoreKit (iOS 15) and Play Billing instead of RevenueCat.
- After the store sheet succeeds, the app POSTs the signed transaction or Play purchase token to `/monetization/store/confirm/`.
- Restore reads current store entitlements and confirms each one. Web checkout stays on Stripe.
- The store account token from `GET /monetization/subscription/` is sent as `appAccountToken` / `obfuscatedAccountId`.

Depends on the `chat_backend` PR for issue #78 (`feat/78-native-store-purchases`).

## Test plan
- [x] `storeBilling`, `revenueCat`, `finance`, and `BillingSection` unit tests
- [ ] iOS sandbox purchase and restore against a backend with `APPLE_IAP_BUNDLE_ID` set
- [ ] Play license-test purchase and restore against a backend with `GOOGLE_PLAY_SERVICE_ACCOUNT_JSON` set
- [ ] Web billing still opens Stripe Checkout

Reviewed-on: #122

llm-fe/plugins/native-store-billing/NativeStoreBilling.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'NativeStoreBilling'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = 'MIT'
+  s.homepage = 'https://aimloperations.com'
+  s.author = 'AI ML Operations'
+  s.source = { :path => '.' }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

llm-fe/plugins/native-store-billing/android/build.gradle

@@ -0,0 +1,30 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "ai.hesychia.chat.billing"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:1.7.0"
+    implementation "com.android.billingclient:billing:7.1.1"
+}

llm-fe/plugins/native-store-billing/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

llm-fe/plugins/native-store-billing/android/src/main/java/ai/hesychia/chat/billing/NativeStoreBillingPlugin.java

@@ -0,0 +1,243 @@
+package ai.hesychia.chat.billing;
+
+import android.app.Activity;
+import com.android.billingclient.api.AcknowledgePurchaseParams;
+import com.android.billingclient.api.BillingClient;
+import com.android.billingclient.api.BillingClientStateListener;
+import com.android.billingclient.api.BillingFlowParams;
+import com.android.billingclient.api.BillingResult;
+import com.android.billingclient.api.PendingPurchasesParams;
+import com.android.billingclient.api.ProductDetails;
+import com.android.billingclient.api.Purchase;
+import com.android.billingclient.api.PurchasesUpdatedListener;
+import com.android.billingclient.api.QueryProductDetailsParams;
+import com.android.billingclient.api.QueryPurchasesParams;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.json.JSONObject;
+
+@CapacitorPlugin(name = "NativeStoreBilling")
+public class NativeStoreBillingPlugin extends Plugin implements PurchasesUpdatedListener {
+
+    private BillingClient billingClient;
+    private PluginCall pendingPurchase;
+    private String pendingProductId = "";
+
+    @PluginMethod
+    public void purchase(PluginCall call) {
+        String productId = call.getString("productId", "");
+        String accountToken = call.getString("accountToken", "");
+        if (productId == null || productId.isEmpty()) {
+            call.reject("productId is required");
+            return;
+        }
+        Activity activity = getActivity();
+        if (activity == null) {
+            call.reject("Play Billing needs a foreground activity");
+            return;
+        }
+        activity.runOnUiThread(() ->
+            connect(call, () -> queryAndLaunch(call, productId, accountToken == null ? "" : accountToken))
+        );
+    }
+
+    @PluginMethod
+    public void restore(PluginCall call) {
+        Activity activity = getActivity();
+        if (activity == null) {
+            call.reject("Play Billing needs a foreground activity");
+            return;
+        }
+        activity.runOnUiThread(() -> connect(call, () -> queryOwned(call, "")));
+    }
+
+    private void connect(PluginCall call, Runnable whenReady) {
+        if (billingClient != null && billingClient.isReady()) {
+            whenReady.run();
+            return;
+        }
+        billingClient = BillingClient.newBuilder(getContext())
+            .setListener(this)
+            .enablePendingPurchases(
+                PendingPurchasesParams.newBuilder().enableOneTimeProducts().build()
+            )
+            .build();
+        billingClient.startConnection(
+            new BillingClientStateListener() {
+                @Override
+                public void onBillingSetupFinished(BillingResult billingResult) {
+                    if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
+                        whenReady.run();
+                        return;
+                    }
+                    call.reject("Play Billing setup failed: " + billingResult.getDebugMessage());
+                }
+
+                @Override
+                public void onBillingServiceDisconnected() {
+                    // The next purchase reconnects.
+                }
+            }
+        );
+    }
+
+    private void queryAndLaunch(PluginCall call, String productId, String accountToken) {
+        QueryProductDetailsParams params = QueryProductDetailsParams.newBuilder()
+            .setProductList(
+                Collections.singletonList(
+                    QueryProductDetailsParams.Product.newBuilder()
+                        .setProductId(productId)
+                        .setProductType(BillingClient.ProductType.SUBS)
+                        .build()
+                )
+            )
+            .build();
+        billingClient.queryProductDetailsAsync(params, (billingResult, productDetailsList) -> {
+            if (billingResult.getResponseCode() != BillingClient.BillingResponseCode.OK) {
+                call.reject("Could not load Play product: " + billingResult.getDebugMessage());
+                return;
+            }
+            if (productDetailsList == null || productDetailsList.isEmpty()) {
+                call.reject("Play product was not found: " + productId);
+                return;
+            }
+            ProductDetails details = productDetailsList.get(0);
+            List<ProductDetails.SubscriptionOfferDetails> offers = details.getSubscriptionOfferDetails();
+            if (offers == null || offers.isEmpty()) {
+                call.reject("Play product has no subscription offer");
+                return;
+            }
+            String offerToken = offers.get(0).getOfferToken();
+            BillingFlowParams.ProductDetailsParams productParams = BillingFlowParams.ProductDetailsParams.newBuilder()
+                .setProductDetails(details)
+                .setOfferToken(offerToken)
+                .build();
+            BillingFlowParams.Builder flow = BillingFlowParams.newBuilder()
+                .setProductDetailsParamsList(Collections.singletonList(productParams));
+            if (!accountToken.isEmpty()) {
+                flow.setObfuscatedAccountId(accountToken);
+            }
+            Activity activity = getActivity();
+            if (activity == null) {
+                call.reject("Play Billing needs a foreground activity");
+                return;
+            }
+            activity.runOnUiThread(() -> {
+                pendingPurchase = call;
+                pendingProductId = productId;
+                BillingResult launched = billingClient.launchBillingFlow(activity, flow.build());
+                if (launched.getResponseCode() != BillingClient.BillingResponseCode.OK) {
+                    pendingPurchase = null;
+                    call.reject("Could not open Play purchase sheet: " + launched.getDebugMessage());
+                }
+            });
+        });
+    }
+
+    @Override
+    public void onPurchasesUpdated(BillingResult billingResult, List<Purchase> purchases) {
+        PluginCall call = pendingPurchase;
+        pendingPurchase = null;
+        if (call == null) {
+            return;
+        }
+        int code = billingResult.getResponseCode();
+        if (code == BillingClient.BillingResponseCode.USER_CANCELED) {
+            JSObject data = new JSObject();
+            data.put("userCancelled", true);
+            call.reject("Purchase cancelled", "PURCHASE_CANCELLED", null, data);
+            return;
+        }
+        if (code == BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED) {
+            queryOwned(call, pendingProductId);
+            return;
+        }
+        if (code != BillingClient.BillingResponseCode.OK || purchases == null || purchases.isEmpty()) {
+            call.reject("Play purchase failed: " + billingResult.getDebugMessage());
+            return;
+        }
+        Purchase match = null;
+        for (Purchase purchase : purchases) {
+            if (purchase.getPurchaseState() != Purchase.PurchaseState.PURCHASED) {
+                continue;
+            }
+            if (pendingProductId.isEmpty() || purchase.getProducts().contains(pendingProductId)) {
+                match = purchase;
+                break;
+            }
+        }
+        if (match == null) {
+            call.reject("Play purchase did not complete");
+            return;
+        }
+        acknowledge(match);
+        call.resolve(purchaseToJson(match));
+    }
+
+    private void queryOwned(PluginCall call, String productId) {
+        QueryPurchasesParams params = QueryPurchasesParams.newBuilder()
+            .setProductType(BillingClient.ProductType.SUBS)
+            .build();
+        billingClient.queryPurchasesAsync(params, (billingResult, purchases) -> {
+            if (billingResult.getResponseCode() != BillingClient.BillingResponseCode.OK) {
+                call.reject("Could not restore Play purchases: " + billingResult.getDebugMessage());
+                return;
+            }
+            JSArray rows = new JSArray();
+            Purchase single = null;
+            List<Purchase> owned = purchases == null ? new ArrayList<>() : purchases;
+            for (Purchase purchase : owned) {
+                if (purchase.getPurchaseState() != Purchase.PurchaseState.PURCHASED) {
+                    continue;
+                }
+                if (!productId.isEmpty() && !purchase.getProducts().contains(productId)) {
+                    continue;
+                }
+                acknowledge(purchase);
+                JSONObject row = purchaseToJson(purchase);
+                rows.put(row);
+                single = purchase;
+            }
+            if (!productId.isEmpty()) {
+                if (single == null) {
+                    call.reject("No active Play purchase for " + productId);
+                    return;
+                }
+                call.resolve(purchaseToJson(single));
+                return;
+            }
+            JSObject result = new JSObject();
+            result.put("transactions", rows);
+            call.resolve(result);
+        });
+    }
+
+    private void acknowledge(Purchase purchase) {
+        if (purchase.isAcknowledged() || billingClient == null) {
+            return;
+        }
+        AcknowledgePurchaseParams params = AcknowledgePurchaseParams.newBuilder()
+            .setPurchaseToken(purchase.getPurchaseToken())
+            .build();
+        billingClient.acknowledgePurchase(params, billingResult -> { });
+    }
+
+    private JSObject purchaseToJson(Purchase purchase) {
+        String productId = purchase.getProducts().isEmpty() ? "" : purchase.getProducts().get(0);
+        String orderId = purchase.getOrderId() == null ? purchase.getPurchaseToken() : purchase.getOrderId();
+        JSObject row = new JSObject();
+        row.put("store", "play_store");
+        row.put("productId", productId);
+        row.put("transactionId", orderId);
+        row.put("purchaseToken", purchase.getPurchaseToken());
+        row.put("signedTransaction", "");
+        return row;
+    }
+}

llm-fe/plugins/native-store-billing/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

llm-fe/plugins/native-store-billing/dist/index.js

@@ -0,0 +1,2 @@
+// Native code is loaded by Capacitor. The web app registers the plugin from src.
+module.exports = {};

llm-fe/plugins/native-store-billing/ios/Sources/NativeStoreBillingPlugin/NativeStoreBillingPlugin.swift

@@ -0,0 +1,94 @@
+import Foundation
+import Capacitor
+import StoreKit
+
+@objc(NativeStoreBillingPlugin)
+public class NativeStoreBillingPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "NativeStoreBillingPlugin"
+    public let jsName = "NativeStoreBilling"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "purchase", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "restore", returnType: CAPPluginReturnPromise)
+    ]
+
+    @objc func purchase(_ call: CAPPluginCall) {
+        let productId = call.getString("productId") ?? ""
+        let accountToken = call.getString("accountToken") ?? ""
+        if productId.isEmpty {
+            call.reject("productId is required")
+            return
+        }
+        Task {
+            do {
+                let products = try await Product.products(for: [productId])
+                guard let product = products.first else {
+                    call.reject("App Store product was not found: \(productId)")
+                    return
+                }
+                var options = Set<Product.PurchaseOption>()
+                if let uuid = UUID(uuidString: accountToken) {
+                    options.insert(.appAccountToken(uuid))
+                }
+                let result = try await product.purchase(options: options)
+                switch result {
+                case .success(let verification):
+                    let transaction = try Self.checkVerified(verification)
+                    let payload = Self.payload(transaction: transaction, jws: verification.jwsRepresentation)
+                    await transaction.finish()
+                    call.resolve(payload)
+                case .userCancelled:
+                    call.reject("Purchase cancelled", "PURCHASE_CANCELLED", nil, ["userCancelled": true])
+                case .pending:
+                    call.reject("App Store purchase is still pending")
+                @unknown default:
+                    call.reject("Unknown App Store purchase result")
+                }
+            } catch {
+                call.reject(error.localizedDescription)
+            }
+        }
+    }
+
+    @objc func restore(_ call: CAPPluginCall) {
+        Task {
+            var rows: [JSObject] = []
+            for await result in Transaction.currentEntitlements {
+                guard case .verified(let transaction) = result else {
+                    continue
+                }
+                if transaction.revocationDate != nil {
+                    continue
+                }
+                rows.append(Self.payload(transaction: transaction, jws: result.jwsRepresentation))
+            }
+            call.resolve(["transactions": rows])
+        }
+    }
+
+    private static func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
+        switch result {
+        case .unverified:
+            throw NSError(
+                domain: "NativeStoreBilling",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "App Store could not verify this transaction"]
+            )
+        case .verified(let safe):
+            return safe
+        }
+    }
+
+    private static func payload(transaction: Transaction, jws: String) -> JSObject {
+        var row: JSObject = [
+            "store": "app_store",
+            "productId": transaction.productID,
+            "transactionId": String(transaction.id),
+            "purchaseToken": "",
+            "signedTransaction": jws
+        ]
+        if let expires = transaction.expirationDate {
+            row["expiresAt"] = ISO8601DateFormatter().string(from: expires)
+        }
+        return row
+    }
+}

llm-fe/plugins/native-store-billing/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "native-store-billing",
+  "version": "0.1.0",
+  "private": true,
+  "description": "StoreKit and Play Billing purchases for the Hesychia Capacitor shell.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "ios/Sources",
+    "NativeStoreBilling.podspec",
+    "dist/"
+  ],
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  }
+}