@teardown/cli 1.2.39 → 2.0.42

package/src/cli/commands/start.ts

@@ -0,0 +1,87 @@
+/**
+ * Start command - starts the Metro bundler
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+/**
+ * Check if a metro.config.js file exists in the project
+ */
+function hasMetroConfig(projectRoot: string): boolean {
+	const configPaths = ["metro.config.js", "metro.config.cjs", "metro.config.mjs"];
+	return configPaths.some((config) => existsSync(join(projectRoot, config)));
+}
+
+/**
+ * Check if @teardown/metro-config is installed
+ */
+function hasTeardownMetroConfig(projectRoot: string): boolean {
+	const nodeModulesPath = join(projectRoot, "node_modules", "@teardown", "metro-config");
+	return existsSync(nodeModulesPath);
+}
+
+/**
+ * Create the start command
+ */
+export function createStartCommand(): Command {
+	const start = new Command("start")
+		.description("Start the Metro bundler")
+		.option("-p, --port <port>", "Port to run Metro on", "8081")
+		.option("--reset-cache", "Reset the Metro cache")
+		.option("--platform <platform>", "Platform to target (ios, android, all)", "all")
+		.option("--verbose", "Enable verbose logging")
+		.action(async (options) => {
+			const projectRoot = process.cwd();
+
+			// Check for metro config
+			if (!hasMetroConfig(projectRoot)) {
+				console.log(chalk.yellow("No metro.config.js found. Using default React Native config.\n"));
+				console.log(chalk.gray("Tip: Add @teardown/metro-config for 36x faster builds:\n"));
+				console.log(
+					chalk.gray(`  1. bun add @teardown/metro-config\n  2. Create metro.config.js with withTeardown()\n`)
+				);
+			} else if (!hasTeardownMetroConfig(projectRoot)) {
+				console.log(chalk.gray("Tip: Add @teardown/metro-config for 36x faster builds\n"));
+			}
+
+			console.log(chalk.blue("Starting Metro bundler...\n"));
+
+			const args = ["react-native", "start", "--port", options.port];
+
+			if (options.resetCache) {
+				args.push("--reset-cache");
+			}
+
+			if (options.verbose) {
+				args.push("--verbose");
+			}
+
+			const proc = spawn("npx", args, {
+				stdio: "inherit",
+				shell: true,
+				cwd: projectRoot,
+				env: {
+					...process.env,
+					// Ensure proper encoding for CocoaPods compatibility
+					LANG: "en_US.UTF-8",
+				},
+			});
+
+			proc.on("error", (error) => {
+				console.error(chalk.red(`Failed to start Metro: ${error.message}`));
+				process.exit(1);
+			});
+
+			proc.on("close", (code) => {
+				if (code !== 0 && code !== null) {
+					process.exit(code);
+				}
+			});
+		});
+
+	return start;
+}

package/src/cli/commands/validate.ts

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { loadConfig } from "../../config";
+
+/**
+ * Create the validate command
+ */
+export function createValidateCommand(): Command {
+	const command = new Command("validate").description("Validate the Teardown configuration file").action(async () => {
+		const spinner = ora("Validating configuration...").start();
+
+		try {
+			const projectRoot = process.cwd();
+			const result = await loadConfig(projectRoot);
+
+			if (!result.success) {
+				spinner.fail("Configuration validation failed");
+
+				console.error(chalk.red("\nErrors:"));
+				for (const error of result.errors ?? []) {
+					console.error(chalk.red(`  - ${error.path || "config"}: ${error.message}`));
+					if (error.suggestion) {
+						console.error(chalk.gray(`    Suggestion: ${error.suggestion}`));
+					}
+				}
+				process.exit(1);
+			}
+
+			spinner.succeed("Configuration is valid");
+
+			console.log(chalk.green("\nConfiguration summary:"));
+			console.log(chalk.gray(`  Name: ${result.config?.name}`));
+			console.log(chalk.gray(`  Slug: ${result.config?.slug}`));
+			console.log(chalk.gray(`  Version: ${result.config?.version}`));
+
+			if (result.config?.ios) {
+				console.log(chalk.blue("\n  iOS:"));
+				console.log(chalk.gray(`    Bundle ID: ${result.config?.ios.bundleIdentifier}`));
+				console.log(chalk.gray(`    Deployment Target: ${result.config?.ios.deploymentTarget}`));
+			}
+
+			if (result.config?.android) {
+				console.log(chalk.green("\n  Android:"));
+				console.log(chalk.gray(`    Package: ${result.config?.android.packageName}`));
+				console.log(chalk.gray(`    Min SDK: ${result.config?.android.minSdkVersion}`));
+				console.log(chalk.gray(`    Target SDK: ${result.config?.android.targetSdkVersion}`));
+			}
+
+			const pluginCount = result.config?.plugins?.length ?? 0;
+			if (pluginCount > 0) {
+				console.log(chalk.cyan(`\n  Plugins: ${pluginCount}`));
+			}
+		} catch (error) {
+			spinner.fail("Validation failed");
+			console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+			process.exit(1);
+		}
+	});
+
+	return command;
+}

package/src/cli/index.ts

@@ -0,0 +1,59 @@
+/**
+ * CLI for Teardown Launchpad
+ */
+
+import { Command } from "commander";
+import { createInitCommand } from "./commands/init";
+import { createPluginsCommand } from "./commands/plugins";
+import { createPrebuildCommand } from "./commands/prebuild";
+import { createRunCommand } from "./commands/run";
+import { createStartCommand } from "./commands/start";
+import { createValidateCommand } from "./commands/validate";
+
+/**
+ * Package version (injected at build time)
+ */
+const VERSION = "0.0.1";
+
+/**
+ * Create and configure the CLI program
+ */
+export function createProgram(): Command {
+	const program = new Command()
+		.name("teardown")
+		.description("Teardown CLI - React Native Development Toolkit")
+		.version(VERSION);
+
+	// Add commands
+	program.addCommand(createPrebuildCommand());
+	program.addCommand(createValidateCommand());
+	program.addCommand(createInitCommand());
+	program.addCommand(createPluginsCommand());
+	program.addCommand(createRunCommand());
+	program.addCommand(createStartCommand());
+
+	// Default command (prebuild)
+	program.argument("[command]").action((cmd) => {
+		if (!cmd) {
+			program.help();
+		}
+	});
+
+	return program;
+}
+
+/**
+ * Run the CLI
+ */
+export async function run(args: string[] = process.argv): Promise<void> {
+	const program = createProgram();
+	await program.parseAsync(args);
+}
+
+export { createInitCommand } from "./commands/init";
+export { createPluginsCommand } from "./commands/plugins";
+// Export commands for testing
+export { createPrebuildCommand } from "./commands/prebuild";
+export { createRunCommand } from "./commands/run";
+export { createStartCommand } from "./commands/start";
+export { createValidateCommand } from "./commands/validate";

package/src/config/index.ts

@@ -0,0 +1,45 @@
+/**
+ * Configuration module for Teardown Launchpad
+ *
+ * Provides configuration loading, validation, and type definitions
+ * for the prebuild system.
+ */
+
+export type { ConfigLoadResult } from "./loader";
+
+export { findConfigFile, generateDefaultConfig, loadConfig, watchConfig } from "./loader";
+export {
+	AndroidConfigSchema,
+	defineConfig,
+	formatValidationErrors,
+	iOSConfigSchema,
+	SplashConfigSchema,
+	TeardownConfigSchema,
+	validateConfig,
+} from "./schema";
+
+export type {
+	AndroidConfig,
+	AndroidIntentFilter,
+	AndroidWidgetDefinition,
+	BuildConfig,
+	DryRunResult,
+	FileChange,
+	HealthConnectDataType,
+	HealthKitDataType,
+	IntentDefinition,
+	IntentParameter,
+	iOSConfig,
+	PermissionConfig,
+	PermissionMapping,
+	PermissionStatus,
+	PluginEntry,
+	PrebuildError,
+	PrebuildOptions,
+	PrebuildWarning,
+	ProcessedAppConfig,
+	SplashConfig,
+	TeardownConfig,
+	TemplateContext,
+	WidgetDefinition,
+} from "./types";

package/src/config/loader.ts

@@ -0,0 +1,366 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Project, SyntaxKind } from "ts-morph";
+import { type ValidationError, validateConfig } from "./schema";
+import type { TeardownConfig } from "./types";
+
+/**
+ * Configuration file names to search for (in order of priority)
+ */
+const CONFIG_FILE_NAMES = [
+	"teardown.config.ts",
+	"teardown.config.js",
+	"teardown.config.mjs",
+	"launchpad.config.ts",
+	"launchpad.config.js",
+];
+
+/**
+ * Result of loading configuration
+ */
+export interface ConfigLoadResult {
+	success: boolean;
+	config?: TeardownConfig;
+	configPath?: string;
+	errors?: ValidationError[];
+}
+
+/**
+ * Find the configuration file in the project root
+ */
+export function findConfigFile(projectRoot: string): string | null {
+	for (const fileName of CONFIG_FILE_NAMES) {
+		const filePath = path.join(projectRoot, fileName);
+		if (fs.existsSync(filePath)) {
+			return filePath;
+		}
+	}
+	return null;
+}
+
+/**
+ * Load and parse the configuration file
+ */
+export async function loadConfig(projectRoot: string): Promise<ConfigLoadResult> {
+	const configPath = findConfigFile(projectRoot);
+
+	if (!configPath) {
+		return {
+			success: false,
+			errors: [
+				{
+					path: "",
+					message: `No configuration file found. Expected one of: ${CONFIG_FILE_NAMES.join(", ")}`,
+					suggestion: "Create a teardown.config.ts file in your project root",
+				},
+			],
+		};
+	}
+
+	try {
+		// For TypeScript files, we need to transpile first
+		if (configPath.endsWith(".ts")) {
+			return await loadTypeScriptConfig(configPath);
+		}
+
+		// For JavaScript files, we can import directly
+		const module = await import(configPath);
+		const config = module.default || module;
+
+		const validation = validateConfig(config);
+
+		if (!validation.success) {
+			return {
+				success: false,
+				configPath,
+				errors: validation.errors,
+			};
+		}
+
+		return {
+			success: true,
+			config: validation.data,
+			configPath,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			configPath,
+			errors: [
+				{
+					path: "",
+					message: `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`,
+				},
+			],
+		};
+	}
+}
+
+/**
+ * Load TypeScript configuration file
+ */
+async function loadTypeScriptConfig(configPath: string): Promise<ConfigLoadResult> {
+	try {
+		// Use Bun's native TypeScript support if available
+		if (typeof Bun !== "undefined") {
+			// Add cache-busting query param to force fresh import
+			const cacheBuster = `?t=${Date.now()}`;
+			const module = await import(configPath + cacheBuster);
+			const config = module.default || module;
+
+			const validation = validateConfig(config);
+
+			if (!validation.success) {
+				return {
+					success: false,
+					configPath,
+					errors: validation.errors,
+				};
+			}
+
+			return {
+				success: true,
+				config: validation.data,
+				configPath,
+			};
+		}
+
+		// Fallback: Parse with ts-morph for analysis
+		const project = new Project({
+			compilerOptions: {
+				target: 99, // ESNext
+				module: 99, // ESNext
+				moduleResolution: 100, // Bundler
+			},
+		});
+
+		const sourceFile = project.addSourceFileAtPath(configPath);
+
+		// Find the default export
+		const defaultExport = sourceFile.getExportAssignment((d) => !d.isExportEquals());
+
+		if (!defaultExport) {
+			return {
+				success: false,
+				configPath,
+				errors: [
+					{
+						path: "",
+						message: "Configuration file must have a default export",
+						suggestion: "Add 'export default defineConfig({ ... })' to your config file",
+					},
+				],
+			};
+		}
+
+		// Get the expression being exported
+		const expression = defaultExport.getExpression();
+
+		// If it's a call expression (defineConfig(...)), get the argument
+		let configObject: unknown;
+
+		if (expression.getKind() === SyntaxKind.CallExpression) {
+			const callExpr = expression.asKind(SyntaxKind.CallExpression);
+			const args = callExpr?.getArguments();
+
+			if (args && args.length > 0) {
+				const firstArg = args[0];
+				if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+					configObject = evaluateObjectLiteral(firstArg);
+				}
+			}
+		} else if (expression.getKind() === SyntaxKind.ObjectLiteralExpression) {
+			configObject = evaluateObjectLiteral(expression);
+		}
+
+		if (!configObject) {
+			return {
+				success: false,
+				configPath,
+				errors: [
+					{
+						path: "",
+						message: "Could not parse configuration object",
+						suggestion: "Ensure your config exports a plain object or uses defineConfig()",
+					},
+				],
+			};
+		}
+
+		const validation = validateConfig(configObject);
+
+		if (!validation.success) {
+			return {
+				success: false,
+				configPath,
+				errors: validation.errors,
+			};
+		}
+
+		return {
+			success: true,
+			config: validation.data,
+			configPath,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			configPath,
+			errors: [
+				{
+					path: "",
+					message: `Failed to parse TypeScript config: ${error instanceof Error ? error.message : String(error)}`,
+				},
+			],
+		};
+	}
+}
+
+/**
+ * Evaluate an object literal expression to a JavaScript object
+ * This is a simplified evaluator that handles common cases
+ */
+function evaluateObjectLiteral(node: import("ts-morph").Node): Record<string, unknown> {
+	const obj: Record<string, unknown> = {};
+	const objLiteral = node.asKind(SyntaxKind.ObjectLiteralExpression);
+
+	if (!objLiteral) {
+		return obj;
+	}
+
+	for (const prop of objLiteral.getProperties()) {
+		if (prop.getKind() === SyntaxKind.PropertyAssignment) {
+			const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+			if (!propAssign) continue;
+
+			const name = propAssign.getName();
+			const initializer = propAssign.getInitializer();
+
+			if (!initializer) continue;
+
+			obj[name] = evaluateExpression(initializer);
+		} else if (prop.getKind() === SyntaxKind.ShorthandPropertyAssignment) {
+			const shorthand = prop.asKind(SyntaxKind.ShorthandPropertyAssignment);
+			if (!shorthand) continue;
+
+			const name = shorthand.getName();
+			// For shorthand, we can't easily resolve the value without runtime
+			obj[name] = undefined;
+		}
+	}
+
+	return obj;
+}
+
+/**
+ * Evaluate a simple expression to a JavaScript value
+ */
+function evaluateExpression(node: import("ts-morph").Node): unknown {
+	const kind = node.getKind();
+
+	switch (kind) {
+		case SyntaxKind.StringLiteral:
+			return node.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+
+		case SyntaxKind.NumericLiteral:
+			return node.asKind(SyntaxKind.NumericLiteral)?.getLiteralValue();
+
+		case SyntaxKind.TrueKeyword:
+			return true;
+
+		case SyntaxKind.FalseKeyword:
+			return false;
+
+		case SyntaxKind.NullKeyword:
+			return null;
+
+		case SyntaxKind.ObjectLiteralExpression:
+			return evaluateObjectLiteral(node);
+
+		case SyntaxKind.ArrayLiteralExpression: {
+			const arrayLiteral = node.asKind(SyntaxKind.ArrayLiteralExpression);
+			if (!arrayLiteral) return [];
+			return arrayLiteral.getElements().map((el) => evaluateExpression(el));
+		}
+
+		default:
+			// For complex expressions, return the text representation
+			return node.getText();
+	}
+}
+
+/**
+ * Watch configuration file for changes
+ */
+export function watchConfig(projectRoot: string, onChange: (result: ConfigLoadResult) => void): () => void {
+	const configPath = findConfigFile(projectRoot);
+
+	if (!configPath) {
+		onChange({
+			success: false,
+			errors: [
+				{
+					path: "",
+					message: "No configuration file found",
+				},
+			],
+		});
+		return () => {};
+	}
+
+	const watcher = fs.watch(configPath, async (eventType) => {
+		if (eventType === "change") {
+			const result = await loadConfig(projectRoot);
+			onChange(result);
+		}
+	});
+
+	return () => watcher.close();
+}
+
+/**
+ * Generate a default configuration file
+ */
+export function generateDefaultConfig(options: {
+	name: string;
+	slug: string;
+	bundleIdentifier?: string;
+	packageName?: string;
+}): string {
+	const { name, slug } = options;
+	const bundleIdentifier = options.bundleIdentifier || `com.example.${slug.replace(/-/g, "")}`;
+	const packageName = options.packageName || bundleIdentifier;
+
+	return `import { defineConfig } from "@teardown/cli";
+
+export default defineConfig({
+  name: '${name}',
+  slug: '${slug}',
+  version: '1.0.0',
+
+  ios: {
+    bundleIdentifier: '${bundleIdentifier}',
+    buildNumber: 1,
+    deploymentTarget: '15.0',
+  },
+
+  android: {
+    packageName: '${packageName}',
+    versionCode: 1,
+    minSdkVersion: 23,
+    targetSdkVersion: 34,
+  },
+
+  icon: './assets/icon.png',
+
+  splash: {
+    image: './assets/splash.png',
+    backgroundColor: '#FFFFFF',
+  },
+
+  plugins: [
+    // Add your plugins here
+  ],
+});
+`;
+}