@teardown/cli 1.2.39 → 2.0.42

package/bin/teardown.js

@@ -1,3 +1,13 @@
 #!/usr/bin/env bun
+/**
+ * Teardown Launchpad CLI
+ *
+ * This is the entry point for the teardown command.
+ */
 
-require("../dist/index.js");
+import { run } from "../src/cli/index.ts";
+
+run().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});

package/package.json

@@ -1,59 +1,79 @@
 {
-  "name": "@teardown/cli",
-  "version": "1.2.39",
-  "description": "Teardown CLI",
-  "main": "dist/index.js",
-  "bin": {
-    "teardown": "./bin/teardown.js",
-    "td": "./bin/teardown.js"
-  },
-  "files": [
-    "bin/**/*",
-    "README.md",
-    "dist/**/*",
-    "assets/**/*"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "start": "bun run ./bin/teardown.js"
-  },
-  "dependencies": {
-    "@babel/code-frame": "^7.26.2",
-    "@fastify/compress": "^8.0.1",
-    "@fastify/cors": "^10.0.1",
-    "@fastify/middie": "^9.0.2",
-    "@fastify/sensible": "^6.0.1",
-    "@isaacs/ttlcache": "^1.4.1",
-    "@react-native-community/cli-server-api": "^15.0.1",
-    "@react-native/metro-config": "0.76.1",
-    "@types/bun": "^1.1.13",
-    "bun": "1.1.34",
-    "chalk": "^5.3.0",
-    "cli-progress": "^3.12.0",
-    "commander": "^11.0.0",
-    "compression": "^1.7.5",
-    "connect": "^3.7.0",
-    "debug": "^4.3.7",
-    "devtools-protocol": "^0.0.1380148",
-    "fastify": "^5.1.0",
-    "fastify-favicon": "^5.0.0",
-    "fastify-plugin": "^5.0.1",
-    "log-update": "^6.1.0",
-    "metro": "^0.81.0",
-    "metro-config": "^0.81.0",
-    "metro-core": "^0.81.0",
-    "pretty-format": "^29.7.0",
-    "prompts": "^2.4.2",
-    "source-map": "^0.7.4",
-    "timers": "^0.1.1"
-  },
-  "devDependencies": {
-    "@types/babel__code-frame": "^7.0.6",
-    "@types/metro": "^0.76.3",
-    "@types/metro-config": "^0.76.3",
-    "@types/prompts": "^2.4.9",
-    "typescript": "^5.0.0",
-    "copyfiles": "^2.4.1"
-  }
+	"name": "@teardown/cli",
+	"version": "2.0.42",
+	"private": false,
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"bin": {
+		"teardown": "./bin/teardown.js"
+	},
+	"files": [
+		"bin/**/*",
+		"src/**/*",
+		"templates/**/*",
+		"templates/.gitignore"
+	],
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts",
+			"default": "./src/index.ts"
+		},
+		"./config": {
+			"types": "./src/config/index.ts",
+			"import": "./src/config/index.ts",
+			"default": "./src/config/index.ts"
+		},
+		"./plugins": {
+			"types": "./src/plugins/index.ts",
+			"import": "./src/plugins/index.ts",
+			"default": "./src/plugins/index.ts"
+		},
+		"./plugins/*": {
+			"types": "./src/plugins/*/index.ts",
+			"import": "./src/plugins/*/index.ts",
+			"default": "./src/plugins/*/index.ts"
+		},
+		"./transformers": {
+			"types": "./src/transformers/index.ts",
+			"import": "./src/transformers/index.ts",
+			"default": "./src/transformers/index.ts"
+		},
+		"./cli": {
+			"types": "./src/cli/index.ts",
+			"import": "./src/cli/index.ts",
+			"default": "./src/cli/index.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"typecheck": "bun x tsgo --noEmit --project ./tsconfig.json",
+		"build": "bun x tsgo --project ./tsconfig.json",
+		"dev": "bun x tsgo --watch --project ./tsconfig.json",
+		"lint": "bunx biome lint --write ./src",
+		"fmt": "bunx biome format --write ./src",
+		"check": "bunx biome check ./src",
+		"test": "bun test",
+		"test:e2e": "rm -rf ./example || true && bun test test/e2e",
+		"test:e2e:clean": "rm -rf example"
+	},
+	"dependencies": {
+		"@bacons/xcode": "^1.0.0-alpha.27",
+		"chalk": "^5.4.1",
+		"commander": "^13.1.0",
+		"ejs": "^3.1.10",
+		"fast-xml-parser": "^5.0.9",
+		"ora": "^8.2.0",
+		"simple-plist": "^1.4.0",
+		"ts-morph": "^25.0.1",
+		"zod": "4.2.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.11",
+		"@teardown/tsconfig": "2.0.42",
+		"@types/bun": "1.3.5",
+		"@types/ejs": "^3.1.5",
+		"typescript": "5.9.3"
+	}
 }

package/src/cli/commands/init.ts

@@ -0,0 +1,254 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { findConfigFile, generateDefaultConfig } from "../../config";
+import { TemplateGenerator } from "../../templates";
+
+/**
+ * Get the CLI package version
+ */
+function getCliVersion(): string {
+	try {
+		// Get the directory of this file
+		const __filename = fileURLToPath(import.meta.url);
+		const __dirname = path.dirname(__filename);
+		// Navigate up to package root and read package.json
+		const packageJsonPath = path.resolve(__dirname, "../../../package.json");
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		return `^${packageJson.version}`;
+	} catch {
+		// Fallback to a reasonable default
+		return "^0.1.0";
+	}
+}
+
+/**
+ * Generate dev-client configuration file content
+ */
+function generateDevClientConfig(): string {
+	return `import type { DevClientConfig } from "@teardown/dev-client";
+
+/**
+ * Development client configuration
+ *
+ * This configuration controls the dev menu and splash screen
+ * behavior during development.
+ */
+export const devClientConfig: DevClientConfig = {
+	// Enable shake gesture to open dev menu
+	enableShakeGesture: true,
+
+	// Enable 3-finger tap to open dev menu
+	enableThreeFingerTap: true,
+
+	// Splash screen configuration
+	splash: {
+		backgroundColor: "#ffffff",
+		minDisplayTime: 500,
+		fadeOutDuration: 300,
+		autoHide: true,
+	},
+
+	// Enable verbose logging in development
+	verbose: __DEV__,
+};
+`;
+}
+
+/**
+ * Create the init command
+ */
+export function createInitCommand(): Command {
+	const command = new Command("init")
+		.description("Initialize a new Teardown React Native project")
+		.argument("<name>", "App name (required)")
+		.option("-f, --force", "Overwrite existing files", false)
+		.option("--skip-src", "Skip generating src folder", false)
+		.option("--skip-git", "Skip generating .gitignore", false)
+		.option("--skip-install", "Skip installing dependencies", false)
+		.action(async (name: string, options) => {
+			const spinner = ora("Initializing project...").start();
+
+			try {
+				const projectRoot = process.cwd();
+
+				// Check for existing config
+				const existingConfig = findConfigFile(projectRoot);
+				if (existingConfig && !options.force) {
+					spinner.fail("Configuration file already exists");
+					console.log(chalk.yellow(`\n  Found: ${existingConfig}`));
+					console.log(chalk.gray("  Use --force to overwrite"));
+					process.exit(1);
+				}
+
+				// Use provided name as the app name
+				const appName = name;
+
+				// Generate slug from name
+				const slug = appName
+					.toLowerCase()
+					.replace(/[^a-z0-9]+/g, "-")
+					.replace(/^-|-$/g, "");
+
+				// Generate bundle identifier
+				const bundleId = `com.example.${slug.replace(/-/g, "")}`;
+
+				// Generate config content
+				const configContent = generateDefaultConfig({
+					name: appName,
+					slug,
+					bundleIdentifier: bundleId,
+					packageName: bundleId,
+				});
+
+				// Write config file
+				const configPath = path.join(projectRoot, "teardown.config.ts");
+				fs.writeFileSync(configPath, configContent, "utf-8");
+
+				spinner.succeed("Created teardown.config.ts");
+
+				// Create template generator
+				const generator = new TemplateGenerator({
+					projectRoot,
+					variables: {
+						slug,
+						appName,
+						bundleIdentifier: bundleId,
+						version: "1.0.0",
+						buildNumber: 1,
+						packageName: bundleId,
+						versionCode: 1,
+						versionName: "1.0.0",
+						cliVersion: getCliVersion(),
+					},
+					force: options.force,
+				});
+
+				// Generate src folder
+				if (!options.skipSrc) {
+					const srcSpinner = ora("Generating src folder...").start();
+					const srcExists = await generator.srcFolderExists();
+
+					if (!srcExists || options.force) {
+						const srcResult = await generator.generateSrcFolder();
+						if (srcResult.success) {
+							srcSpinner.succeed(`Generated src/ folder (${srcResult.filesCreated.length} files)`);
+						} else {
+							srcSpinner.warn(`src/ folder had errors: ${srcResult.errors.join(", ")}`);
+						}
+					} else {
+						srcSpinner.info("src/ folder already exists, skipping");
+					}
+				}
+
+				// Generate package.json if it doesn't exist
+				const packageJsonPath = path.join(projectRoot, "package.json");
+				if (!fs.existsSync(packageJsonPath) || options.force) {
+					const pkgSpinner = ora("Generating package.json...").start();
+					const pkgResult = await generator.generatePackageJson();
+					if (pkgResult.success && pkgResult.filesCreated.length > 0) {
+						pkgSpinner.succeed("Generated package.json");
+					} else if (pkgResult.filesSkipped.length > 0) {
+						pkgSpinner.info("package.json already exists, skipping");
+					} else {
+						pkgSpinner.warn(`package.json had errors: ${pkgResult.errors.join(", ")}`);
+					}
+				}
+
+				// Generate root config files
+				const configSpinner = ora("Generating config files...").start();
+				const configResult = await generator.generateRootConfigFiles();
+				if (configResult.filesCreated.length > 0) {
+					configSpinner.succeed(`Generated: ${configResult.filesCreated.map((f) => path.basename(f)).join(", ")}`);
+				} else if (configResult.filesSkipped.length > 0) {
+					configSpinner.info("Config files already exist, skipping");
+				}
+
+				// Generate .gitignore
+				if (!options.skipGit) {
+					const gitignorePath = path.join(projectRoot, ".gitignore");
+					if (!fs.existsSync(gitignorePath) || options.force) {
+						const gitSpinner = ora("Generating .gitignore...").start();
+						const gitResult = await generator.generateGitignore();
+						if (gitResult.success && gitResult.filesCreated.length > 0) {
+							gitSpinner.succeed("Generated .gitignore (ios/ and android/ excluded)");
+						} else {
+							gitSpinner.warn(`gitignore had errors: ${gitResult.errors.join(", ")}`);
+						}
+					}
+				}
+
+				// Create assets directory if it doesn't exist
+				const assetsDir = path.join(projectRoot, "assets");
+				if (!fs.existsSync(assetsDir)) {
+					fs.mkdirSync(assetsDir, { recursive: true });
+				}
+
+				// Generate dev-client configuration
+				const devClientConfigPath = path.join(projectRoot, "dev-client.config.ts");
+				if (!fs.existsSync(devClientConfigPath) || options.force) {
+					const devClientSpinner = ora("Setting up dev client...").start();
+					try {
+						fs.writeFileSync(devClientConfigPath, generateDevClientConfig(), "utf-8");
+						devClientSpinner.succeed("Created dev-client.config.ts");
+					} catch {
+						devClientSpinner.warn("Failed to create dev-client.config.ts");
+					}
+				}
+
+				// Run bun install (unless skipped)
+				if (!options.skipInstall) {
+					const installSpinner = ora("Installing dependencies...").start();
+					await new Promise<void>((resolve, reject) => {
+						const child = spawn("bun", ["install"], {
+							cwd: projectRoot,
+							stdio: ["ignore", "pipe", "pipe"],
+						});
+
+						let stderr = "";
+						child.stderr?.on("data", (data) => {
+							stderr += data.toString();
+						});
+
+						child.on("close", (code) => {
+							if (code === 0) {
+								installSpinner.succeed("Dependencies installed");
+								resolve();
+							} else {
+								installSpinner.fail("Failed to install dependencies");
+								console.error(chalk.red(stderr));
+								reject(new Error(`bun install exited with code ${code}`));
+							}
+						});
+
+						child.on("error", (err) => {
+							installSpinner.fail("Failed to run bun install");
+							reject(err);
+						});
+					});
+				}
+
+				console.log(chalk.green("\n✓ Project initialized successfully!"));
+				console.log(chalk.gray("\nProject structure:"));
+				console.log(chalk.gray("  teardown.config.ts    - App configuration"));
+				console.log(chalk.gray("  dev-client.config.ts  - Dev client settings"));
+				console.log(chalk.gray("  src/                  - React Native source code"));
+				console.log(chalk.gray("  assets/               - App icons and images"));
+				console.log(chalk.gray("  .gitignore            - Excludes ios/ and android/"));
+
+				console.log(chalk.gray("\nNext steps:"));
+				console.log(chalk.cyan("  1. teardown prebuild") + chalk.gray(" - Generate native projects"));
+				console.log(chalk.cyan("  2. teardown run ios") + chalk.gray(" or ") + chalk.cyan("teardown run android"));
+			} catch (error) {
+				spinner.fail("Initialization failed");
+				console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+				process.exit(1);
+			}
+		});
+
+	return command;
+}

package/src/cli/commands/plugins.ts

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { CapabilityPlugins } from "../../plugins/capabilities";
+
+/**
+ * Create the plugins command
+ */
+export function createPluginsCommand(): Command {
+	const command = new Command("plugins").description("Manage Teardown plugins");
+
+	// List subcommand
+	command
+		.command("list")
+		.description("List all available plugins")
+		.action(() => {
+			console.log(chalk.cyan("\nAvailable Plugins:\n"));
+
+			const plugins = Object.entries(CapabilityPlugins).map(([_name, Plugin]) => {
+				const instance = new Plugin();
+				return {
+					name: instance.name,
+					version: instance.version,
+					description: instance.description,
+					platforms: instance.platforms,
+					provides: instance.provides,
+				};
+			});
+
+			// Group by capability
+			for (const plugin of plugins) {
+				const platformIcons = plugin.platforms.map((p) => (p === "ios" ? "" : "🤖")).join(" ");
+
+				console.log(`${chalk.bold(`  ${plugin.name}`) + chalk.gray(` v${plugin.version}`)} ${platformIcons}`);
+				console.log(chalk.gray(`    ${plugin.description}`));
+				console.log(chalk.gray(`    Provides: ${plugin.provides.join(", ")}`));
+				console.log();
+			}
+
+			console.log(chalk.gray("Usage in teardown.config.ts:"));
+			console.log(
+				chalk.gray(`
+  import { CameraPlugin, LocationPlugin } from '@teardown/cli/plugins';
+
+  export default defineConfig({
+    // ...
+    plugins: [
+      [CameraPlugin, { cameraPermission: 'We need camera access' }],
+      [LocationPlugin, { whenInUsePermission: 'We need location' }],
+    ],
+  });
+`)
+			);
+		});
+
+	// Info subcommand
+	command
+		.command("info <name>")
+		.description("Show detailed information about a plugin")
+		.action((name: string) => {
+			const PluginClass = Object.values(CapabilityPlugins).find((P) => {
+				const instance = new P();
+				return instance.name === name;
+			});
+
+			if (!PluginClass) {
+				console.error(chalk.red(`Plugin "${name}" not found`));
+				console.log(chalk.gray("\nRun 'teardown plugins list' to see available plugins"));
+				process.exit(1);
+			}
+
+			const plugin = new PluginClass();
+
+			console.log(chalk.cyan(`\n${plugin.name}`));
+			console.log(chalk.gray(`  Version: ${plugin.version}`));
+			console.log(chalk.gray(`  ${plugin.description}\n`));
+
+			console.log(chalk.bold("Platforms:"));
+			console.log(chalk.gray(`  ${plugin.platforms.join(", ")}\n`));
+
+			console.log(chalk.bold("Provides:"));
+			console.log(chalk.gray(`  ${plugin.provides.join(", ")}\n`));
+
+			if (plugin.dependencies.length > 0) {
+				console.log(chalk.bold("Dependencies:"));
+				console.log(chalk.gray(`  ${plugin.dependencies.join(", ")}\n`));
+			}
+
+			console.log(chalk.bold("Configuration Schema:"));
+			console.log(chalk.gray("  See plugin documentation for schema details"));
+		});
+
+	return command;
+}

package/src/cli/commands/prebuild.ts

@@ -0,0 +1,168 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { loadConfig } from "../../config";
+import type { PrebuildOptions } from "../../config/types";
+import { createPipeline } from "../../pipeline";
+import type { BasePlugin } from "../../plugins/base";
+import { getPluginByName } from "../../plugins/capabilities";
+import { createLogger, formatDuration } from "../../utils";
+
+/**
+ * Create the prebuild command
+ */
+export function createPrebuildCommand(): Command {
+	const command = new Command("prebuild")
+		.description("Generate native iOS and Android projects from configuration")
+		.option("-p, --platform <platform>", "Target platform (ios, android, all)", "all")
+		.option("-c, --clean", "Clean native directories before prebuild", false)
+		.option("-d, --dry-run", "Preview changes without applying", false)
+		.option("-v, --verbose", "Enable verbose logging", false)
+		.option("--skip-validation", "Skip configuration validation", false)
+		.action(async (options) => {
+			const spinner = ora("Starting prebuild...").start();
+			const startTime = Date.now();
+
+			const logger = createLogger({
+				level: options.verbose ? "debug" : "info",
+				colors: true,
+			});
+
+			try {
+				const projectRoot = process.cwd();
+
+				// Load configuration
+				spinner.text = "Loading configuration...";
+				const configResult = await loadConfig(projectRoot);
+
+				if (!configResult.success || !configResult.config) {
+					spinner.fail("Failed to load configuration");
+					console.error(chalk.red("\nConfiguration errors:"));
+					for (const error of configResult.errors ?? []) {
+						console.error(chalk.red(`  - ${error.path}: ${error.message}`));
+						if (error.suggestion) {
+							console.error(chalk.gray(`    Suggestion: ${error.suggestion}`));
+						}
+					}
+					process.exit(1);
+				}
+
+				spinner.text = "Resolving plugins...";
+
+				// Create pipeline
+				const pipeline = createPipeline({ logger });
+
+				// Register plugins from configuration
+				const plugins = configResult.config.plugins ?? [];
+				for (const pluginEntry of plugins) {
+					if (typeof pluginEntry === "string") {
+						// String plugin name
+						const PluginClass = getPluginByName(pluginEntry);
+						if (PluginClass) {
+							const plugin = new (PluginClass as new () => BasePlugin)();
+							pipeline.registerPlugin(plugin);
+						} else {
+							logger.warn(`Unknown plugin: ${pluginEntry}`);
+						}
+					} else if (Array.isArray(pluginEntry)) {
+						// [PluginClass, config] tuple
+						const [PluginClass, pluginConfig] = pluginEntry;
+						if (typeof PluginClass === "function") {
+							const plugin = new PluginClass();
+							pipeline.registerPlugin(plugin, pluginConfig);
+						}
+					}
+				}
+
+				// Execute pipeline
+				spinner.text = "Running prebuild...";
+
+				const prebuildOptions: PrebuildOptions = {
+					platform: options.platform as "ios" | "android" | "all",
+					clean: options.clean,
+					dryRun: options.dryRun,
+					projectRoot,
+					skipValidation: options.skipValidation,
+					verbose: options.verbose,
+				};
+
+				const result = await pipeline.execute(prebuildOptions);
+
+				const duration = formatDuration(Date.now() - startTime);
+
+				if (!result.success) {
+					spinner.fail(`Prebuild failed (${duration})`);
+					console.error(chalk.red("\nErrors:"));
+					for (const error of result.errors) {
+						console.error(chalk.red(`  - [${error.code}] ${error.message}`));
+						if (error.plugin) {
+							console.error(chalk.gray(`    Plugin: ${error.plugin}`));
+						}
+					}
+					process.exit(1);
+				}
+
+				// Show warnings
+				if (result.warnings.length > 0) {
+					console.log(chalk.yellow("\nWarnings:"));
+					for (const warning of result.warnings) {
+						console.log(chalk.yellow(`  - [${warning.code}] ${warning.message}`));
+						if (warning.suggestion) {
+							console.log(chalk.gray(`    Suggestion: ${warning.suggestion}`));
+						}
+					}
+				}
+
+				// Show changes
+				if (options.dryRun && result.changes) {
+					spinner.succeed(`Dry run completed (${duration})`);
+					console.log(chalk.cyan("\nPending changes:"));
+
+					const iosChanges = result.changes.filter((c) => c.path.includes("/ios/"));
+					const androidChanges = result.changes.filter((c) => c.path.includes("/android/"));
+
+					if (iosChanges.length > 0) {
+						console.log(chalk.blue("\n  iOS:"));
+						for (const change of iosChanges) {
+							const icon = change.operation === "create" ? "+" : change.operation === "delete" ? "-" : "~";
+							const color =
+								change.operation === "create" ? chalk.green : change.operation === "delete" ? chalk.red : chalk.yellow;
+							console.log(color(`    ${icon} ${change.path.split("/ios/")[1]}`));
+						}
+					}
+
+					if (androidChanges.length > 0) {
+						console.log(chalk.green("\n  Android:"));
+						for (const change of androidChanges) {
+							const icon = change.operation === "create" ? "+" : change.operation === "delete" ? "-" : "~";
+							const color =
+								change.operation === "create" ? chalk.green : change.operation === "delete" ? chalk.red : chalk.yellow;
+							console.log(color(`    ${icon} ${change.path.split("/android/")[1]}`));
+						}
+					}
+
+					console.log(chalk.gray(`\n  Run without --dry-run to apply changes.`));
+				} else {
+					spinner.succeed(`Prebuild completed (${duration})`);
+
+					if (result.changes && result.changes.length > 0) {
+						console.log(chalk.green(`\n  ${result.changes.length} files modified`));
+					}
+
+					// Show iOS workspace hint if iOS was built
+					if (options.platform === "ios" || options.platform === "all") {
+						console.log(chalk.gray(`\n  iOS: Use the .xcworkspace file (not .xcodeproj) to open in Xcode`));
+					}
+				}
+			} catch (error) {
+				spinner.fail("Prebuild failed");
+				console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+				if (options.verbose && error instanceof Error && error.stack) {
+					console.error(chalk.gray(error.stack));
+				}
+				process.exit(1);
+			}
+		});
+
+	return command;
+}