@babelx/cli 0.2.1 → 0.2.3

package/bin/bx

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
 /**
- * BabelX CLI - Binary wrapper
- * Detects platform and runs the appropriate binary
+ * BabelX CLI - Binary wrapper with lazy download
+ * Downloads the appropriate binary on first run
  */
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { createWriteStream, existsSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { platform as getPlatformName, arch as getArch } from "node:os";
+import { get } from "node:https";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const GITHUB_REPO = "babelxdev/bx-cli";
+
 function getPlatform() {
 	const platform = getPlatformName();
 	const arch = getArch();
@@ -32,33 +35,125 @@ function getPlatform() {
 	const a = archMap[arch];
 
 	if (!p || !a) {
-		console.error(`Unsupported platform: ${platform} ${arch}`);
+		console.error(`❌ Unsupported platform: ${platform} ${arch}`);
 		process.exit(1);
 	}
 
 	return `${p}-${a}`;
 }
 
+function getBinaryName() {
+	return process.platform === "win32" ? "bx.exe" : "bx";
+}
+
 function getBinaryPath() {
 	const platform = getPlatform();
 	const binDir = join(__dirname, "..", "vendor");
-	const binName = platform.startsWith("windows") ? "bx.exe" : "bx";
-	const binPath = join(binDir, platform, binName);
+	const binName = getBinaryName();
+	return join(binDir, platform, binName);
+}
+
+async function downloadBinary(platform, destPath) {
+	const binaryName = getBinaryName();
+	const packageJson = JSON.parse(
+		await import("node:fs").then((fs) =>
+			fs.readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
+		),
+	);
+	const version = packageJson.version;
+	const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/bx-${platform}${process.platform === "win32" ? ".exe" : ""}`;
+
+	console.log(`📦 First time setup: Downloading BabelX CLI v${version}`);
+	console.log(`   Platform: ${platform}`);
+	console.log("");
+
+	// Ensure directory exists
+	const dir = dirname(destPath);
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
 
-	return binPath;
+	return new Promise((resolve, reject) => {
+		const file = createWriteStream(destPath);
+		let downloaded = 0;
+		let total = 0;
+		let lastPercent = -1;
+
+		function formatBytes(bytes) {
+			if (bytes === 0) return "0 B";
+			const k = 1024;
+			const sizes = ["B", "KB", "MB", "GB"];
+			const i = Math.floor(Math.log(bytes) / Math.log(k));
+			return `${(bytes / k ** i).toFixed(1)} ${sizes[i]}`;
+		}
+
+		function updateProgress() {
+			if (total === 0) return;
+			const percent = Math.floor((downloaded / total) * 100);
+			if (percent !== lastPercent && percent % 5 === 0) {
+				const bar = "█".repeat(Math.floor(percent / 5)) + "░".repeat(20 - Math.floor(percent / 5));
+				process.stdout.write(`\r   ${bar} ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
+				lastPercent = percent;
+			}
+		}
+
+		function handleResponse(response) {
+			total = parseInt(response.headers["content-length"] || "0", 10);
+
+			response.on("data", (chunk) => {
+				downloaded += chunk.length;
+				updateProgress();
+			});
+
+			response.pipe(file);
+
+			file.on("finish", () => {
+				process.stdout.write("\n");
+				file.close();
+				resolve();
+			});
+		}
+
+		get(url, { followRedirects: true }, (response) => {
+			if (response.statusCode === 302 || response.statusCode === 301) {
+				get(response.headers.location, handleResponse).on("error", reject);
+			} else if (response.statusCode === 200) {
+				handleResponse(response);
+			} else {
+				reject(
+					new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`),
+				);
+			}
+		}).on("error", reject);
+	});
+}
+
+function makeExecutable(filePath) {
+	if (process.platform !== "win32") {
+		import("node:fs").then((fs) => fs.chmodSync(filePath, 0o755));
+	}
 }
 
-function main() {
+async function main() {
 	const binaryPath = getBinaryPath();
+	const platform = getPlatform();
 
-	// Check if binary exists
+	// Download binary if it doesn't exist (lazy loading)
 	if (!existsSync(binaryPath)) {
-		console.error("BabelX CLI binary not found.");
-		console.error(`Expected path: ${binaryPath}`);
-		console.error("");
-		console.error("Please run: npm install @babelx/cli");
-		console.error("Or download the binary manually from GitHub releases.");
-		process.exit(1);
+		try {
+			await downloadBinary(platform, binaryPath);
+			makeExecutable(binaryPath);
+			console.log(`✅ BabelX CLI installed successfully!\n`);
+		} catch (error) {
+			console.error("❌ Failed to download BabelX CLI binary.");
+			console.error(`Error: ${error.message}`);
+			console.error("");
+			console.error("Please try:");
+			console.error("1. Check your internet connection");
+			console.error("2. Download manually from:");
+			console.error(`   https://github.com/${GITHUB_REPO}/releases`);
+			process.exit(1);
+		}
 	}
 
 	// Run the binary with all arguments

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@babelx/cli",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "BabelX CLI - AI-powered translation and i18n management tool",
 	"module": "index.ts",
 	"type": "module",

package/scripts/postinstall.js

@@ -1,23 +1,17 @@
 #!/usr/bin/env node
 /**
- * Post-install script for @babelx/cli
- * Downloads the appropriate binary for the current platform
+ * Post-install script for @babelx/cli (optional)
+ * Pre-downloads the binary during installation (if allowed)
+ * If this fails, the CLI will download lazily on first run
  */
 
-import {
-	chmodSync,
-	createWriteStream,
-	existsSync,
-	mkdirSync,
-	readFileSync,
-} from "node:fs";
+import { createWriteStream, existsSync, mkdirSync } from "node:fs";
 import { get } from "node:https";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const GITHUB_REPO = "babelxdev/bx-cli";
 
-// ES modules don't have __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -39,14 +33,7 @@ function getPlatform() {
 	const p = platformMap[platform];
 	const a = archMap[arch];
 
-	if (!p || !a) {
-		console.error(`❌ Unsupported platform: ${platform} ${arch}`);
-		console.error(
-			"Supported platforms: darwin-x64, darwin-arm64, linux-x64, linux-arm64, windows-x64",
-		);
-		process.exit(1);
-	}
-
+	if (!p || !a) return null;
 	return `${p}-${a}`;
 }
 
@@ -58,14 +45,10 @@ async function downloadBinary(version, platform, destPath) {
 	const binaryExt = process.platform === "win32" ? ".exe" : "";
 	const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/bx-${platform}${binaryExt}`;
 
-	console.log(`📦 Downloading BabelX CLI v${version} for ${platform}...`);
-	console.log(`   URL: ${url}`);
-
 	return new Promise((resolve, reject) => {
 		const file = createWriteStream(destPath);
 		get(url, { followRedirects: true }, (response) => {
 			if (response.statusCode === 302 || response.statusCode === 301) {
-				// Handle redirect
 				get(response.headers.location, (res) => {
 					res.pipe(file);
 					file.on("finish", () => {
@@ -80,78 +63,47 @@ async function downloadBinary(version, platform, destPath) {
 					resolve();
 				});
 			} else {
-				reject(
-					new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`),
-				);
+				reject(new Error(`HTTP ${response.statusCode}`));
 			}
 		}).on("error", reject);
 	});
 }
 
-function makeExecutable(filePath) {
-	if (process.platform !== "win32") {
-		chmodSync(filePath, 0o755);
-	}
-}
-
 async function main() {
-	// Skip in CI environment or if explicitly disabled
+	// Skip if CI, disabled, or not interactive
 	if (process.env.CI || process.env.SKIP_BABELX_BINARY) {
-		console.log("⏭️ Skipping binary download (CI environment)");
 		return;
 	}
 
 	try {
-		// Get package version
+		const platform = getPlatform();
+		if (!platform) return;
+
+		const { readFileSync } = await import("node:fs");
 		const packageJson = JSON.parse(
 			readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
 		);
 		const version = packageJson.version;
-
-		const platform = getPlatform();
 		const binaryName = getBinaryName();
-
-		// Create vendor directory
 		const vendorDir = join(__dirname, "..", "vendor", platform);
-		if (!existsSync(vendorDir)) {
-			mkdirSync(vendorDir, { recursive: true });
-		}
-
 		const binaryPath = join(vendorDir, binaryName);
 
-		// Check if binary already exists
-		if (existsSync(binaryPath)) {
-			console.log(`✅ BabelX CLI binary already exists for ${platform}`);
-			return;
+		if (existsSync(binaryPath)) return;
+
+		if (!existsSync(vendorDir)) {
+			mkdirSync(vendorDir, { recursive: true });
 		}
 
-		// Download binary
 		await downloadBinary(version, platform, binaryPath);
 
-		// Make executable (Unix only)
-		makeExecutable(binaryPath);
-
-		console.log(`✅ BabelX CLI v${version} installed successfully!`);
-		console.log(`   Binary: ${binaryPath}`);
-	} catch (error) {
-		// Don't fail installation if binary download fails (e.g., first release)
-		if (error.message.includes("404")) {
-			console.warn("⚠️ Binary not found for this version yet.");
-			console.warn("   The CLI will use the bundled JavaScript version.");
-			console.warn(
-				`   Check https://github.com/${GITHUB_REPO}/releases for updates.`,
-			);
-			return; // Don't fail installation
+		if (process.platform !== "win32") {
+			const { chmodSync } = await import("node:fs");
+			chmodSync(binaryPath, 0o755);
 		}
 
-		console.error("❌ Failed to install BabelX CLI binary:", error.message);
-		console.error("");
-		console.error("You can try:");
-		console.error("1. Check your internet connection");
-		console.error("2. Set SKIP_BABELX_BINARY=1 to skip binary download");
-		console.error("3. Install manually from GitHub releases:");
-		console.error(`   https://github.com/${GITHUB_REPO}/releases`);
-		// Don't exit with error - allow npm install to continue
+		console.log(`✅ BabelX CLI binary pre-downloaded for ${platform}`);
+	} catch {
+		// Silent fail - CLI will download on first run
 	}
 }