@teardown/cli 1.2.38 → 2.0.41

package/src/plugins/base.ts

@@ -0,0 +1,370 @@
+import type { z } from "zod";
+import type { ProcessedAppConfig } from "../config/types";
+import type { PluginContext } from "./context";
+
+/**
+ * Info.plist entries type
+ */
+export type InfoPlist = Record<string, unknown>;
+
+/**
+ * Entitlements type
+ */
+export type Entitlements = Record<string, unknown>;
+
+/**
+ * Android Manifest type (simplified)
+ */
+export interface AndroidManifest {
+	permissions: string[];
+	features: string[];
+	metadata: Record<string, string>;
+	activities: AndroidActivity[];
+	services: AndroidService[];
+	receivers: AndroidReceiver[];
+	providers: AndroidProvider[];
+}
+
+export interface AndroidActivity {
+	name: string;
+	intentFilters?: AndroidIntentFilter[];
+	exported?: boolean;
+	launchMode?: string;
+	screenOrientation?: string;
+	configChanges?: string;
+}
+
+export interface AndroidIntentFilter {
+	actions: string[];
+	categories: string[];
+	data?: AndroidIntentData[];
+	autoVerify?: boolean;
+}
+
+export interface AndroidIntentData {
+	scheme?: string;
+	host?: string;
+	pathPrefix?: string;
+	path?: string;
+}
+
+export interface AndroidService {
+	name: string;
+	exported?: boolean;
+	permission?: string;
+	intentFilters?: AndroidIntentFilter[];
+}
+
+export interface AndroidReceiver {
+	name: string;
+	exported?: boolean;
+	intentFilters?: AndroidIntentFilter[];
+}
+
+export interface AndroidProvider {
+	name: string;
+	authorities: string;
+	exported?: boolean;
+	grantUriPermissions?: boolean;
+}
+
+/**
+ * Abstract base class for all Teardown plugins
+ *
+ * Plugins extend this class to implement native configuration
+ * for specific capabilities (camera, location, push notifications, etc.)
+ */
+export abstract class BasePlugin<TConfig = unknown> {
+	/**
+	 * Unique plugin identifier
+	 */
+	abstract readonly name: string;
+
+	/**
+	 * Plugin version (semver)
+	 */
+	abstract readonly version: string;
+
+	/**
+	 * Zod schema for validating plugin configuration
+	 */
+	abstract readonly configSchema: z.ZodSchema<TConfig>;
+
+	/**
+	 * Human-readable description of what this plugin does
+	 */
+	abstract readonly description: string;
+
+	/**
+	 * Plugin names that this plugin depends on (must run first)
+	 */
+	dependencies: string[] = [];
+
+	/**
+	 * Capabilities that this plugin provides
+	 */
+	provides: string[] = [];
+
+	/**
+	 * Platforms this plugin supports
+	 */
+	platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	/**
+	 * Validate and parse plugin configuration
+	 */
+	validateConfig(config: unknown): TConfig {
+		return this.configSchema.parse(config);
+	}
+
+	/**
+	 * Check if plugin supports the target platform
+	 */
+	supportsPlatform(platform: "ios" | "android"): boolean {
+		return this.platforms.includes(platform);
+	}
+
+	/**
+	 * Pre-process hook - runs before transform
+	 * Use for validation, setup, or reading existing files
+	 */
+	async preProcess(_context: PluginContext): Promise<void> {
+		// Default implementation does nothing
+	}
+
+	/**
+	 * Main transformation method - modifies the app configuration
+	 * This is the core method that plugins must implement
+	 */
+	abstract transform(config: ProcessedAppConfig, pluginConfig: TConfig, context: PluginContext): ProcessedAppConfig;
+
+	/**
+	 * Post-process hook - runs after transform
+	 * Use for cleanup, file generation, or additional modifications
+	 */
+	async postProcess(_context: PluginContext): Promise<void> {
+		// Default implementation does nothing
+	}
+
+	/**
+	 * Modify iOS Info.plist entries
+	 * Override in subclass to add plist modifications
+	 */
+	protected modifyInfoPlist(plist: InfoPlist, _config: TConfig, _context: PluginContext): InfoPlist {
+		return plist;
+	}
+
+	/**
+	 * Modify iOS entitlements
+	 * Override in subclass to add entitlement modifications
+	 */
+	protected modifyEntitlements(entitlements: Entitlements, _config: TConfig, _context: PluginContext): Entitlements {
+		return entitlements;
+	}
+
+	/**
+	 * Modify Android manifest
+	 * Override in subclass to add manifest modifications
+	 */
+	protected modifyAndroidManifest(
+		manifest: AndroidManifest,
+		_config: TConfig,
+		_context: PluginContext
+	): AndroidManifest {
+		return manifest;
+	}
+
+	/**
+	 * Modify Android build.gradle content
+	 * Override in subclass to add Gradle modifications
+	 */
+	protected modifyBuildGradle(content: string, _config: TConfig, _context: PluginContext): string {
+		return content;
+	}
+
+	/**
+	 * Get iOS frameworks required by this plugin
+	 */
+	protected getRequiredFrameworks(_config: TConfig): string[] {
+		return [];
+	}
+
+	/**
+	 * Get CocoaPods dependencies required by this plugin
+	 */
+	protected getPodDependencies(
+		_config: TConfig
+	): Array<{ name: string; version?: string; options?: Record<string, unknown> }> {
+		return [];
+	}
+
+	/**
+	 * Get Gradle dependencies required by this plugin
+	 */
+	protected getGradleDependencies(_config: TConfig): string[] {
+		return [];
+	}
+
+	/**
+	 * Get Android permissions required by this plugin
+	 */
+	protected getAndroidPermissions(_config: TConfig): string[] {
+		return [];
+	}
+
+	/**
+	 * Get iOS background modes required by this plugin
+	 */
+	protected getBackgroundModes(_config: TConfig): string[] {
+		return [];
+	}
+
+	/**
+	 * Helper to add Info.plist usage description
+	 */
+	protected addUsageDescription(config: ProcessedAppConfig, key: string, description: string): ProcessedAppConfig {
+		return {
+			...config,
+			resolvedInfoPlist: {
+				...config.resolvedInfoPlist,
+				[key]: description,
+			},
+		};
+	}
+
+	/**
+	 * Helper to add iOS entitlement
+	 */
+	protected addEntitlement(config: ProcessedAppConfig, key: string, value: unknown): ProcessedAppConfig {
+		return {
+			...config,
+			resolvedEntitlements: {
+				...config.resolvedEntitlements,
+				[key]: value,
+			},
+		};
+	}
+
+	/**
+	 * Helper to add Android permission
+	 */
+	protected addAndroidPermission(config: ProcessedAppConfig, permission: string): ProcessedAppConfig {
+		if (config.resolvedAndroidPermissions.includes(permission)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedAndroidPermissions: [...config.resolvedAndroidPermissions, permission],
+		};
+	}
+
+	/**
+	 * Helper to add Android feature
+	 */
+	protected addAndroidFeature(config: ProcessedAppConfig, feature: string): ProcessedAppConfig {
+		if (config.resolvedAndroidFeatures.includes(feature)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedAndroidFeatures: [...config.resolvedAndroidFeatures, feature],
+		};
+	}
+
+	/**
+	 * Helper to add iOS background mode
+	 */
+	protected addBackgroundMode(config: ProcessedAppConfig, mode: string): ProcessedAppConfig {
+		if (config.resolvedBackgroundModes.includes(mode)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedBackgroundModes: [...config.resolvedBackgroundModes, mode],
+		};
+	}
+
+	/**
+	 * Helper to add iOS framework
+	 */
+	protected addFramework(config: ProcessedAppConfig, framework: string): ProcessedAppConfig {
+		if (config.resolvedFrameworks.includes(framework)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedFrameworks: [...config.resolvedFrameworks, framework],
+		};
+	}
+
+	/**
+	 * Helper to add Gradle dependency
+	 */
+	protected addGradleDependency(config: ProcessedAppConfig, dependency: string): ProcessedAppConfig {
+		if (config.resolvedGradleDependencies.includes(dependency)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedGradleDependencies: [...config.resolvedGradleDependencies, dependency],
+		};
+	}
+
+	/**
+	 * Helper to add CocoaPods dependency
+	 */
+	protected addPodDependency(
+		config: ProcessedAppConfig,
+		pod: { name: string; version?: string; options?: Record<string, unknown> }
+	): ProcessedAppConfig {
+		const existing = config.resolvedPodDependencies.find((p) => p.name === pod.name);
+		if (existing) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedPodDependencies: [...config.resolvedPodDependencies, pod],
+		};
+	}
+
+	/**
+	 * Helper to add URL scheme
+	 */
+	protected addUrlScheme(config: ProcessedAppConfig, scheme: string): ProcessedAppConfig {
+		if (config.resolvedUrlSchemes.includes(scheme)) {
+			return config;
+		}
+		return {
+			...config,
+			resolvedUrlSchemes: [...config.resolvedUrlSchemes, scheme],
+		};
+	}
+
+	/**
+	 * Helper to add Android intent filter
+	 */
+	protected addIntentFilter(config: ProcessedAppConfig, intentFilter: AndroidIntentFilter): ProcessedAppConfig {
+		return {
+			...config,
+			resolvedIntentFilters: [...config.resolvedIntentFilters, intentFilter],
+		};
+	}
+
+	/**
+	 * Helper to add Android metadata
+	 */
+	protected addAndroidMetadata(config: ProcessedAppConfig, key: string, value: string): ProcessedAppConfig {
+		return {
+			...config,
+			resolvedAndroidMetadata: {
+				...config.resolvedAndroidMetadata,
+				[key]: value,
+			},
+		};
+	}
+}
+
+/**
+ * Plugin constructor type for registration
+ */
+export type PluginConstructor<TConfig = unknown> = new () => BasePlugin<TConfig>;

package/src/plugins/capabilities/biometrics.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Biometrics plugin configuration schema
+ */
+export const BiometricsPluginConfigSchema = z.object({
+	/** iOS Face ID usage description */
+	faceIdPermission: z.string().min(1, "Face ID permission description is required"),
+
+	/** Allow device credential (PIN/password) as fallback */
+	allowDeviceCredentialFallback: z.boolean().optional().default(true),
+});
+
+export type BiometricsPluginConfig = z.infer<typeof BiometricsPluginConfigSchema>;
+
+/**
+ * Biometrics capability plugin
+ *
+ * Configures biometric authentication (Face ID, Touch ID, fingerprint)
+ * for iOS and Android.
+ */
+export class BiometricsPlugin extends BasePlugin<BiometricsPluginConfig> {
+	readonly name = "biometrics";
+	readonly version = "1.0.0";
+	readonly description = "Configure biometric authentication (Face ID, Touch ID, fingerprint)";
+	readonly configSchema = BiometricsPluginConfigSchema;
+
+	override provides = ["biometrics", "authentication"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: BiometricsPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying biometrics configuration...");
+
+		let result = config;
+
+		// iOS: Add Face ID usage description
+		result = this.addUsageDescription(result, "NSFaceIDUsageDescription", pluginConfig.faceIdPermission);
+
+		// iOS: Add LocalAuthentication framework
+		result = this.addFramework(result, "LocalAuthentication");
+
+		// Android: Add biometric permission
+		result = this.addAndroidPermission(result, "android.permission.USE_BIOMETRIC");
+
+		// Android: Add fingerprint permission (for older devices)
+		result = this.addAndroidPermission(result, "android.permission.USE_FINGERPRINT");
+
+		// Android: Add biometric feature (optional)
+		result = this.addAndroidFeature(result, "android.hardware.fingerprint");
+
+		// Android: Add androidx.biometric dependency
+		result = this.addGradleDependency(result, "androidx.biometric:biometric:1.2.0-alpha05");
+
+		return result;
+	}
+}

package/src/plugins/capabilities/bluetooth.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Bluetooth plugin configuration schema
+ */
+export const BluetoothPluginConfigSchema = z.object({
+	/** iOS Bluetooth always-on permission description */
+	alwaysPermission: z.string().min(1, "Bluetooth permission description is required"),
+
+	/** Enable BLE central mode (connecting to devices) */
+	centralMode: z.boolean().optional().default(true),
+
+	/** Enable BLE peripheral mode (advertising) */
+	peripheralMode: z.boolean().optional().default(false),
+
+	/** Enable background Bluetooth */
+	backgroundMode: z.boolean().optional().default(false),
+});
+
+export type BluetoothPluginConfig = z.infer<typeof BluetoothPluginConfigSchema>;
+
+/**
+ * Bluetooth capability plugin
+ */
+export class BluetoothPlugin extends BasePlugin<BluetoothPluginConfig> {
+	readonly name = "bluetooth";
+	readonly version = "1.0.0";
+	readonly description = "Configure Bluetooth Low Energy (BLE) access";
+	readonly configSchema = BluetoothPluginConfigSchema;
+
+	override provides = ["bluetooth", "ble"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: BluetoothPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying Bluetooth configuration...");
+
+		let result = config;
+
+		// iOS: Add Bluetooth usage description
+		result = this.addUsageDescription(result, "NSBluetoothAlwaysUsageDescription", pluginConfig.alwaysPermission);
+
+		// iOS: Legacy Bluetooth peripheral description
+		result = this.addUsageDescription(result, "NSBluetoothPeripheralUsageDescription", pluginConfig.alwaysPermission);
+
+		// iOS: Add CoreBluetooth framework
+		result = this.addFramework(result, "CoreBluetooth");
+
+		// iOS: Add background modes
+		if (pluginConfig.backgroundMode) {
+			if (pluginConfig.centralMode) {
+				result = this.addBackgroundMode(result, "bluetooth-central");
+			}
+			if (pluginConfig.peripheralMode) {
+				result = this.addBackgroundMode(result, "bluetooth-peripheral");
+			}
+		}
+
+		// Android: Add Bluetooth permissions (API 31+)
+		result = this.addAndroidPermission(result, "android.permission.BLUETOOTH_SCAN");
+		result = this.addAndroidPermission(result, "android.permission.BLUETOOTH_CONNECT");
+
+		if (pluginConfig.peripheralMode) {
+			result = this.addAndroidPermission(result, "android.permission.BLUETOOTH_ADVERTISE");
+		}
+
+		// Android: Legacy Bluetooth permissions
+		result = this.addAndroidPermission(result, "android.permission.BLUETOOTH");
+		result = this.addAndroidPermission(result, "android.permission.BLUETOOTH_ADMIN");
+
+		// Android: Location permission (required for BLE scanning on older versions)
+		result = this.addAndroidPermission(result, "android.permission.ACCESS_FINE_LOCATION");
+
+		// Android: Add Bluetooth LE feature
+		result = this.addAndroidFeature(result, "android.hardware.bluetooth_le");
+
+		return result;
+	}
+}

package/src/plugins/capabilities/calendar.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Calendar plugin configuration schema
+ */
+export const CalendarPluginConfigSchema = z.object({
+	/** iOS calendar usage description */
+	permission: z.string().min(1, "Calendar permission description is required"),
+
+	/** Enable write access to calendar */
+	writeAccess: z.boolean().optional().default(false),
+});
+
+export type CalendarPluginConfig = z.infer<typeof CalendarPluginConfigSchema>;
+
+/**
+ * Calendar capability plugin
+ */
+export class CalendarPlugin extends BasePlugin<CalendarPluginConfig> {
+	readonly name = "calendar";
+	readonly version = "1.0.0";
+	readonly description = "Configure calendar access for reading and writing events";
+	readonly configSchema = CalendarPluginConfigSchema;
+
+	override provides = ["calendar"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: CalendarPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying calendar configuration...");
+
+		let result = config;
+
+		// iOS: Add usage description
+		result = this.addUsageDescription(result, "NSCalendarsUsageDescription", pluginConfig.permission);
+
+		// iOS: Add EventKit framework
+		result = this.addFramework(result, "EventKit");
+
+		// Android: Add read permission
+		result = this.addAndroidPermission(result, "android.permission.READ_CALENDAR");
+
+		// Android: Add write permission if needed
+		if (pluginConfig.writeAccess) {
+			result = this.addAndroidPermission(result, "android.permission.WRITE_CALENDAR");
+		}
+
+		return result;
+	}
+}

package/src/plugins/capabilities/camera.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Camera plugin configuration schema
+ */
+export const CameraPluginConfigSchema = z.object({
+	/** iOS camera usage description */
+	cameraPermission: z.string().min(1, "Camera permission description is required"),
+
+	/** iOS microphone usage description (for video recording) */
+	microphonePermission: z.string().optional(),
+
+	/** iOS photo library usage description */
+	photosPermission: z.string().optional(),
+
+	/** Enable barcode scanning support */
+	enableBarcodeScan: z.boolean().optional().default(false),
+});
+
+export type CameraPluginConfig = z.infer<typeof CameraPluginConfigSchema>;
+
+/**
+ * Camera capability plugin
+ *
+ * Configures camera access for iOS and Android including
+ * permissions, frameworks, and optional barcode scanning.
+ */
+export class CameraPlugin extends BasePlugin<CameraPluginConfig> {
+	readonly name = "camera";
+	readonly version = "1.0.0";
+	readonly description = "Configure camera access for capturing photos and videos";
+	readonly configSchema = CameraPluginConfigSchema;
+
+	override provides = ["camera"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(config: ProcessedAppConfig, pluginConfig: CameraPluginConfig, context: PluginContext): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying camera configuration...");
+
+		let result = config;
+
+		// iOS: Add usage descriptions
+		result = this.addUsageDescription(result, "NSCameraUsageDescription", pluginConfig.cameraPermission);
+
+		if (pluginConfig.microphonePermission) {
+			result = this.addUsageDescription(result, "NSMicrophoneUsageDescription", pluginConfig.microphonePermission);
+		}
+
+		if (pluginConfig.photosPermission) {
+			result = this.addUsageDescription(result, "NSPhotoLibraryUsageDescription", pluginConfig.photosPermission);
+		}
+
+		// iOS: Add frameworks
+		result = this.addFramework(result, "AVFoundation");
+
+		if (pluginConfig.enableBarcodeScan) {
+			result = this.addFramework(result, "Vision");
+		}
+
+		// Android: Add permissions
+		result = this.addAndroidPermission(result, "android.permission.CAMERA");
+
+		if (pluginConfig.microphonePermission) {
+			result = this.addAndroidPermission(result, "android.permission.RECORD_AUDIO");
+		}
+
+		// Android: Add camera feature
+		result = this.addAndroidFeature(result, "android.hardware.camera");
+		result = this.addAndroidFeature(result, "android.hardware.camera.autofocus");
+
+		return result;
+	}
+}

package/src/plugins/capabilities/contacts.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import type { ProcessedAppConfig } from "../../config/types";
+import { BasePlugin } from "../base";
+import type { PluginContext } from "../context";
+
+/**
+ * Contacts plugin configuration schema
+ */
+export const ContactsPluginConfigSchema = z.object({
+	/** iOS contacts usage description */
+	permission: z.string().min(1, "Contacts permission description is required"),
+
+	/** Enable write access to contacts */
+	writeAccess: z.boolean().optional().default(false),
+});
+
+export type ContactsPluginConfig = z.infer<typeof ContactsPluginConfigSchema>;
+
+/**
+ * Contacts capability plugin
+ */
+export class ContactsPlugin extends BasePlugin<ContactsPluginConfig> {
+	readonly name = "contacts";
+	readonly version = "1.0.0";
+	readonly description = "Configure contacts access for reading and writing contacts";
+	readonly configSchema = ContactsPluginConfigSchema;
+
+	override provides = ["contacts"];
+	override platforms: ("ios" | "android")[] = ["ios", "android"];
+
+	transform(
+		config: ProcessedAppConfig,
+		pluginConfig: ContactsPluginConfig,
+		context: PluginContext
+	): ProcessedAppConfig {
+		const { log } = context;
+		log.debug("Applying contacts configuration...");
+
+		let result = config;
+
+		// iOS: Add usage description
+		result = this.addUsageDescription(result, "NSContactsUsageDescription", pluginConfig.permission);
+
+		// iOS: Add Contacts framework
+		result = this.addFramework(result, "Contacts");
+
+		// Android: Add read permission
+		result = this.addAndroidPermission(result, "android.permission.READ_CONTACTS");
+
+		// Android: Add write permission if needed
+		if (pluginConfig.writeAccess) {
+			result = this.addAndroidPermission(result, "android.permission.WRITE_CONTACTS");
+		}
+
+		return result;
+	}
+}