@teardown/cli 1.2.38 → 2.0.41

package/src/transformers/ios/plist.ts

@@ -0,0 +1,198 @@
+import * as plist from "simple-plist";
+import type { ProcessedAppConfig } from "../../config/types";
+import type { PluginContext } from "../../plugins/context";
+
+/**
+ * Info.plist structure
+ */
+export interface InfoPlistContent {
+	CFBundleName: string;
+	CFBundleDisplayName: string;
+	CFBundleIdentifier: string;
+	CFBundleVersion: string;
+	CFBundleShortVersionString: string;
+	CFBundlePackageType: string;
+	CFBundleExecutable: string;
+	UILaunchStoryboardName: string;
+	UIRequiredDeviceCapabilities: string[];
+	UISupportedInterfaceOrientations: string[];
+	UIStatusBarStyle?: string;
+	UIViewControllerBasedStatusBarAppearance?: boolean;
+	UIBackgroundModes?: string[];
+	LSApplicationQueriesSchemes?: string[];
+	CFBundleURLTypes?: CFBundleURLType[];
+	NSAppTransportSecurity?: {
+		NSAllowsArbitraryLoads?: boolean;
+		NSAllowsLocalNetworking?: boolean;
+		NSExceptionDomains?: Record<string, unknown>;
+	};
+	[key: string]: unknown;
+}
+
+export interface CFBundleURLType {
+	CFBundleURLName?: string;
+	CFBundleURLSchemes: string[];
+	CFBundleTypeRole?: string;
+}
+
+/**
+ * Plist transformer for iOS Info.plist files
+ */
+export class PlistTransformer {
+	/**
+	 * Transform the Info.plist file with configuration
+	 */
+	async transform(context: PluginContext, config: ProcessedAppConfig): Promise<void> {
+		const { fs, log, iosPaths } = context;
+
+		log.debug("Transforming Info.plist...");
+
+		let existingPlist: InfoPlistContent;
+
+		try {
+			const content = await fs.readFile(iosPaths.infoPlist);
+			existingPlist = plist.parse(content) as InfoPlistContent;
+		} catch {
+			// Create default plist if doesn't exist
+			existingPlist = this.createDefaultPlist(config);
+		}
+
+		// Apply configuration
+		const updatedPlist = this.applyConfig(existingPlist, config);
+
+		// Write back
+		const plistContent = plist.stringify(updatedPlist);
+		await fs.writeFile(iosPaths.infoPlist, plistContent);
+
+		log.debug("Info.plist transformation complete");
+	}
+
+	/**
+	 * Create default Info.plist content
+	 */
+	private createDefaultPlist(config: ProcessedAppConfig): InfoPlistContent {
+		const appName = config.name.replace(/[^a-zA-Z0-9]/g, "");
+
+		return {
+			CFBundleName: config.name,
+			CFBundleDisplayName: config.name,
+			CFBundleIdentifier: config.ios?.bundleIdentifier ?? "com.example.app",
+			CFBundleVersion: String(config.ios?.buildNumber ?? 1),
+			CFBundleShortVersionString: config.version,
+			CFBundlePackageType: "APPL",
+			CFBundleExecutable: appName,
+			UILaunchStoryboardName: "LaunchScreen",
+			UIRequiredDeviceCapabilities: ["arm64"],
+			UISupportedInterfaceOrientations: this.getOrientations(config),
+		};
+	}
+
+	/**
+	 * Apply configuration to existing plist
+	 */
+	private applyConfig(plist: InfoPlistContent, config: ProcessedAppConfig): InfoPlistContent {
+		// Update basic info
+		plist.CFBundleName = config.name;
+		plist.CFBundleDisplayName = config.name;
+		plist.CFBundleIdentifier = config.ios?.bundleIdentifier ?? plist.CFBundleIdentifier;
+		plist.CFBundleVersion = String(config.ios?.buildNumber ?? 1);
+		plist.CFBundleShortVersionString = config.version;
+
+		// Apply orientation
+		plist.UISupportedInterfaceOrientations = this.getOrientations(config);
+
+		// Apply user interface style
+		if (config.userInterfaceStyle === "light") {
+			plist.UIUserInterfaceStyle = "Light";
+		} else if (config.userInterfaceStyle === "dark") {
+			plist.UIUserInterfaceStyle = "Dark";
+		}
+
+		// Apply background modes
+		if (config.resolvedBackgroundModes.length > 0) {
+			plist.UIBackgroundModes = config.resolvedBackgroundModes;
+		}
+
+		// Apply URL schemes
+		if (config.resolvedUrlSchemes.length > 0 || config.scheme) {
+			const schemes = [...config.resolvedUrlSchemes];
+			if (config.scheme && !schemes.includes(config.scheme)) {
+				schemes.push(config.scheme);
+			}
+
+			plist.CFBundleURLTypes = plist.CFBundleURLTypes ?? [];
+
+			for (const scheme of schemes) {
+				// Check if scheme already exists
+				const existing = plist.CFBundleURLTypes.find((t) => t.CFBundleURLSchemes.includes(scheme));
+
+				if (!existing) {
+					plist.CFBundleURLTypes.push({
+						CFBundleURLName: config.ios?.bundleIdentifier ?? "",
+						CFBundleURLSchemes: [scheme],
+						CFBundleTypeRole: "Editor",
+					});
+				}
+			}
+		}
+
+		// Apply plugin-resolved Info.plist entries (permissions, etc.)
+		for (const [key, value] of Object.entries(config.resolvedInfoPlist)) {
+			plist[key] = value;
+		}
+
+		// Apply custom Info.plist entries from config
+		if (config.ios?.infoPlist) {
+			for (const [key, value] of Object.entries(config.ios.infoPlist)) {
+				plist[key] = value;
+			}
+		}
+
+		return plist;
+	}
+
+	/**
+	 * Get supported interface orientations based on config
+	 */
+	private getOrientations(config: ProcessedAppConfig): string[] {
+		const orientations: string[] = [];
+
+		switch (config.orientation) {
+			case "portrait":
+				orientations.push("UIInterfaceOrientationPortrait");
+				orientations.push("UIInterfaceOrientationPortraitUpsideDown");
+				break;
+			case "landscape":
+				orientations.push("UIInterfaceOrientationLandscapeLeft");
+				orientations.push("UIInterfaceOrientationLandscapeRight");
+				break;
+			default:
+				orientations.push(
+					"UIInterfaceOrientationPortrait",
+					"UIInterfaceOrientationPortraitUpsideDown",
+					"UIInterfaceOrientationLandscapeLeft",
+					"UIInterfaceOrientationLandscapeRight"
+				);
+		}
+
+		return orientations;
+	}
+
+	/**
+	 * Read and parse an existing plist file
+	 */
+	static async readPlist(filePath: string): Promise<InfoPlistContent> {
+		const fs = await import("node:fs/promises");
+		const content = await fs.readFile(filePath, "utf-8");
+		return plist.parse(content) as InfoPlistContent;
+	}
+
+	/**
+	 * Write plist content to file
+	 */
+	static async writePlist(filePath: string, content: InfoPlistContent): Promise<void> {
+		const fs = await import("node:fs/promises");
+		const plistContent = plist.stringify(content);
+		await fs.writeFile(filePath, plistContent, "utf-8");
+	}
+}

package/src/utils/fs.ts

@@ -0,0 +1,429 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { FileChange } from "../config/types";
+
+/**
+ * Virtual file system that can operate in dry-run mode
+ *
+ * In normal mode, operations are performed on the real filesystem.
+ * In dry-run mode, operations are recorded but not applied.
+ */
+export interface VirtualFileSystem {
+	/**
+	 * Read a file
+	 */
+	readFile(filePath: string): Promise<string>;
+
+	/**
+	 * Read a file synchronously
+	 */
+	readFileSync(filePath: string): string;
+
+	/**
+	 * Write a file
+	 */
+	writeFile(filePath: string, content: string): Promise<void>;
+
+	/**
+	 * Write a file synchronously
+	 */
+	writeFileSync(filePath: string, content: string): void;
+
+	/**
+	 * Check if a file exists
+	 */
+	exists(filePath: string): Promise<boolean>;
+
+	/**
+	 * Check if a file exists synchronously
+	 */
+	existsSync(filePath: string): boolean;
+
+	/**
+	 * Create a directory recursively
+	 */
+	mkdir(dirPath: string): Promise<void>;
+
+	/**
+	 * Create a directory recursively synchronously
+	 */
+	mkdirSync(dirPath: string): void;
+
+	/**
+	 * Delete a file
+	 */
+	unlink(filePath: string): Promise<void>;
+
+	/**
+	 * Delete a file synchronously
+	 */
+	unlinkSync(filePath: string): void;
+
+	/**
+	 * Delete a directory recursively
+	 */
+	rmdir(dirPath: string): Promise<void>;
+
+	/**
+	 * Copy a file
+	 */
+	copyFile(src: string, dest: string): Promise<void>;
+
+	/**
+	 * Copy a file synchronously
+	 */
+	copyFileSync(src: string, dest: string): void;
+
+	/**
+	 * Get all recorded changes (for dry-run mode)
+	 */
+	getChanges(): FileChange[];
+
+	/**
+	 * Commit all pending changes to the real filesystem
+	 */
+	commit(): Promise<void>;
+
+	/**
+	 * Check if operating in dry-run mode
+	 */
+	isDryRun(): boolean;
+}
+
+/**
+ * Create a virtual file system
+ */
+export function createVirtualFileSystem(options: { dryRun?: boolean; projectRoot: string }): VirtualFileSystem {
+	const { dryRun = false, projectRoot } = options;
+	const changes: FileChange[] = [];
+	const virtualFiles: Map<string, string> = new Map();
+	const deletedFiles: Set<string> = new Set();
+
+	/**
+	 * Normalize path to absolute
+	 */
+	const normalizePath = (filePath: string): string => {
+		if (path.isAbsolute(filePath)) {
+			return filePath;
+		}
+		return path.join(projectRoot, filePath);
+	};
+
+	/**
+	 * Read from virtual or real filesystem
+	 */
+	const readFromVirtualOrReal = (filePath: string): string | null => {
+		const normalizedPath = normalizePath(filePath);
+
+		// Check if deleted
+		if (deletedFiles.has(normalizedPath)) {
+			return null;
+		}
+
+		// Check virtual files first
+		if (virtualFiles.has(normalizedPath)) {
+			return virtualFiles.get(normalizedPath)!;
+		}
+
+		// Fall back to real filesystem
+		try {
+			return fs.readFileSync(normalizedPath, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+
+	/**
+	 * Record a file change
+	 */
+	const recordChange = (
+		filePath: string,
+		operation: "create" | "modify" | "delete",
+		before: string | undefined,
+		after: string
+	): void => {
+		const normalizedPath = normalizePath(filePath);
+
+		// Find existing change for this file
+		const existingIndex = changes.findIndex((c) => c.path === normalizedPath);
+
+		if (existingIndex >= 0) {
+			// Update existing change
+			changes[existingIndex] = {
+				...changes[existingIndex],
+				after,
+				operation: operation === "delete" ? "delete" : changes[existingIndex].operation,
+			};
+		} else {
+			changes.push({
+				path: normalizedPath,
+				operation,
+				before,
+				after,
+				diff: generateDiff(before, after),
+			});
+		}
+	};
+
+	return {
+		async readFile(filePath: string): Promise<string> {
+			const content = readFromVirtualOrReal(filePath);
+			if (content === null) {
+				throw new Error(`File not found: ${filePath}`);
+			}
+			return content;
+		},
+
+		readFileSync(filePath: string): string {
+			const content = readFromVirtualOrReal(filePath);
+			if (content === null) {
+				throw new Error(`File not found: ${filePath}`);
+			}
+			return content;
+		},
+
+		async writeFile(filePath: string, content: string): Promise<void> {
+			const normalizedPath = normalizePath(filePath);
+			const before = readFromVirtualOrReal(filePath) ?? undefined;
+			const isNew = before === undefined;
+
+			if (dryRun) {
+				virtualFiles.set(normalizedPath, content);
+				deletedFiles.delete(normalizedPath);
+				recordChange(filePath, isNew ? "create" : "modify", before, content);
+			} else {
+				// Ensure directory exists
+				const dir = path.dirname(normalizedPath);
+				await fs.promises.mkdir(dir, { recursive: true });
+				await fs.promises.writeFile(normalizedPath, content, "utf-8");
+				recordChange(filePath, isNew ? "create" : "modify", before, content);
+			}
+		},
+
+		writeFileSync(filePath: string, content: string): void {
+			const normalizedPath = normalizePath(filePath);
+			const before = readFromVirtualOrReal(filePath) ?? undefined;
+			const isNew = before === undefined;
+
+			if (dryRun) {
+				virtualFiles.set(normalizedPath, content);
+				deletedFiles.delete(normalizedPath);
+				recordChange(filePath, isNew ? "create" : "modify", before, content);
+			} else {
+				// Ensure directory exists
+				const dir = path.dirname(normalizedPath);
+				fs.mkdirSync(dir, { recursive: true });
+				fs.writeFileSync(normalizedPath, content, "utf-8");
+				recordChange(filePath, isNew ? "create" : "modify", before, content);
+			}
+		},
+
+		async exists(filePath: string): Promise<boolean> {
+			const normalizedPath = normalizePath(filePath);
+
+			if (deletedFiles.has(normalizedPath)) {
+				return false;
+			}
+
+			if (virtualFiles.has(normalizedPath)) {
+				return true;
+			}
+
+			try {
+				await fs.promises.access(normalizedPath);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+
+		existsSync(filePath: string): boolean {
+			const normalizedPath = normalizePath(filePath);
+
+			if (deletedFiles.has(normalizedPath)) {
+				return false;
+			}
+
+			if (virtualFiles.has(normalizedPath)) {
+				return true;
+			}
+
+			return fs.existsSync(normalizedPath);
+		},
+
+		async mkdir(dirPath: string): Promise<void> {
+			if (!dryRun) {
+				await fs.promises.mkdir(normalizePath(dirPath), { recursive: true });
+			}
+		},
+
+		mkdirSync(dirPath: string): void {
+			if (!dryRun) {
+				fs.mkdirSync(normalizePath(dirPath), { recursive: true });
+			}
+		},
+
+		async unlink(filePath: string): Promise<void> {
+			const normalizedPath = normalizePath(filePath);
+			const before = readFromVirtualOrReal(filePath) ?? "";
+
+			if (dryRun) {
+				virtualFiles.delete(normalizedPath);
+				deletedFiles.add(normalizedPath);
+				recordChange(filePath, "delete", before, "");
+			} else {
+				await fs.promises.unlink(normalizedPath);
+				recordChange(filePath, "delete", before, "");
+			}
+		},
+
+		unlinkSync(filePath: string): void {
+			const normalizedPath = normalizePath(filePath);
+			const before = readFromVirtualOrReal(filePath) ?? "";
+
+			if (dryRun) {
+				virtualFiles.delete(normalizedPath);
+				deletedFiles.add(normalizedPath);
+				recordChange(filePath, "delete", before, "");
+			} else {
+				fs.unlinkSync(normalizedPath);
+				recordChange(filePath, "delete", before, "");
+			}
+		},
+
+		async rmdir(dirPath: string): Promise<void> {
+			if (!dryRun) {
+				await fs.promises.rm(normalizePath(dirPath), { recursive: true, force: true });
+			}
+		},
+
+		async copyFile(src: string, dest: string): Promise<void> {
+			const content = await this.readFile(src);
+			await this.writeFile(dest, content);
+		},
+
+		copyFileSync(src: string, dest: string): void {
+			const content = this.readFileSync(src);
+			this.writeFileSync(dest, content);
+		},
+
+		getChanges(): FileChange[] {
+			return [...changes];
+		},
+
+		async commit(): Promise<void> {
+			if (!dryRun) {
+				// Changes are already committed in non-dry-run mode
+				return;
+			}
+
+			// Apply all virtual changes to real filesystem
+			for (const change of changes) {
+				switch (change.operation) {
+					case "create":
+					case "modify": {
+						const dir = path.dirname(change.path);
+						await fs.promises.mkdir(dir, { recursive: true });
+						await fs.promises.writeFile(change.path, change.after, "utf-8");
+						break;
+					}
+					case "delete": {
+						try {
+							await fs.promises.unlink(change.path);
+						} catch {
+							// File might not exist
+						}
+						break;
+					}
+				}
+			}
+
+			// Clear virtual state
+			virtualFiles.clear();
+			deletedFiles.clear();
+		},
+
+		isDryRun(): boolean {
+			return dryRun;
+		},
+	};
+}
+
+/**
+ * Generate a simple diff between two strings
+ */
+function generateDiff(before: string | undefined, after: string): string {
+	if (before === undefined) {
+		return `+ ${after.split("\n").length} lines added`;
+	}
+
+	const beforeLines = before.split("\n");
+	const afterLines = after.split("\n");
+
+	const added = afterLines.length - beforeLines.length;
+	const removed = beforeLines.filter((line, i) => afterLines[i] !== line).length;
+
+	const parts: string[] = [];
+	if (added > 0) parts.push(`+${added}`);
+	if (added < 0) parts.push(`${added}`);
+	if (removed > 0) parts.push(`~${removed} changed`);
+
+	return parts.join(", ") || "no changes";
+}
+
+/**
+ * Recursively copy a directory
+ */
+export async function copyDirectory(src: string, dest: string): Promise<void> {
+	await fs.promises.mkdir(dest, { recursive: true });
+
+	const entries = await fs.promises.readdir(src, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const srcPath = path.join(src, entry.name);
+		const destPath = path.join(dest, entry.name);
+
+		if (entry.isDirectory()) {
+			await copyDirectory(srcPath, destPath);
+		} else {
+			await fs.promises.copyFile(srcPath, destPath);
+		}
+	}
+}
+
+/**
+ * Remove directory recursively
+ */
+export async function removeDirectory(dirPath: string): Promise<void> {
+	try {
+		await fs.promises.rm(dirPath, { recursive: true, force: true });
+	} catch {
+		// Directory might not exist
+	}
+}
+
+/**
+ * Ensure directory exists
+ */
+export async function ensureDirectory(dirPath: string): Promise<void> {
+	await fs.promises.mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Find files matching a pattern
+ */
+export async function findFiles(dir: string, pattern: RegExp, results: string[] = []): Promise<string[]> {
+	const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+
+		if (entry.isDirectory()) {
+			await findFiles(fullPath, pattern, results);
+		} else if (pattern.test(entry.name)) {
+			results.push(fullPath);
+		}
+	}
+
+	return results;
+}

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Utility functions for Teardown Launchpad
+ */
+
+export type { VirtualFileSystem } from "./fs";
+export {
+	copyDirectory,
+	createVirtualFileSystem,
+	ensureDirectory,
+	findFiles,
+	removeDirectory,
+} from "./fs";
+export type { Logger, LoggerConfig, LogLevel } from "./logger";
+export {
+	createLogger,
+	defaultLogger,
+	formatBytes,
+	formatDuration,
+	formatKeyValue,
+	formatList,
+} from "./logger";