@teardown/cli 1.2.39 → 2.0.42

package/src/plugins/capabilities/deep-linking.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import type { AndroidIntentFilter, ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Deep linking plugin configuration schema
+ */
+export const DeepLinkingPluginConfigSchema = z.object({
+	/** Custom URL scheme */
+	scheme: z.string().min(1, "URL scheme is required"),
+
+	/** Universal Links configuration (iOS) / App Links (Android) */
+	universalLinks: z
+		.object({
+			/** Associated domains */
+			domains: z.array(z.string()).min(1),
+			/** URL path patterns */
+			paths: z.array(z.string()).optional().default(["/*"]),
+		})
+		.optional(),
+
+	/** Android App Links configuration */
+	androidAppLinks: z
+		.object({
+			/** App Links host domains */
+			hosts: z.array(z.string()).min(1),
+			/** URL path patterns */
+			paths: z.array(z.string()).optional().default(["/*"]),
+		})
+		.optional(),
+});
+
+export type DeepLinkingPluginConfig = z.infer<typeof DeepLinkingPluginConfigSchema>;
+
+/**
+ * Deep linking capability plugin
+ *
+ * Configures deep linking support including custom URL schemes,
+ * Universal Links (iOS), and App Links (Android).
+ */
+export class DeepLinkingPlugin extends BasePlugin<DeepLinkingPluginConfig> {
+	readonly name = "deep-linking";
+	readonly version = "1.0.0";
+	readonly description = "Configure deep linking with custom schemes and Universal/App Links";
+	readonly configSchema = DeepLinkingPluginConfigSchema;
+
+	override provides = ["deep-linking", "universal-links", "app-links"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: DeepLinkingPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying deep linking configuration...");
+
+		let result = config;
+
+		// Add custom URL scheme
+		result = this.addUrlScheme(result, pluginConfig.scheme);
+
+		// iOS: Configure Universal Links
+		if (pluginConfig.universalLinks) {
+			for (const domain of pluginConfig.universalLinks.domains) {
+				// Add associated domain entitlement
+				result = this.addAssociatedDomain(result, domain, "applinks");
+				// Also add webcredentials for password autofill
+				result = this.addAssociatedDomain(result, domain, "webcredentials");
+			}
+		}
+
+		// Android: Add intent filter for custom scheme
+		const schemeFilter: AndroidIntentFilter = {
+			actions: ["android.intent.action.VIEW"],
+			categories: ["android.intent.category.DEFAULT", "android.intent.category.BROWSABLE"],
+			data: [{ scheme: pluginConfig.scheme }],
+		};
+		result = this.addIntentFilter(result, schemeFilter);
+
+		// Android: Configure App Links
+		if (pluginConfig.androidAppLinks || pluginConfig.universalLinks) {
+			const hosts = pluginConfig.androidAppLinks?.hosts ?? pluginConfig.universalLinks?.domains ?? [];
+			const paths = pluginConfig.androidAppLinks?.paths ?? pluginConfig.universalLinks?.paths ?? ["/*"];
+
+			for (const host of hosts) {
+				const appLinkFilter: AndroidIntentFilter = {
+					actions: ["android.intent.action.VIEW"],
+					categories: ["android.intent.category.DEFAULT", "android.intent.category.BROWSABLE"],
+					data: paths.map((pathPrefix) => ({
+						scheme: "https",
+						host,
+						pathPrefix: pathPrefix.replace("*", ""),
+					})),
+					autoVerify: true,
+				};
+				result = this.addIntentFilter(result, appLinkFilter);
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Helper to add associated domain entitlement
+	 */
+	private addAssociatedDomain(
+		config: ProcessedAppConfig,
+		domain: string,
+		type: "applinks" | "webcredentials" | "activitycontinuation"
+	): ProcessedAppConfig {
+		const key = "com.apple.developer.associated-domains";
+		const domainEntry = `${type}:${domain}`;
+
+		const existingDomains = (config.resolvedEntitlements[key] as string[]) || [];
+
+		if (!existingDomains.includes(domainEntry)) {
+			return this.addEntitlement(config, key, [...existingDomains, domainEntry]);
+		}
+
+		return config;
+	}
+}

package/src/plugins/capabilities/firebase.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Firebase plugin configuration schema
+ */
+export const FirebasePluginConfigSchema = z.object({
+	/** Enable Firebase Analytics */
+	analytics: z.boolean().optional().default(true),
+
+	/** Enable Firebase Crashlytics */
+	crashlytics: z.boolean().optional().default(true),
+
+	/** Enable Firebase Cloud Messaging */
+	messaging: z.boolean().optional().default(false),
+
+	/** Enable Firebase Remote Config */
+	remoteConfig: z.boolean().optional().default(false),
+
+	/** Enable Firebase Performance Monitoring */
+	performance: z.boolean().optional().default(false),
+
+	/** Path to GoogleService-Info.plist (iOS) */
+	iosGoogleServicesFile: z.string().optional(),
+
+	/** Path to google-services.json (Android) */
+	androidGoogleServicesFile: z.string().optional(),
+});
+
+export type FirebasePluginConfig = z.infer<typeof FirebasePluginConfigSchema>;
+
+/**
+ * Firebase capability plugin
+ *
+ * Configures Firebase SDK integration including Analytics,
+ * Crashlytics, Cloud Messaging, Remote Config, and Performance.
+ */
+export class FirebasePlugin extends BasePlugin<FirebasePluginConfig> {
+	readonly name = "firebase";
+	readonly version = "1.0.0";
+	readonly description = "Configure Firebase SDK integration (Analytics, Crashlytics, FCM, etc.)";
+	readonly configSchema = FirebasePluginConfigSchema;
+
+	override provides = ["firebase", "analytics", "crashlytics"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: FirebasePluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying Firebase configuration...");
+
+		let result = config;
+
+		// iOS: Add Firebase CocoaPods
+		result = this.addPodDependency(result, { name: "Firebase/Core" });
+
+		if (pluginConfig.analytics) {
+			result = this.addPodDependency(result, { name: "Firebase/Analytics" });
+		}
+
+		if (pluginConfig.crashlytics) {
+			result = this.addPodDependency(result, { name: "Firebase/Crashlytics" });
+
+			// Enable Crashlytics collection
+			result = {
+				...result,
+				resolvedInfoPlist: {
+					...result.resolvedInfoPlist,
+					FirebaseCrashlyticsCollectionEnabled: true,
+				},
+			};
+		}
+
+		if (pluginConfig.messaging) {
+			result = this.addPodDependency(result, { name: "Firebase/Messaging" });
+
+			// Add push notification background mode
+			result = this.addBackgroundMode(result, "remote-notification");
+		}
+
+		if (pluginConfig.remoteConfig) {
+			result = this.addPodDependency(result, { name: "Firebase/RemoteConfig" });
+		}
+
+		if (pluginConfig.performance) {
+			result = this.addPodDependency(result, { name: "Firebase/Performance" });
+		}
+
+		// Android: Add Firebase dependencies
+		result = this.addGradleDependency(result, "com.google.firebase:firebase-bom:33.0.0");
+
+		if (pluginConfig.analytics) {
+			result = this.addGradleDependency(result, "com.google.firebase:firebase-analytics");
+		}
+
+		if (pluginConfig.crashlytics) {
+			result = this.addGradleDependency(result, "com.google.firebase:firebase-crashlytics");
+
+			// Add Crashlytics metadata
+			result = this.addAndroidMetadata(result, "firebase_crashlytics_collection_enabled", "true");
+		}
+
+		if (pluginConfig.messaging) {
+			result = this.addGradleDependency(result, "com.google.firebase:firebase-messaging");
+
+			// Add required permissions
+			result = this.addAndroidPermission(result, "android.permission.POST_NOTIFICATIONS");
+			result = this.addAndroidPermission(result, "android.permission.WAKE_LOCK");
+		}
+
+		if (pluginConfig.remoteConfig) {
+			result = this.addGradleDependency(result, "com.google.firebase:firebase-config");
+		}
+
+		if (pluginConfig.performance) {
+			result = this.addGradleDependency(result, "com.google.firebase:firebase-perf");
+		}
+
+		// Android: Add internet permission
+		result = this.addAndroidPermission(result, "android.permission.INTERNET");
+		result = this.addAndroidPermission(result, "android.permission.ACCESS_NETWORK_STATE");
+
+		return result;
+	}
+
+	override async postProcess(context: PluginContext): Promise<void> {
+		const { log, isDryRun } = context;
+
+		if (!isDryRun) {
+			log.debug("Firebase post-processing: Ensure GoogleService-Info.plist and google-services.json are present");
+		}
+	}
+}

package/src/plugins/capabilities/index.ts

@@ -0,0 +1,96 @@
+/**
+ * Capability plugins for Teardown Launchpad
+ *
+ * These plugins configure native capabilities for iOS and Android,
+ * including permissions, entitlements, frameworks, and dependencies.
+ */
+
+import { BiometricsPlugin, BiometricsPluginConfigSchema } from "./biometrics";
+import { BluetoothPlugin, BluetoothPluginConfigSchema } from "./bluetooth";
+import { CalendarPlugin, CalendarPluginConfigSchema } from "./calendar";
+// Import all plugins for re-export and use in objects
+import { CameraPlugin, CameraPluginConfigSchema } from "./camera";
+import { ContactsPlugin, ContactsPluginConfigSchema } from "./contacts";
+import { DeepLinkingPlugin, DeepLinkingPluginConfigSchema } from "./deep-linking";
+import { FirebasePlugin, FirebasePluginConfigSchema } from "./firebase";
+import { LocationPlugin, LocationPluginConfigSchema } from "./location";
+import { PhotoLibraryPlugin, PhotoLibraryPluginConfigSchema } from "./photo-library";
+import { PushNotificationsPlugin, PushNotificationsPluginConfigSchema } from "./push-notifications";
+import { SignInWithApplePlugin, SignInWithApplePluginConfigSchema } from "./sign-in-with-apple";
+
+// Re-export plugins
+export {
+	CameraPlugin,
+	CameraPluginConfigSchema,
+	LocationPlugin,
+	LocationPluginConfigSchema,
+	PushNotificationsPlugin,
+	PushNotificationsPluginConfigSchema,
+	BiometricsPlugin,
+	BiometricsPluginConfigSchema,
+	DeepLinkingPlugin,
+	DeepLinkingPluginConfigSchema,
+	FirebasePlugin,
+	FirebasePluginConfigSchema,
+	ContactsPlugin,
+	ContactsPluginConfigSchema,
+	CalendarPlugin,
+	CalendarPluginConfigSchema,
+	PhotoLibraryPlugin,
+	PhotoLibraryPluginConfigSchema,
+	BluetoothPlugin,
+	BluetoothPluginConfigSchema,
+	SignInWithApplePlugin,
+	SignInWithApplePluginConfigSchema,
+};
+
+export type { BiometricsPluginConfig } from "./biometrics";
+export type { BluetoothPluginConfig } from "./bluetooth";
+export type { CalendarPluginConfig } from "./calendar";
+// Re-export types
+export type { CameraPluginConfig } from "./camera";
+export type { ContactsPluginConfig } from "./contacts";
+export type { DeepLinkingPluginConfig } from "./deep-linking";
+export type { FirebasePluginConfig } from "./firebase";
+export type { LocationPluginConfig } from "./location";
+export type { PhotoLibraryPluginConfig } from "./photo-library";
+export type { PushNotificationsPluginConfig } from "./push-notifications";
+export type { SignInWithApplePluginConfig } from "./sign-in-with-apple";
+
+/**
+ * All available capability plugins
+ */
+export const CapabilityPlugins = {
+	CameraPlugin,
+	LocationPlugin,
+	PushNotificationsPlugin,
+	BiometricsPlugin,
+	DeepLinkingPlugin,
+	FirebasePlugin,
+	ContactsPlugin,
+	CalendarPlugin,
+	PhotoLibraryPlugin,
+	BluetoothPlugin,
+	SignInWithApplePlugin,
+} as const;
+
+/**
+ * Get a plugin by name
+ */
+export function getPluginByName(name: string) {
+	const plugins: Record<string, unknown> = {
+		camera: CameraPlugin,
+		location: LocationPlugin,
+		"push-notifications": PushNotificationsPlugin,
+		biometrics: BiometricsPlugin,
+		"deep-linking": DeepLinkingPlugin,
+		firebase: FirebasePlugin,
+		contacts: ContactsPlugin,
+		calendar: CalendarPlugin,
+		"photo-library": PhotoLibraryPlugin,
+		bluetooth: BluetoothPlugin,
+		"sign-in-with-apple": SignInWithApplePlugin,
+	};
+
+	return plugins[name];
+}

package/src/plugins/capabilities/location.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Location plugin configuration schema
+ */
+export const LocationPluginConfigSchema = z.object({
+	/** iOS when-in-use location usage description */
+	whenInUsePermission: z.string().min(1, "When-in-use permission description is required"),
+
+	/** iOS always-on location usage description */
+	alwaysPermission: z.string().optional(),
+
+	/** Show background location indicator */
+	backgroundIndicator: z.boolean().optional().default(true),
+
+	/** Enable high accuracy GPS */
+	highAccuracy: z.boolean().optional().default(true),
+});
+
+export type LocationPluginConfig = z.infer<typeof LocationPluginConfigSchema>;
+
+/**
+ * Location capability plugin
+ *
+ * Configures location access for iOS and Android including
+ * foreground, background, and always-on location permissions.
+ */
+export class LocationPlugin extends BasePlugin<LocationPluginConfig> {
+	readonly name = "location";
+	readonly version = "1.0.0";
+	readonly description = "Configure location services for geolocation features";
+	readonly configSchema = LocationPluginConfigSchema;
+
+	override provides = ["location"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: LocationPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying location configuration...");
+
+		let result = config;
+
+		// iOS: Add usage descriptions
+		result = this.addUsageDescription(result, "NSLocationWhenInUseUsageDescription", pluginConfig.whenInUsePermission);
+
+		if (pluginConfig.alwaysPermission) {
+			result = this.addUsageDescription(
+				result,
+				"NSLocationAlwaysAndWhenInUseUsageDescription",
+				pluginConfig.alwaysPermission
+			);
+
+			// Also add legacy key for older iOS versions
+			result = this.addUsageDescription(result, "NSLocationAlwaysUsageDescription", pluginConfig.alwaysPermission);
+
+			// Add background mode
+			result = this.addBackgroundMode(result, "location");
+		}
+
+		// iOS: Add framework
+		result = this.addFramework(result, "CoreLocation");
+
+		// Android: Add permissions
+		result = this.addAndroidPermission(result, "android.permission.ACCESS_FINE_LOCATION");
+		result = this.addAndroidPermission(result, "android.permission.ACCESS_COARSE_LOCATION");
+
+		if (pluginConfig.alwaysPermission) {
+			result = this.addAndroidPermission(result, "android.permission.ACCESS_BACKGROUND_LOCATION");
+			result = this.addAndroidPermission(result, "android.permission.FOREGROUND_SERVICE");
+			result = this.addAndroidPermission(result, "android.permission.FOREGROUND_SERVICE_LOCATION");
+		}
+
+		// Android: Add GPS feature
+		if (pluginConfig.highAccuracy) {
+			result = this.addAndroidFeature(result, "android.hardware.location.gps");
+		}
+
+		return result;
+	}
+}

package/src/plugins/capabilities/photo-library.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Photo library plugin configuration schema
+ */
+export const PhotoLibraryPluginConfigSchema = z.object({
+	/** iOS photo library read permission description */
+	readPermission: z.string().min(1, "Photo library read permission description is required"),
+
+	/** iOS photo library write permission description */
+	writePermission: z.string().optional(),
+
+	/** Behavior for iOS 14+ limited photo access */
+	limitedAccessBehavior: z.enum(["prompt", "silent"]).optional().default("prompt"),
+});
+
+export type PhotoLibraryPluginConfig = z.infer<typeof PhotoLibraryPluginConfigSchema>;
+
+/**
+ * Photo library capability plugin
+ */
+export class PhotoLibraryPlugin extends BasePlugin<PhotoLibraryPluginConfig> {
+	readonly name = "photo-library";
+	readonly version = "1.0.0";
+	readonly description = "Configure photo library access for reading and writing photos/videos";
+	readonly configSchema = PhotoLibraryPluginConfigSchema;
+
+	override provides = ["photo-library", "photos"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: PhotoLibraryPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying photo library configuration...");
+
+		let result = config;
+
+		// iOS: Add read usage description
+		result = this.addUsageDescription(result, "NSPhotoLibraryUsageDescription", pluginConfig.readPermission);
+
+		// iOS: Add write usage description
+		if (pluginConfig.writePermission) {
+			result = this.addUsageDescription(result, "NSPhotoLibraryAddUsageDescription", pluginConfig.writePermission);
+		}
+
+		// iOS: Configure limited photo access behavior
+		if (pluginConfig.limitedAccessBehavior === "silent") {
+			result = {
+				...result,
+				resolvedInfoPlist: {
+					...result.resolvedInfoPlist,
+					PHPhotoLibraryPreventAutomaticLimitedAccessAlert: true,
+				},
+			};
+		}
+
+		// iOS: Add Photos framework
+		result = this.addFramework(result, "Photos");
+		result = this.addFramework(result, "PhotosUI");
+
+		// Android: Add media permissions (Android 13+)
+		result = this.addAndroidPermission(result, "android.permission.READ_MEDIA_IMAGES");
+		result = this.addAndroidPermission(result, "android.permission.READ_MEDIA_VIDEO");
+
+		// Android: Legacy storage permission for older versions
+		result = this.addAndroidPermission(result, "android.permission.READ_EXTERNAL_STORAGE");
+
+		if (pluginConfig.writePermission) {
+			result = this.addAndroidPermission(result, "android.permission.WRITE_EXTERNAL_STORAGE");
+		}
+
+		return result;
+	}
+}

package/src/plugins/capabilities/push-notifications.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Push notifications plugin configuration schema
+ */
+export const PushNotificationsPluginConfigSchema = z.object({
+	/** Push notification environment */
+	environment: z.enum(["development", "production"]).default("development"),
+
+	/** Default notification channel ID (Android) */
+	defaultChannelId: z.string().optional().default("default"),
+
+	/** Default notification icon resource (Android) */
+	defaultIcon: z.string().optional(),
+
+	/** Enable remote notification background mode (iOS) */
+	backgroundModes: z.boolean().optional().default(true),
+
+	/** Enable silent push notifications */
+	silentNotifications: z.boolean().optional().default(true),
+});
+
+export type PushNotificationsPluginConfig = z.infer<typeof PushNotificationsPluginConfigSchema>;
+
+/**
+ * Push notifications capability plugin
+ *
+ * Configures push notification support for iOS (APNs) and Android (FCM)
+ * including entitlements, background modes, and notification settings.
+ */
+export class PushNotificationsPlugin extends BasePlugin<PushNotificationsPluginConfig> {
+	readonly name = "push-notifications";
+	readonly version = "1.0.0";
+	readonly description = "Configure push notifications for iOS (APNs) and Android (FCM)";
+	readonly configSchema = PushNotificationsPluginConfigSchema;
+
+	override provides = ["push-notifications", "notifications"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: PushNotificationsPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying push notifications configuration...");
+
+		let result = config;
+
+		// iOS: Add APS entitlement
+		result = this.addEntitlement(result, "aps-environment", pluginConfig.environment);
+
+		// iOS: Add background modes
+		if (pluginConfig.backgroundModes) {
+			result = this.addBackgroundMode(result, "remote-notification");
+		}
+
+		if (pluginConfig.silentNotifications) {
+			result = this.addBackgroundMode(result, "fetch");
+		}
+
+		// iOS: Add UserNotifications framework
+		result = this.addFramework(result, "UserNotifications");
+
+		// Android: Add POST_NOTIFICATIONS permission (Android 13+)
+		result = this.addAndroidPermission(result, "android.permission.POST_NOTIFICATIONS");
+
+		// Android: Add RECEIVE_BOOT_COMPLETED for scheduling
+		result = this.addAndroidPermission(result, "android.permission.RECEIVE_BOOT_COMPLETED");
+
+		// Android: Add VIBRATE permission
+		result = this.addAndroidPermission(result, "android.permission.VIBRATE");
+
+		// Android: Add wake lock for background processing
+		result = this.addAndroidPermission(result, "android.permission.WAKE_LOCK");
+
+		// Android: Add default notification icon metadata
+		if (pluginConfig.defaultIcon) {
+			result = this.addAndroidMetadata(
+				result,
+				"com.google.firebase.messaging.default_notification_icon",
+				pluginConfig.defaultIcon
+			);
+		}
+
+		// Android: Add default notification channel
+		result = this.addAndroidMetadata(
+			result,
+			"com.google.firebase.messaging.default_notification_channel_id",
+			pluginConfig.defaultChannelId ?? "default"
+		);
+
+		return result;
+	}
+}

package/src/plugins/capabilities/sign-in-with-apple.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Sign in with Apple plugin configuration schema
+ */
+export const SignInWithApplePluginConfigSchema = z.object({
+	/** Enable Sign in with Apple */
+	enabled: z.boolean().optional().default(true),
+});
+
+export type SignInWithApplePluginConfig = z.infer<typeof SignInWithApplePluginConfigSchema>;
+
+/**
+ * Sign in with Apple capability plugin
+ */
+export class SignInWithApplePlugin extends BasePlugin<SignInWithApplePluginConfig> {
+	readonly name = "sign-in-with-apple";
+	readonly version = "1.0.0";
+	readonly description = "Configure Sign in with Apple authentication";
+	readonly configSchema = SignInWithApplePluginConfigSchema;
+
+	override provides = ["sign-in-with-apple", "apple-auth"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: SignInWithApplePluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+
+		if (!pluginConfig.enabled) {
+			return config;
+		}
+
+		log.debug("Applying Sign in with Apple configuration...");
+
+		let result = config;
+
+		// iOS: Add entitlement
+		result = this.addEntitlement(result, "com.apple.developer.applesignin", ["Default"]);
+
+		// iOS: Add AuthenticationServices framework
+		result = this.addFramework(result, "AuthenticationServices");
+
+		// Android: No native configuration required (uses web-based OAuth)
+
+		return result;
+	}
+}