@babelx/cli 0.2.0 → 0.2.2

package/bin/bx

@@ -1,74 +1,143 @@
 #!/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
  */
 
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
+import { spawn } from "node:child_process";
+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 = os.platform();
-	const arch = os.arch();
+	const platform = getPlatformName();
+	const arch = getArch();
 
 	const platformMap = {
-		'darwin': 'darwin',
-		'linux': 'linux',
-		'win32': 'windows'
+		darwin: "darwin",
+		linux: "linux",
+		win32: "windows",
 	};
 
 	const archMap = {
-		'x64': 'x64',
-		'arm64': 'arm64'
+		x64: "x64",
+		arm64: "arm64",
 	};
 
 	const p = platformMap[platform];
 	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 = path.join(__dirname, '..', 'vendor');
-	const binName = platform.startsWith('windows') ? 'bx.exe' : 'bx';
-	const binPath = path.join(binDir, platform, binName);
+	const binDir = join(__dirname, "..", "vendor");
+	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" : ""}`;
 
-	return binPath;
+	console.log(`📦 First time setup: Downloading BabelX CLI v${version}...`);
+	console.log(`   Platform: ${platform}`);
+
+	// Ensure directory exists
+	const dir = dirname(destPath);
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+
+	return new Promise((resolve, reject) => {
+		const file = createWriteStream(destPath);
+		get(url, { followRedirects: true }, (response) => {
+			if (response.statusCode === 302 || response.statusCode === 301) {
+				get(response.headers.location, (res) => {
+					res.pipe(file);
+					file.on("finish", () => {
+						file.close();
+						resolve();
+					});
+				}).on("error", reject);
+			} else if (response.statusCode === 200) {
+				response.pipe(file);
+				file.on("finish", () => {
+					file.close();
+					resolve();
+				});
+			} else {
+				reject(
+					new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`),
+				);
+			}
+		}).on("error", reject);
+	});
 }
 
-function main() {
+function makeExecutable(filePath) {
+	if (process.platform !== "win32") {
+		import("node:fs").then((fs) => fs.chmodSync(filePath, 0o755));
+	}
+}
+
+async function main() {
 	const binaryPath = getBinaryPath();
+	const platform = getPlatform();
 
-	// Check if binary exists
-	if (!fs.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);
+	// Download binary if it doesn't exist (lazy loading)
+	if (!existsSync(binaryPath)) {
+		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
 	const child = spawn(binaryPath, process.argv.slice(2), {
-		stdio: 'inherit',
-		windowsHide: true
+		stdio: "inherit",
+		windowsHide: true,
 	});
 
-	child.on('error', (err) => {
-		console.error('Failed to start BabelX CLI:', err.message);
+	child.on("error", (err) => {
+		console.error("Failed to start BabelX CLI:", err.message);
 		process.exit(1);
 	});
 
-	child.on('exit', (code) => {
+	child.on("exit", (code) => {
 		process.exit(code || 0);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@babelx/cli",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"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
 	}
 }