@teardown/cli 1.2.38 → 2.0.41

package/src/transformers/android/manifest.ts

@@ -0,0 +1,506 @@
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+import type { AndroidIntentFilter, ProcessedAppConfig } from "../../config/types";
+import type { PluginContext } from "../../plugins/context";
+
+/**
+ * Android Manifest structure (parsed from XML)
+ */
+export interface AndroidManifestXml {
+	"?xml"?: {
+		"@_version": string;
+		"@_encoding": string;
+	};
+	manifest: {
+		"@_xmlns:android": string;
+		"@_package": string;
+		"uses-permission"?: AndroidPermission[];
+		"uses-feature"?: AndroidFeature[];
+		queries?: AndroidQueries;
+		application: AndroidApplication;
+	};
+}
+
+export interface AndroidPermission {
+	"@_android:name": string;
+	"@_android:maxSdkVersion"?: string;
+}
+
+export interface AndroidFeature {
+	"@_android:name": string;
+	"@_android:required"?: string;
+}
+
+export interface AndroidQueries {
+	package?: Array<{ "@_android:name": string }>;
+	intent?: AndroidIntentXml[];
+}
+
+export interface AndroidApplication {
+	"@_android:name"?: string;
+	"@_android:label"?: string;
+	"@_android:icon"?: string;
+	"@_android:roundIcon"?: string;
+	"@_android:allowBackup"?: string;
+	"@_android:theme"?: string;
+	"@_android:networkSecurityConfig"?: string;
+	"@_android:supportsRtl"?: string;
+	activity?: AndroidActivityXml[];
+	service?: AndroidServiceXml[];
+	receiver?: AndroidReceiverXml[];
+	provider?: AndroidProviderXml[];
+	"meta-data"?: AndroidMetaData[];
+}
+
+export interface AndroidActivityXml {
+	"@_android:name": string;
+	"@_android:label"?: string;
+	"@_android:exported"?: string;
+	"@_android:launchMode"?: string;
+	"@_android:screenOrientation"?: string;
+	"@_android:configChanges"?: string;
+	"@_android:windowSoftInputMode"?: string;
+	"@_android:theme"?: string;
+	"intent-filter"?: AndroidIntentFilterXml[];
+}
+
+export interface AndroidIntentFilterXml {
+	"@_android:autoVerify"?: string;
+	action?: Array<{ "@_android:name": string }>;
+	category?: Array<{ "@_android:name": string }>;
+	data?: Array<{
+		"@_android:scheme"?: string;
+		"@_android:host"?: string;
+		"@_android:pathPrefix"?: string;
+		"@_android:path"?: string;
+	}>;
+}
+
+export interface AndroidIntentXml {
+	action?: Array<{ "@_android:name": string }>;
+	data?: Array<{
+		"@_android:scheme"?: string;
+		"@_android:host"?: string;
+	}>;
+}
+
+export interface AndroidServiceXml {
+	"@_android:name": string;
+	"@_android:exported"?: string;
+	"@_android:permission"?: string;
+	"intent-filter"?: AndroidIntentFilterXml[];
+	"meta-data"?: AndroidMetaData[];
+}
+
+export interface AndroidReceiverXml {
+	"@_android:name": string;
+	"@_android:exported"?: string;
+	"intent-filter"?: AndroidIntentFilterXml[];
+}
+
+export interface AndroidProviderXml {
+	"@_android:name": string;
+	"@_android:authorities": string;
+	"@_android:exported"?: string;
+	"@_android:grantUriPermissions"?: string;
+}
+
+export interface AndroidMetaData {
+	"@_android:name": string;
+	"@_android:value"?: string;
+	"@_android:resource"?: string;
+}
+
+/**
+ * XML Parser configuration
+ */
+const parserOptions = {
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	allowBooleanAttributes: true,
+	parseAttributeValue: false,
+	trimValues: true,
+	isArray: (name: string) => {
+		// These elements should always be treated as arrays even if there's only one
+		const alwaysArray = [
+			"uses-permission",
+			"uses-feature",
+			"activity",
+			"service",
+			"receiver",
+			"provider",
+			"meta-data",
+			"intent-filter",
+			"action",
+			"category",
+			"data",
+			"package",
+			"intent",
+		];
+		return alwaysArray.includes(name);
+	},
+};
+
+const builderOptions = {
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	format: true,
+	indentBy: "    ",
+	suppressEmptyNode: false,
+};
+
+/**
+ * Android Manifest transformer
+ */
+export class AndroidManifestTransformer {
+	private parser: XMLParser;
+	private builder: XMLBuilder;
+
+	constructor() {
+		this.parser = new XMLParser(parserOptions);
+		this.builder = new XMLBuilder(builderOptions);
+	}
+
+	/**
+	 * Transform the AndroidManifest.xml with configuration
+	 */
+	async transform(context: PluginContext, config: ProcessedAppConfig): Promise<void> {
+		const { fs, log, androidPaths } = context;
+
+		log.debug("Transforming AndroidManifest.xml...");
+
+		let content: string;
+
+		try {
+			content = await fs.readFile(androidPaths.manifest);
+		} catch {
+			log.warn("AndroidManifest.xml not found, creating default manifest");
+			content = this.createDefaultManifest(config);
+		}
+
+		// Parse XML
+		const manifest = this.parser.parse(content) as AndroidManifestXml;
+
+		// Apply transformations
+		this.applyPackageName(manifest, config);
+		this.applyPermissions(manifest, config);
+		this.applyFeatures(manifest, config);
+		this.applyMetadata(manifest, config);
+		this.applyIntentFilters(manifest, config);
+
+		// Build XML
+		const xmlHeader = '<?xml version="1.0" encoding="utf-8"?>\n';
+		const updatedContent = xmlHeader + this.builder.build(manifest);
+
+		// Write back
+		await fs.writeFile(androidPaths.manifest, updatedContent);
+
+		log.debug("AndroidManifest.xml transformation complete");
+	}
+
+	/**
+	 * Create default AndroidManifest.xml
+	 */
+	private createDefaultManifest(config: ProcessedAppConfig): string {
+		const packageName = config.android?.packageName ?? "com.example.app";
+
+		return `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="${packageName}">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+        android:name=".MainApplication"
+        android:label="@string/app_name"
+        android:icon="@mipmap/ic_launcher"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:allowBackup="false"
+        android:theme="@style/AppTheme">
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name"
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|screenLayout|uiMode"
+            android:windowSoftInputMode="adjustResize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>`;
+	}
+
+	/**
+	 * Apply package name to manifest
+	 */
+	private applyPackageName(manifest: AndroidManifestXml, config: ProcessedAppConfig): void {
+		if (config.android?.packageName) {
+			manifest.manifest["@_package"] = config.android.packageName;
+		}
+	}
+
+	/**
+	 * Apply permissions to manifest
+	 */
+	private applyPermissions(manifest: AndroidManifestXml, config: ProcessedAppConfig): void {
+		if (!manifest.manifest["uses-permission"]) {
+			manifest.manifest["uses-permission"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest["uses-permission"])) {
+			manifest.manifest["uses-permission"] = [manifest.manifest["uses-permission"]];
+		}
+
+		const existingPermissions = new Set(manifest.manifest["uses-permission"].map((p) => p["@_android:name"]));
+
+		for (const permission of config.resolvedAndroidPermissions) {
+			if (!existingPermissions.has(permission)) {
+				manifest.manifest["uses-permission"].push({
+					"@_android:name": permission,
+				});
+			}
+		}
+	}
+
+	/**
+	 * Apply features to manifest
+	 */
+	private applyFeatures(manifest: AndroidManifestXml, config: ProcessedAppConfig): void {
+		if (!manifest.manifest["uses-feature"]) {
+			manifest.manifest["uses-feature"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest["uses-feature"])) {
+			manifest.manifest["uses-feature"] = [manifest.manifest["uses-feature"]];
+		}
+
+		const existingFeatures = new Set(manifest.manifest["uses-feature"].map((f) => f["@_android:name"]));
+
+		for (const feature of config.resolvedAndroidFeatures) {
+			if (!existingFeatures.has(feature)) {
+				manifest.manifest["uses-feature"].push({
+					"@_android:name": feature,
+					"@_android:required": "true",
+				});
+			}
+		}
+	}
+
+	/**
+	 * Apply metadata to manifest
+	 */
+	private applyMetadata(manifest: AndroidManifestXml, config: ProcessedAppConfig): void {
+		if (!manifest.manifest.application["meta-data"]) {
+			manifest.manifest.application["meta-data"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest.application["meta-data"])) {
+			manifest.manifest.application["meta-data"] = [manifest.manifest.application["meta-data"]];
+		}
+
+		const existingMetadata = new Map(manifest.manifest.application["meta-data"].map((m) => [m["@_android:name"], m]));
+
+		for (const [key, value] of Object.entries(config.resolvedAndroidMetadata)) {
+			if (existingMetadata.has(key)) {
+				// Update existing
+				const existing = existingMetadata.get(key)!;
+				existing["@_android:value"] = value;
+			} else {
+				// Add new
+				manifest.manifest.application["meta-data"].push({
+					"@_android:name": key,
+					"@_android:value": value,
+				});
+			}
+		}
+	}
+
+	/**
+	 * Apply intent filters to MainActivity
+	 */
+	private applyIntentFilters(manifest: AndroidManifestXml, config: ProcessedAppConfig): void {
+		if (config.resolvedIntentFilters.length === 0 && !config.scheme) {
+			return;
+		}
+
+		// Find MainActivity
+		let activities = manifest.manifest.application.activity;
+		if (!activities) {
+			return;
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(activities)) {
+			activities = [activities];
+			manifest.manifest.application.activity = activities;
+		}
+
+		if (activities.length === 0) {
+			return;
+		}
+
+		const mainActivity = activities.find((a) => a["@_android:name"] === ".MainActivity") || activities[0];
+
+		if (!mainActivity["intent-filter"]) {
+			mainActivity["intent-filter"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(mainActivity["intent-filter"])) {
+			mainActivity["intent-filter"] = [mainActivity["intent-filter"]];
+		}
+
+		// Add custom scheme if configured
+		if (config.scheme) {
+			const schemeFilter: AndroidIntentFilterXml = {
+				action: [{ "@_android:name": "android.intent.action.VIEW" }],
+				category: [
+					{ "@_android:name": "android.intent.category.DEFAULT" },
+					{ "@_android:name": "android.intent.category.BROWSABLE" },
+				],
+				data: [{ "@_android:scheme": config.scheme }],
+			};
+			mainActivity["intent-filter"].push(schemeFilter);
+		}
+
+		// Add resolved intent filters
+		for (const filter of config.resolvedIntentFilters) {
+			const xmlFilter = this.convertIntentFilter(filter);
+			mainActivity["intent-filter"].push(xmlFilter);
+		}
+	}
+
+	/**
+	 * Convert internal intent filter to XML format
+	 */
+	private convertIntentFilter(filter: AndroidIntentFilter): AndroidIntentFilterXml {
+		const xmlFilter: AndroidIntentFilterXml = {};
+
+		if (filter.autoVerify) {
+			xmlFilter["@_android:autoVerify"] = "true";
+		}
+
+		if (filter.actions.length > 0) {
+			xmlFilter.action = filter.actions.map((a) => ({ "@_android:name": a }));
+		}
+
+		if (filter.categories.length > 0) {
+			xmlFilter.category = filter.categories.map((c) => ({ "@_android:name": c }));
+		}
+
+		if (filter.data && filter.data.length > 0) {
+			xmlFilter.data = filter.data.map((d) => ({
+				...(d.scheme && { "@_android:scheme": d.scheme }),
+				...(d.host && { "@_android:host": d.host }),
+				...(d.pathPrefix && { "@_android:pathPrefix": d.pathPrefix }),
+			}));
+		}
+
+		return xmlFilter;
+	}
+
+	/**
+	 * Add a permission to an existing manifest
+	 */
+	static addPermission(manifest: AndroidManifestXml, permission: string): void {
+		if (!manifest.manifest["uses-permission"]) {
+			manifest.manifest["uses-permission"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest["uses-permission"])) {
+			manifest.manifest["uses-permission"] = [manifest.manifest["uses-permission"]];
+		}
+
+		const exists = manifest.manifest["uses-permission"].some((p) => p["@_android:name"] === permission);
+
+		if (!exists) {
+			manifest.manifest["uses-permission"].push({
+				"@_android:name": permission,
+			});
+		}
+	}
+
+	/**
+	 * Add a feature to an existing manifest
+	 */
+	static addFeature(manifest: AndroidManifestXml, feature: string, required = true): void {
+		if (!manifest.manifest["uses-feature"]) {
+			manifest.manifest["uses-feature"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest["uses-feature"])) {
+			manifest.manifest["uses-feature"] = [manifest.manifest["uses-feature"]];
+		}
+
+		const exists = manifest.manifest["uses-feature"].some((f) => f["@_android:name"] === feature);
+
+		if (!exists) {
+			manifest.manifest["uses-feature"].push({
+				"@_android:name": feature,
+				"@_android:required": String(required),
+			});
+		}
+	}
+
+	/**
+	 * Add metadata to the application
+	 */
+	static addMetadata(manifest: AndroidManifestXml, name: string, value: string, isResource = false): void {
+		if (!manifest.manifest.application["meta-data"]) {
+			manifest.manifest.application["meta-data"] = [];
+		}
+
+		// Normalize to array if XML parser returned a single object
+		if (!Array.isArray(manifest.manifest.application["meta-data"])) {
+			manifest.manifest.application["meta-data"] = [manifest.manifest.application["meta-data"]];
+		}
+
+		const existing = manifest.manifest.application["meta-data"].find((m) => m["@_android:name"] === name);
+
+		if (existing) {
+			if (isResource) {
+				existing["@_android:resource"] = value;
+				delete existing["@_android:value"];
+			} else {
+				existing["@_android:value"] = value;
+				delete existing["@_android:resource"];
+			}
+		} else {
+			const metadata: AndroidMetaData = {
+				"@_android:name": name,
+			};
+
+			if (isResource) {
+				metadata["@_android:resource"] = value;
+			} else {
+				metadata["@_android:value"] = value;
+			}
+
+			manifest.manifest.application["meta-data"].push(metadata);
+		}
+	}
+
+	/**
+	 * Parse an AndroidManifest.xml file
+	 */
+	static parse(content: string): AndroidManifestXml {
+		const parser = new XMLParser(parserOptions);
+		return parser.parse(content) as AndroidManifestXml;
+	}
+
+	/**
+	 * Build XML from AndroidManifest object
+	 */
+	static build(manifest: AndroidManifestXml): string {
+		const builder = new XMLBuilder(builderOptions);
+		const xmlHeader = '<?xml version="1.0" encoding="utf-8"?>\n';
+		return xmlHeader + builder.build(manifest);
+	}
+}

package/src/transformers/index.ts

@@ -0,0 +1,39 @@
+/**
+ * File transformers for Teardown Launchpad
+ *
+ * Provides transformers for native iOS and Android files
+ * including plist, entitlements, Xcode project, manifest, and Gradle.
+ */
+
+export type {
+	AndroidActivityXml,
+	AndroidApplication,
+	AndroidFeature,
+	AndroidIntentFilterXml,
+	AndroidManifestXml,
+	AndroidMetaData,
+	AndroidPermission,
+	AndroidProviderXml,
+	AndroidQueries,
+	AndroidReceiverXml,
+	AndroidServiceXml,
+} from "./android";
+// Android transformers
+export {
+	AndroidManifestTransformer,
+	GradleTransformer,
+	StringsTransformer,
+} from "./android";
+export type {
+	BuildSettings,
+	CFBundleURLType,
+	EntitlementsContent,
+	InfoPlistContent,
+} from "./ios";
+// iOS transformers
+export {
+	EntitlementsTransformer,
+	PbxprojTransformer,
+	PlistTransformer,
+	XcodeProjectManipulator,
+} from "./ios";