@teardown/cli 1.2.39 → 2.0.42

package/src/plugins/context.ts

@@ -0,0 +1,220 @@
+import type { PrebuildWarning, ProcessedAppConfig, TeardownConfig } from "../config/types";
+import type { VirtualFileSystem } from "../utils/fs";
+import type { Logger } from "../utils/logger";
+
+/**
+ * Plugin context provides shared state and utilities for plugins
+ */
+export interface PluginContext {
+	/**
+	 * Shared state between plugins - allows plugins to communicate
+	 */
+	readonly sharedState: Map<string, unknown>;
+
+	/**
+	 * Access another plugin's output by name
+	 */
+	getPluginOutput<T>(pluginName: string): T | undefined;
+
+	/**
+	 * Set output for this plugin (accessible by other plugins)
+	 */
+	setPluginOutput<T>(pluginName: string, output: T): void;
+
+	/**
+	 * Register a capability that this plugin provides
+	 */
+	registerCapability(capability: string): void;
+
+	/**
+	 * Check if a capability has been registered by any plugin
+	 */
+	hasCapability(capability: string): boolean;
+
+	/**
+	 * Get all registered capabilities
+	 */
+	getCapabilities(): string[];
+
+	/**
+	 * Project root directory path
+	 */
+	readonly projectRoot: string;
+
+	/**
+	 * Target platform(s) for this prebuild
+	 */
+	readonly platform: "ios" | "android" | "both";
+
+	/**
+	 * Virtual file system for dry-run support
+	 */
+	readonly fs: VirtualFileSystem;
+
+	/**
+	 * Logger instance
+	 */
+	readonly log: Logger;
+
+	/**
+	 * Original configuration (before plugin modifications)
+	 */
+	readonly originalConfig: TeardownConfig;
+
+	/**
+	 * Current processed configuration (accumulates changes)
+	 */
+	config: ProcessedAppConfig;
+
+	/**
+	 * Add a warning to the prebuild output
+	 */
+	addWarning(warning: PrebuildWarning): void;
+
+	/**
+	 * Get all accumulated warnings
+	 */
+	getWarnings(): PrebuildWarning[];
+
+	/**
+	 * Check if running in dry-run mode
+	 */
+	readonly isDryRun: boolean;
+
+	/**
+	 * Check if verbose logging is enabled
+	 */
+	readonly isVerbose: boolean;
+
+	/**
+	 * iOS-specific paths
+	 */
+	readonly iosPaths: {
+		projectRoot: string;
+		infoPlist: string;
+		entitlements: string;
+		pbxproj: string;
+		podfile: string;
+		appDelegate: string;
+	};
+
+	/**
+	 * Android-specific paths
+	 */
+	readonly androidPaths: {
+		projectRoot: string;
+		manifest: string;
+		buildGradle: string;
+		appBuildGradle: string;
+		mainActivity: string;
+		mainApplication: string;
+		stringsXml: string;
+		networkSecurityConfig: string;
+	};
+}
+
+/**
+ * Create a new plugin context
+ */
+export function createPluginContext(options: {
+	projectRoot: string;
+	platform: "ios" | "android" | "both";
+	config: TeardownConfig;
+	fs: VirtualFileSystem;
+	log: Logger;
+	isDryRun: boolean;
+	isVerbose: boolean;
+}): PluginContext {
+	const { projectRoot, platform, config, fs, log, isDryRun, isVerbose } = options;
+
+	const sharedState = new Map<string, unknown>();
+	const pluginOutputs = new Map<string, unknown>();
+	const capabilities = new Set<string>();
+	const warnings: PrebuildWarning[] = [];
+
+	// Derive app name for paths
+	const appName = config.name.replace(/[^a-zA-Z0-9]/g, "");
+	const packagePath = config.android?.packageName?.replace(/\./g, "/") ?? "com/example/app";
+
+	// Create processed config with empty resolved fields
+	const processedConfig: ProcessedAppConfig = {
+		...config,
+		resolvedInfoPlist: {},
+		resolvedEntitlements: {},
+		resolvedAndroidPermissions: [],
+		resolvedAndroidFeatures: [],
+		resolvedAndroidMetadata: {},
+		resolvedGradleDependencies: [],
+		resolvedFrameworks: [],
+		resolvedPodDependencies: [],
+		resolvedBackgroundModes: [],
+		resolvedUrlSchemes: [],
+		resolvedIntentFilters: [],
+	};
+
+	const iosPaths = {
+		projectRoot: `${projectRoot}/ios`,
+		infoPlist: `${projectRoot}/ios/${appName}/Info.plist`,
+		entitlements: `${projectRoot}/ios/${appName}/${appName}.entitlements`,
+		pbxproj: `${projectRoot}/ios/${appName}.xcodeproj/project.pbxproj`,
+		podfile: `${projectRoot}/ios/Podfile`,
+		appDelegate: `${projectRoot}/ios/${appName}/AppDelegate.swift`,
+	};
+
+	const androidPaths = {
+		projectRoot: `${projectRoot}/android`,
+		manifest: `${projectRoot}/android/app/src/main/AndroidManifest.xml`,
+		buildGradle: `${projectRoot}/android/build.gradle.kts`,
+		appBuildGradle: `${projectRoot}/android/app/build.gradle.kts`,
+		mainActivity: `${projectRoot}/android/app/src/main/java/${packagePath}/MainActivity.kt`,
+		mainApplication: `${projectRoot}/android/app/src/main/java/${packagePath}/MainApplication.kt`,
+		stringsXml: `${projectRoot}/android/app/src/main/res/values/strings.xml`,
+		networkSecurityConfig: `${projectRoot}/android/app/src/main/res/xml/network_security_config.xml`,
+	};
+
+	return {
+		sharedState,
+
+		getPluginOutput<T>(pluginName: string): T | undefined {
+			return pluginOutputs.get(pluginName) as T | undefined;
+		},
+
+		setPluginOutput<T>(pluginName: string, output: T): void {
+			pluginOutputs.set(pluginName, output);
+		},
+
+		registerCapability(capability: string): void {
+			capabilities.add(capability);
+			log.debug(`Registered capability: ${capability}`);
+		},
+
+		hasCapability(capability: string): boolean {
+			return capabilities.has(capability);
+		},
+
+		getCapabilities(): string[] {
+			return Array.from(capabilities);
+		},
+
+		projectRoot,
+		platform,
+		fs,
+		log,
+		originalConfig: config,
+		config: processedConfig,
+		isDryRun,
+		isVerbose,
+
+		addWarning(warning: PrebuildWarning): void {
+			warnings.push(warning);
+			log.warn(`[${warning.code}] ${warning.message}`);
+		},
+
+		getWarnings(): PrebuildWarning[] {
+			return [...warnings];
+		},
+
+		iosPaths,
+		androidPaths,
+	};
+}

package/src/plugins/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Plugin system for Teardown Launchpad
+ *
+ * Provides the base plugin class, context, and dependency resolution
+ * for implementing native capability plugins.
+ */
+
+export type {
+	AndroidActivity,
+	AndroidIntentData,
+	AndroidIntentFilter,
+	AndroidManifest,
+	AndroidProvider,
+	AndroidReceiver,
+	AndroidService,
+	Entitlements,
+	InfoPlist,
+	PluginConstructor,
+} from "./base";
+export { BasePlugin } from "./base";
+// Re-export capability plugins
+export * from "./capabilities";
+export type { PluginContext } from "./context";
+export { createPluginContext } from "./context";
+export type { CycleInfo } from "./resolver";
+export { DependencyResolver, PluginResolutionError } from "./resolver";

package/src/plugins/resolver.ts

@@ -0,0 +1,321 @@
+import type { Logger } from "../utils/logger";
+import type { BasePlugin, PluginConstructor } from "./base";
+
+/**
+ * Plugin resolution error
+ */
+export class PluginResolutionError extends Error {
+	constructor(
+		message: string,
+		public readonly code: string,
+		public readonly details?: unknown
+	) {
+		super(message);
+		this.name = "PluginResolutionError";
+	}
+}
+
+/**
+ * Cycle detection result
+ */
+export interface CycleInfo {
+	plugins: string[];
+	path: string;
+}
+
+/**
+ * Plugin registry and dependency resolver
+ *
+ * Handles plugin registration, dependency resolution, and topological sorting
+ */
+export class DependencyResolver {
+	private plugins: Map<string, BasePlugin> = new Map();
+	private pluginConfigs: Map<string, unknown> = new Map();
+	private logger: Logger;
+
+	constructor(logger: Logger) {
+		this.logger = logger;
+	}
+
+	/**
+	 * Register a plugin instance
+	 */
+	registerPlugin<TConfig>(plugin: BasePlugin<TConfig>, config?: TConfig): void {
+		if (this.plugins.has(plugin.name)) {
+			throw new PluginResolutionError(`Plugin "${plugin.name}" is already registered`, "DUPLICATE_PLUGIN");
+		}
+
+		// Validate config if provided
+		if (config !== undefined) {
+			try {
+				plugin.validateConfig(config);
+			} catch (error) {
+				throw new PluginResolutionError(
+					`Invalid configuration for plugin "${plugin.name}": ${error instanceof Error ? error.message : String(error)}`,
+					"INVALID_CONFIG",
+					error
+				);
+			}
+		}
+
+		this.plugins.set(plugin.name, plugin);
+		if (config !== undefined) {
+			this.pluginConfigs.set(plugin.name, config);
+		}
+
+		this.logger.debug(`Registered plugin: ${plugin.name} v${plugin.version}`);
+	}
+
+	/**
+	 * Register a plugin from constructor and config
+	 */
+	registerPluginFromConstructor<TConfig>(Constructor: PluginConstructor<TConfig>, config?: TConfig): void {
+		const plugin = new Constructor();
+		this.registerPlugin(plugin, config);
+	}
+
+	/**
+	 * Get a registered plugin by name
+	 */
+	getPlugin(name: string): BasePlugin | undefined {
+		return this.plugins.get(name);
+	}
+
+	/**
+	 * Get plugin configuration
+	 */
+	getPluginConfig<TConfig>(name: string): TConfig | undefined {
+		return this.pluginConfigs.get(name) as TConfig | undefined;
+	}
+
+	/**
+	 * Check if a plugin is registered
+	 */
+	hasPlugin(name: string): boolean {
+		return this.plugins.has(name);
+	}
+
+	/**
+	 * Get all registered plugin names
+	 */
+	getPluginNames(): string[] {
+		return Array.from(this.plugins.keys());
+	}
+
+	/**
+	 * Resolve plugin execution order using topological sort
+	 * Returns plugins in order such that dependencies come before dependents
+	 */
+	resolveOrder(): BasePlugin[] {
+		// First, check for cycles
+		const cycles = this.detectCycles();
+		if (cycles.length > 0) {
+			const cycleStr = cycles.map((c) => c.path).join("; ");
+			throw new PluginResolutionError(`Circular dependencies detected: ${cycleStr}`, "CIRCULAR_DEPENDENCY", cycles);
+		}
+
+		// Check for missing dependencies
+		const missingDeps = this.findMissingDependencies();
+		if (missingDeps.length > 0) {
+			const missingStr = missingDeps.map((m) => `${m.plugin} requires ${m.dependency}`).join(", ");
+			throw new PluginResolutionError(`Missing dependencies: ${missingStr}`, "MISSING_DEPENDENCY", missingDeps);
+		}
+
+		// Perform topological sort using Kahn's algorithm
+		const inDegree = new Map<string, number>();
+		const adjacency = new Map<string, string[]>();
+
+		// Initialize
+		for (const [name] of this.plugins) {
+			inDegree.set(name, 0);
+			adjacency.set(name, []);
+		}
+
+		// Build graph
+		for (const [name, plugin] of this.plugins) {
+			for (const dep of plugin.dependencies) {
+				if (this.plugins.has(dep)) {
+					adjacency.get(dep)?.push(name);
+					inDegree.set(name, (inDegree.get(name) || 0) + 1);
+				}
+			}
+		}
+
+		// Find all nodes with no incoming edges
+		const queue: string[] = [];
+		for (const [name, degree] of inDegree) {
+			if (degree === 0) {
+				queue.push(name);
+			}
+		}
+
+		// Process queue
+		const result: BasePlugin[] = [];
+		while (queue.length > 0) {
+			const current = queue.shift()!;
+			result.push(this.plugins.get(current)!);
+
+			for (const neighbor of adjacency.get(current) || []) {
+				const newDegree = (inDegree.get(neighbor) || 1) - 1;
+				inDegree.set(neighbor, newDegree);
+				if (newDegree === 0) {
+					queue.push(neighbor);
+				}
+			}
+		}
+
+		this.logger.debug(`Plugin execution order: ${result.map((p) => p.name).join(" -> ")}`);
+		return result;
+	}
+
+	/**
+	 * Detect circular dependencies using Tarjan's algorithm
+	 */
+	detectCycles(): CycleInfo[] {
+		const cycles: CycleInfo[] = [];
+		const visited = new Set<string>();
+		const recursionStack = new Set<string>();
+		const path: string[] = [];
+
+		const dfs = (name: string): boolean => {
+			visited.add(name);
+			recursionStack.add(name);
+			path.push(name);
+
+			const plugin = this.plugins.get(name);
+			if (plugin) {
+				for (const dep of plugin.dependencies) {
+					if (!this.plugins.has(dep)) {
+						continue; // Skip missing deps (handled separately)
+					}
+
+					if (!visited.has(dep)) {
+						if (dfs(dep)) {
+							return true;
+						}
+					} else if (recursionStack.has(dep)) {
+						// Found a cycle
+						const cycleStart = path.indexOf(dep);
+						const cyclePath = path.slice(cycleStart);
+						cycles.push({
+							plugins: [...cyclePath],
+							path: `${cyclePath.join(" -> ")} -> ${dep}`,
+						});
+						return true;
+					}
+				}
+			}
+
+			path.pop();
+			recursionStack.delete(name);
+			return false;
+		};
+
+		for (const name of this.plugins.keys()) {
+			if (!visited.has(name)) {
+				dfs(name);
+			}
+		}
+
+		return cycles;
+	}
+
+	/**
+	 * Find dependencies that are not registered
+	 */
+	findMissingDependencies(): Array<{ plugin: string; dependency: string }> {
+		const missing: Array<{ plugin: string; dependency: string }> = [];
+
+		for (const [name, plugin] of this.plugins) {
+			for (const dep of plugin.dependencies) {
+				if (!this.plugins.has(dep)) {
+					missing.push({ plugin: name, dependency: dep });
+				}
+			}
+		}
+
+		return missing;
+	}
+
+	/**
+	 * Get plugins that depend on a specific plugin
+	 */
+	getDependents(pluginName: string): BasePlugin[] {
+		const dependents: BasePlugin[] = [];
+
+		for (const plugin of this.plugins.values()) {
+			if (plugin.dependencies.includes(pluginName)) {
+				dependents.push(plugin);
+			}
+		}
+
+		return dependents;
+	}
+
+	/**
+	 * Get plugins that a specific plugin depends on
+	 */
+	getDependencies(pluginName: string): BasePlugin[] {
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) {
+			return [];
+		}
+
+		return plugin.dependencies.map((dep) => this.plugins.get(dep)).filter((p): p is BasePlugin => p !== undefined);
+	}
+
+	/**
+	 * Clear all registered plugins
+	 */
+	clear(): void {
+		this.plugins.clear();
+		this.pluginConfigs.clear();
+	}
+
+	/**
+	 * Get all registered plugins (unordered)
+	 */
+	getAllPlugins(): BasePlugin[] {
+		return Array.from(this.plugins.values());
+	}
+
+	/**
+	 * Validate all plugin configurations
+	 */
+	validateAllConfigs(): Array<{ plugin: string; error: string }> {
+		const errors: Array<{ plugin: string; error: string }> = [];
+
+		for (const [name, plugin] of this.plugins) {
+			const config = this.pluginConfigs.get(name);
+			if (config !== undefined) {
+				try {
+					plugin.validateConfig(config);
+				} catch (error) {
+					errors.push({
+						plugin: name,
+						error: error instanceof Error ? error.message : String(error),
+					});
+				}
+			}
+		}
+
+		return errors;
+	}
+
+	/**
+	 * Get all capabilities provided by registered plugins
+	 */
+	getAllProvidedCapabilities(): Map<string, string[]> {
+		const capabilities = new Map<string, string[]>();
+
+		for (const plugin of this.plugins.values()) {
+			for (const capability of plugin.provides) {
+				const providers = capabilities.get(capability) || [];
+				providers.push(plugin.name);
+				capabilities.set(capability, providers);
+			}
+		}
+
+		return capabilities;
+	}
+}