@package-pal/cli 0.0.3 → 0.0.5

package/bin/ppal

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+throw new Error("Native binary not linked yet. Re-run `npm install` or check postinstall script.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@package-pal/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "CLI tool exposing core PackagePal functionality.",
   "keywords": [
     "package",
@@ -13,12 +13,13 @@
   "license": "MIT",
   "type": "module",
   "devDependencies": {
-    "typescript": "^5.8.3",
-    "@types/bun": "^1.2.19",
     "@clack/prompts": "^0.11.0",
     "@package-pal/core": "^0.0.2",
     "@package-pal/util": "^0.0.4",
     "@stricli/core": "^1.2.0",
+    "@types/bun": "^1.2.19",
+    "tar": "^7.4.3",
+    "typescript": "^5.8.3",
     "yoctocolors": "^2.1.1"
   },
   "optionalDependencies": {
@@ -30,17 +31,15 @@
     "@package-pal/cli-darwin-x64": "0.0.1",
     "@package-pal/cli-windows-x64": "0.0.1"
   },
-  "engines": {
-    "bun": ">=1.2.0"
-  },
   "bin": {
     "ppal": "bin/ppal",
     "dppal": "./src/index.ts"
   },
   "files": [
-    "./src/link-binary.js"
+    "src/lib/install",
+    "bin"
   ],
   "scripts": {
-    "postinstall": "node ./src/link-binary.js"
+    "postinstall": "node ./src/lib/install/install-binary.js"
   }
 }

package/src/lib/install/functions/clear-placeholder-binary.js

@@ -0,0 +1,14 @@
+import { rmSync } from 'fs';
+
+/**
+ * @param {Bun.Platform} platform
+ * @param {string} outputBinTargetBasePath
+ */
+export const clearPlaceholderBinary = (platform, outputBinTargetBasePath) => {
+	rmSync(outputBinTargetBasePath, { force: true });
+
+	if (platform === 'win32') {
+		rmSync(`${outputBinTargetBasePath}.exe`, { force: true });
+		rmSync(`${outputBinTargetBasePath}.cmd`, { force: true });
+	}
+};

package/src/lib/install/functions/get-path-info.js

@@ -0,0 +1,32 @@
+import {
+	dirname, join, resolve,
+} from 'path';
+import { fileURLToPath } from 'url';
+import packageJson from '../../../../package.json';
+
+/**
+ * @param {Bun.Platform} platform
+ * @param {string} targetPackage
+ */
+export const getPathInfo = (platform, targetPackage) => {
+	const __dirname = dirname(fileURLToPath(import.meta.url));
+	const binName = Object.keys(packageJson.bin)[0];
+	if (!binName) {
+		throw new Error('Expected bin name.');
+	}
+
+	const outputBinDir = resolve(
+		__dirname, '..', 'bin',
+	);
+	const outputBinTargetBasePath = join(outputBinDir, binName);
+	const targetBinPath = resolve(
+		__dirname, '..', '..', targetPackage, platform === 'win32' ? `${binName}.exe` : binName,
+	);
+
+	return {
+		outputBinDir,
+		binName,
+		outputBinTargetBasePath,
+		targetBinPath,
+	};
+};

package/src/lib/install/functions/get-platform-info.js

@@ -0,0 +1,50 @@
+import {
+	arch, platform,
+} from 'os';
+
+export const getPlatformInfo = () => {
+	const usePlatform = platform();
+	const useArch = arch();
+	let targetPackage = '';
+
+	switch (usePlatform) {
+		case 'darwin':
+			targetPackage = useArch === 'arm64' ? 'cli-darwin-arm64' : 'cli-darwin-x64';
+			break;
+
+		case 'win32':
+			targetPackage = 'cli-windows-x64';
+			break;
+
+		case 'linux':
+			let isMusl = false;
+			try {
+				// Determine if the OS is using musl libc.
+				// The report will not have a glibcVersionRuntime property if musl is being used.
+				// @ts-expect-error unknown type
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+				isMusl = !process.report.getReport().header?.glibcVersionRuntime;
+			} catch {
+				isMusl = true;
+			}
+
+			targetPackage
+				= useArch === 'arm64'
+					? isMusl
+						? 'cli-linux-arm64-musl'
+						: 'cli-linux-arm64'
+					: isMusl
+						? 'cli-linux-x64-musl'
+						: 'cli-linux-x64';
+	}
+
+	if (!targetPackage) {
+		throw new Error(`Unsupported platform: ${usePlatform} ${useArch}.`);
+	}
+
+	return {
+		platform: usePlatform,
+		arch: useArch,
+		targetPackage,
+	};
+};

package/src/lib/install/functions/link-existing-binary.js

@@ -0,0 +1,30 @@
+import {
+	copyFileSync, linkSync, symlinkSync, writeFileSync,
+} from 'fs';
+
+/**
+ * @param {Bun.Platform} platform
+ * @param {string} targetBinPath
+ * @param {string} binName
+ * @param {string} outputBinTargetBasePath
+ */
+export const linkExistingBinary = (
+	platform, binName, targetBinPath, outputBinTargetBasePath,
+) => {
+	if (platform !== 'win32') {
+		symlinkSync(targetBinPath, outputBinTargetBasePath);
+		return;
+	}
+
+	try {
+		linkSync(targetBinPath, outputBinTargetBasePath);
+	} catch {
+		try {
+			copyFileSync(targetBinPath, outputBinTargetBasePath);
+		} catch (e) {
+			throw new Error(`Failed to link to or copy target binary '${targetBinPath}'.`, { cause: e });
+		}
+	}
+
+	writeFileSync(`${outputBinTargetBasePath}.cmd`, `@echo off\r\n"%~dp0\\${binName}.exe" %*\r\n`);
+};

package/src/lib/install/functions/load-missing-binary.js

@@ -0,0 +1,79 @@
+import { get } from 'https';
+import { pipeline } from 'stream/promises';
+import { x } from 'tar';
+import packageJson from '../../../../package.json' with { type: 'json' };
+
+/**
+ * @param {string} tarballUrl
+ * @param {string} binName
+ * @param {string} outputBinDir
+ */
+const downloadAndExtract = async (
+	tarballUrl, binName, outputBinDir,
+) => {
+	for (let i = 0; i < 3; i++) {
+		try {
+			await new Promise((resolve, reject) => {
+				get(tarballUrl, (res) => {
+					if (res.statusCode === 301 || res.statusCode === 302) {
+						if (!res.headers.location) {
+							reject(new Error(`Failed to download binary: Redirect location missing.`));
+							return;
+						}
+
+						downloadAndExtract(
+							res.headers.location, binName, outputBinDir,
+						).then(resolve, reject);
+						return;
+					}
+
+					if (res.statusCode !== 200) {
+						reject(new Error(`Failed to download binary: ${res.statusCode?.toString() ?? 'Unknown'}.`));
+						return;
+					}
+
+					const extractStream = x({
+						cwd: outputBinDir,
+						strip: 1,
+						filter: path => path === `package/bin/${binName}`,
+					});
+
+					pipeline(res, extractStream).then(resolve)
+						.catch(reject);
+				}).on('error', reject);
+			});
+
+			return;
+		} catch (e) {
+			if (i < 2) {
+				console.warn(`Download failed, retrying...`);
+			} else {
+				throw e;
+			}
+		}
+	}
+};
+
+/**
+ * @param {string} binName
+ * @param {string} targetPackage
+ * @param {string} outputBinDir
+ */
+export const loadMissingBinary = async (
+	binName, targetPackage, outputBinDir,
+) => {
+	const fullTargetPackageName = `@package-pal/${targetPackage}`;
+	// @ts-expect-error unknown key
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+	const targetPackageVersion = packageJson.optionalDependencies[fullTargetPackageName];
+	if (!targetPackageVersion) {
+		throw new Error(`No version found for target package '${fullTargetPackageName}'.`);
+	}
+
+	const tarballUrl = `https://registry.npmjs.org/${fullTargetPackageName}/-/${fullTargetPackageName.replace('@', '').replace('/', '-')}-${String(targetPackageVersion)}.tgz`;
+	console.log(`Downloading '${fullTargetPackageName}' from ${tarballUrl}...`);
+
+	await downloadAndExtract(
+		tarballUrl, binName, outputBinDir,
+	);
+};

package/src/lib/install/functions/prepare-binary.js

@@ -0,0 +1,34 @@
+import {
+	existsSync, mkdirSync,
+} from 'fs';
+import { clearPlaceholderBinary } from './clear-placeholder-binary.js';
+import { linkExistingBinary } from './link-existing-binary.js';
+import { loadMissingBinary } from './load-missing-binary.js';
+
+/**
+ * @param {Bun.Platform} platform
+ * @param {string} binName
+ * @param {string} targetPackage
+ * @param {string} targetBinPath
+ * @param {string} outputBinDir
+ * @param {string} outputBinTargetBasePath
+ */
+export const prepareBinary = (
+	platform, binName, targetPackage, targetBinPath, outputBinDir, outputBinTargetBasePath,
+) => {
+	clearPlaceholderBinary(platform, outputBinTargetBasePath);
+	mkdirSync(outputBinDir, { recursive: true });
+
+	if (existsSync(targetBinPath)) {
+		console.info(`Expected CLI binary package is available in '${targetBinPath}'.`);
+		linkExistingBinary(
+			platform, binName, targetBinPath, outputBinTargetBasePath,
+		);
+		return Promise.resolve();
+	}
+
+	console.warn(`Expected CLI binary was not found in '${targetBinPath}'.`);
+	return loadMissingBinary(
+		binName, targetPackage, outputBinDir,
+	);
+};

package/src/lib/install/install-binary.js

@@ -0,0 +1,18 @@
+import { getPathInfo } from './functions/get-path-info.js';
+import { getPlatformInfo } from './functions/get-platform-info.js';
+import { prepareBinary } from './functions/prepare-binary.js';
+
+try {
+	const {
+		platform, targetPackage,
+	} = getPlatformInfo();
+	const {
+		outputBinDir, binName, outputBinTargetBasePath, targetBinPath,
+	} = getPathInfo(platform, targetPackage);
+
+	await prepareBinary(
+		platform, binName, targetPackage, targetBinPath, outputBinDir, outputBinTargetBasePath,
+	);
+} catch (e) {
+	throw new Error('Postinstall failed to install CLI binary.', { cause: e });
+}

package/src/link-binary.js

@@ -1,84 +0,0 @@
-import {
-	copyFileSync, existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync,
-} from 'fs';
-import {
-	arch, platform,
-} from 'os';
-import {
-	resolve, dirname,
-} from 'path';
-import { fileURLToPath } from 'url';
-import packageJson from '../package.json' with { type: 'json' };
-
-const usePlatform = platform();
-const useArch = arch();
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const binName = Object.keys(packageJson.bin)[0];
-if (!binName) {
-	throw new Error('Expected bin name.');
-}
-
-// const binName = usePlatform === 'win32' ? `${rawBinName}.exe` : rawBinName;
-const binDir = resolve(
-	__dirname, '..', 'bin',
-);
-const binTarget = resolve(binDir, binName);
-
-try {
-	rmSync(binTarget, { force: true });
-	rmSync(`${binTarget}.exe`, { force: true });
-	rmSync(`${binTarget}.cmd`, { force: true });
-	// eslint-disable-next-line unused-imports/no-unused-vars
-} catch (_) { /* empty */ }
-
-let platformPackage = '';
-switch (usePlatform) {
-	case 'darwin':
-		platformPackage = useArch === 'arm64' ? 'cli-darwin-arm64' : 'cli-darwin-x64';
-		break;
-
-	case 'win32':
-		platformPackage = 'cli-windows-x64';
-		break;
-
-	case 'linux':
-		let isMusl = false;
-		try {
-			// @ts-expect-error unknown type
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-			isMusl = !process.report.getReport().header?.glibcVersionRuntime;
-		} catch {
-			isMusl = true;
-		}
-
-		platformPackage
-			= useArch === 'arm64'
-				? isMusl
-					? 'cli-linux-arm64-musl'
-					: 'cli-linux-arm64'
-				: isMusl
-					? 'cli-linux-x64-musl'
-					: 'cli-linux-x64';
-}
-
-if (!platformPackage) {
-	throw new Error(`Unsupported platform: ${usePlatform} ${useArch}.`);
-}
-
-const binPath = resolve(
-	__dirname, '..', '..', platformPackage, usePlatform === 'win32' ? `${binName}.exe` : binName,
-);
-
-if (!existsSync(binPath)) {
-	throw new Error(`Expected binary not found: ${binPath}.`);
-}
-
-mkdirSync(binDir, { recursive: true });
-
-if (usePlatform === 'win32') {
-	copyFileSync(binPath, `${binTarget}.exe`);
-	writeFileSync(`${binTarget}.cmd`, `@echo off\r\n"%~dp0\\${binName}.exe" %*\r\n`);
-} else {
-	symlinkSync(binPath, binTarget);
-}