@package-pal/cli 0.0.20 → 0.0.23

package/bin/ppal

@@ -1,47 +1,15 @@
-#!/usr/bin/env node
-
-// Fallback, if post-install script did not execute.
-// Adds more overhead due to launching a Node process which launches the CLI process.
-
-import { getPathInfo } from '../src/lib/install/functions/get-path-info.js';
-import { getPlatformInfo } from '../src/lib/install/functions/get-platform-info.js';
-import { join } from 'path';
-import { existsSync, mkdirSync, rmSync } from 'fs';
-import { loadMissingBinary } from '../src/lib/install/functions/load-missing-binary.js';
-
-
-/**
- * @param binPath {string}
- */
-const exec = (binPath) => {
-	require('child_process').execFileSync(binPath, process.argv.slice(2), {
-		stdio: 'inherit',
-	})
-}
-
-async function main() {
-	const {
-		platform, targetPackage
-	} = getPlatformInfo();
-	const { targetBinPath, binExecutableName, outputBinDir } = getPathInfo({ platform, targetPackage });
-	const binarySourceDir = join(outputBinDir, 'source');
-
-	if (targetBinPath) {
-		rmSync(binarySourceDir, { force: true, recursive: true });
-		return exec(targetBinPath);
-	}
-
-	const prevDownloadedBinPath = join(binarySourceDir, binExecutableName);
-	if (!existsSync(prevDownloadedBinPath)) {
-		rmSync(binarySourceDir, { force: true, recursive: true });
-		mkdirSync(binarySourceDir, { recursive: true });
-		await loadMissingBinary({binExecutableName, targetPackage, outputBinDir: binarySourceDir});
-	}
-
-	exec(targetBinPath);
-}
-
-main().catch((err) => {
-	console.error(err);
-	process.exit(1);
-});
+#!/usr/bin/env node
+
+// Fallback, for Windows OR if the post-install script did not execute.
+// Adds more overhead due to launching a Node process which launches the CLI process.
+
+import { launchFallback } from '../src/lib/install/functions/launch-fallback.js';
+
+const main = () => {
+	return launchFallback();
+}
+
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@package-pal/cli",
-  "version": "0.0.20",
+  "version": "0.0.23",
   "description": "CLI tool exposing core PackagePal functionality.",
   "keywords": [
     "package",
@@ -16,12 +16,12 @@
     "tar": "^7.4.3"
   },
   "devDependencies": {
+    "@package-pal/core": "0.0.3",
+    "@package-pal/util": "0.0.5",
     "@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",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.2",
     "yoctocolors": "^2.1.1"
   },
   "optionalDependencies": {

package/src/lib/install/functions/exec.js

@@ -0,0 +1,11 @@
+import { execFileSync } from 'child_process';
+
+/**
+ * @param {string} binPath
+ * @param {string[]} args
+ */
+export const exec = (binPath, args = process.argv.slice(2)) => {
+	return execFileSync(
+		binPath, args, { stdio: 'inherit' },
+	);
+};

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

@@ -1,56 +1,56 @@
-import { createRequire } from 'module';
-import {
-	dirname, join, resolve,
-} from 'path';
-import { fileURLToPath } from 'url';
-import packageJson from '../../../../package.json' with { type: 'json' };
-
-const require = createRequire(import.meta.url);
-
-/**
- * @param {{ platform: Bun.Platform, targetPackage: string }} options
- */
-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 '${targetPackage}' bin name.`);
-	}
-
-	const targetVersion = packageJson.version;
-	if (!targetVersion) {
-		throw new Error(`Expected '${targetPackage}' version.`);
-	}
-
-	const packageRootDir = resolve(
-		__dirname, '..', '..', '..', '..',
-	);
-
-	const binExecutableName = platform === 'win32' ? `${binName}.exe` : binName;
-	const outputBinDir = join(packageRootDir, 'bin');
-	const outputBinBasePath = join(outputBinDir, binName);
-	const outputBinPath = join(outputBinDir, binExecutableName);
-
-	/** @type {string | null} */
-	let targetBinPath;
-	try {
-		targetBinPath = require.resolve(join(
-			'@package-pal', targetPackage, 'bin', binExecutableName,
-		));
-	} catch {
-		targetBinPath = null;
-	}
-
-	return {
-		packageRootDir,
-		outputBinDir,
-		binName,
-		binExecutableName,
-		outputBinBasePath,
-		outputBinPath,
-		targetBinPath,
-		targetVersion,
-	};
-};
+import { createRequire } from 'module';
+import {
+	dirname, join, resolve,
+} from 'path';
+import { fileURLToPath } from 'url';
+import packageJson from '../../../../package.json' with { type: 'json' };
+
+const require = createRequire(import.meta.url);
+
+/**
+ * @param {{ platform: Bun.Platform, targetPackage: string }} options
+ */
+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 '${targetPackage}' bin name.`);
+	}
+
+	const targetVersion = packageJson.version;
+	if (!targetVersion) {
+		throw new Error(`Expected '${targetPackage}' version.`);
+	}
+
+	const packageRootDir = resolve(
+		__dirname, '..', '..', '..', '..',
+	);
+
+	const binExecutableName = platform === 'win32' ? `${binName}.exe` : binName;
+	const outputBinDir = join(packageRootDir, 'bin');
+	const outputBinBasePath = join(outputBinDir, binName);
+	const outputBinPath = join(outputBinDir, binExecutableName);
+
+	/** @type {string | null} */
+	let targetBinPath;
+	try {
+		targetBinPath = require.resolve(join(
+			'@package-pal', targetPackage, 'bin', binExecutableName,
+		));
+	} catch {
+		targetBinPath = null;
+	}
+
+	return {
+		packageRootDir,
+		outputBinDir,
+		binName,
+		binExecutableName,
+		outputBinBasePath,
+		outputBinPath,
+		targetBinPath,
+		targetVersion,
+	};
+};

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

@@ -1,49 +1,49 @@
-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 {
-				// The report will not have a glibcVersionRuntime property if musl is being used.
-				/** @type {{ header?: { glibcVersionRuntime?: unknown } }} */
-				const report = process.report.getReport();
-				isMusl = !report.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 target: ${usePlatform} ${useArch}.`);
-	}
-
-	return {
-		platform: usePlatform,
-		arch: useArch,
-		targetPackage,
-	};
-};
+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 {
+				// The report will not have a glibcVersionRuntime property if musl is being used.
+				/** @type {{ header?: { glibcVersionRuntime?: unknown } }} */
+				const report = process.report.getReport();
+				isMusl = !report.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 target: ${usePlatform} ${useArch}.`);
+	}
+
+	return {
+		platform: usePlatform,
+		arch: useArch,
+		targetPackage,
+	};
+};

package/src/lib/install/functions/launch-fallback.js

@@ -0,0 +1,53 @@
+import {
+	existsSync, mkdirSync, rmSync,
+} from 'fs';
+import { join } from 'path';
+import { exec } from './exec.js';
+import { getPathInfo } from './get-path-info.js';
+import { getPlatformInfo } from './get-platform-info.js';
+import { loadMissingBinary } from './load-missing-binary.js';
+import { validateBinaryVersion } from './validate-binary-version.js';
+
+export const launchFallback = async () => {
+	const {
+		platform, targetPackage,
+	} = getPlatformInfo();
+	const {
+		targetBinPath, binExecutableName, outputBinDir, targetVersion,
+	} = getPathInfo({
+		platform,
+		targetPackage,
+	});
+	const downloadBinarySourceDir = join(
+		outputBinDir, 'source', 'bin',
+	);
+
+	if (targetBinPath) {
+		rmSync(downloadBinarySourceDir, {
+			force: true,
+			recursive: true,
+		});
+		validateBinaryVersion(targetVersion, targetBinPath);
+
+		return exec(targetBinPath);
+	}
+
+	const prevDownloadedBinPath = join(downloadBinarySourceDir, binExecutableName);
+	if (!existsSync(prevDownloadedBinPath)) {
+		rmSync(downloadBinarySourceDir, {
+			force: true,
+			recursive: true,
+		});
+		mkdirSync(downloadBinarySourceDir, { recursive: true });
+		await loadMissingBinary({
+			binExecutableName,
+			targetPackage,
+			outputBinDir: downloadBinarySourceDir,
+		});
+	}
+
+	const downloadBinPath = join(downloadBinarySourceDir, binExecutableName);
+	validateBinaryVersion(targetVersion, downloadBinPath);
+
+	return exec(downloadBinPath);
+};

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

@@ -1,62 +1,62 @@
-import {
-	copyFileSync, existsSync, linkSync, symlinkSync, unlinkSync,
-} from 'fs';
-
-/**
- * @param {{ platform: Bun.Platform, targetBinPath: string, outputBinPath: string }} options
- */
-export const linkExistingBinary = ({
-	platform, targetBinPath, outputBinPath,
-}) => {
-	const isWin = platform === 'win32';
-
-	/**
-	 *  @param {string | undefined} method
-	 */
-	const verifyLinked = (method) => {
-		if (!existsSync(outputBinPath)) {
-			throw new Error(`Expected link not found${method ? ` after ${method}` : ''}: '${outputBinPath}'.`);
-		}
-	};
-
-	const errs = [];
-
-	try {
-		unlinkSync(outputBinPath);
-	} catch (e) {
-		errs.push(e);
-	}
-
-	if (!isWin) {
-		try {
-			symlinkSync(targetBinPath, outputBinPath);
-			verifyLinked('symlinkSync');
-
-			return;
-		} catch (eSymlinkSync) {
-			errs.push(eSymlinkSync);
-		}
-	}
-
-	try {
-		linkSync(targetBinPath, outputBinPath);
-		verifyLinked('linkSync');
-	} catch (eLinkSync) {
-		errs.push(eLinkSync);
-
-		try {
-			copyFileSync(targetBinPath, outputBinPath);
-			verifyLinked('copyFileSync');
-		} catch (eCopyFileSync) {
-			errs.push(eCopyFileSync);
-		}
-	}
-
-	try {
-		verifyLinked(undefined);
-	} catch {
-		throw new Error('Unable to link CLI binary.', { cause: errs });
-	}
-
-	console.info(`Successfully linked binary: '${outputBinPath}' → '${targetBinPath}'.`);
-};
+import {
+	copyFileSync, existsSync, linkSync, symlinkSync, unlinkSync,
+} from 'fs';
+
+/**
+ * @param {{ platform: Bun.Platform, targetBinPath: string, outputBinPath: string }} options
+ */
+export const linkExistingBinary = ({
+	platform, targetBinPath, outputBinPath,
+}) => {
+	const isWin = platform === 'win32';
+
+	/**
+	 *  @param {string | undefined} method
+	 */
+	const verifyLinked = (method) => {
+		if (!existsSync(outputBinPath)) {
+			throw new Error(`Expected link not found${method ? ` after ${method}` : ''}: '${outputBinPath}'.`);
+		}
+	};
+
+	const errs = [];
+
+	try {
+		unlinkSync(outputBinPath);
+	} catch (e) {
+		errs.push(e);
+	}
+
+	if (!isWin) {
+		try {
+			symlinkSync(targetBinPath, outputBinPath);
+			verifyLinked('symlinkSync');
+
+			return;
+		} catch (eSymlinkSync) {
+			errs.push(eSymlinkSync);
+		}
+	}
+
+	try {
+		linkSync(targetBinPath, outputBinPath);
+		verifyLinked('linkSync');
+	} catch (eLinkSync) {
+		errs.push(eLinkSync);
+
+		try {
+			copyFileSync(targetBinPath, outputBinPath);
+			verifyLinked('copyFileSync');
+		} catch (eCopyFileSync) {
+			errs.push(eCopyFileSync);
+		}
+	}
+
+	try {
+		verifyLinked(undefined);
+	} catch {
+		throw new Error('Unable to link CLI binary.', { cause: errs });
+	}
+
+	console.info(`Successfully linked binary: '${outputBinPath}' → '${targetBinPath}'.`);
+};

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

@@ -1,107 +1,107 @@
-import { chmod } from 'fs/promises';
-import { get } from 'https';
-import { join } from 'path';
-import { pipeline } from 'stream/promises';
-import { x } from 'tar';
-import packageJson from '../../../../package.json' with { type: 'json' };
-
-const maxAttempts = 5;
-const initialBackoffMs = 500;
-
-/**
- * @param {string} tarballUrl
- * @param {string} binExecutableName
- * @param {string} outputBinDir
- */
-const tryDownloadAndExtract = (
-	tarballUrl, binExecutableName, outputBinDir,
-) => {
-	return new Promise((resolve, reject) => {
-		get(tarballUrl, (res) => {
-			const isRedirect = res.statusCode && (res.statusCode >= 300
-				&& res.statusCode < 400);
-			const isSuccess = res.statusCode === 200;
-
-			if (isRedirect) {
-				if (!res.headers.location) {
-					reject(new Error(`Failed to download binary: Redirect location missing.`));
-					return;
-				}
-				downloadAndExtract(
-					res.headers.location, binExecutableName, outputBinDir,
-				)
-					.then(resolve)
-					.catch(reject);
-				return;
-			}
-
-			if (!isSuccess) {
-				reject(new Error(`Failed to download binary: ${res.statusCode?.toString() ?? 'Unknown'}`));
-				return;
-			}
-
-			const extractStream = x({
-				cwd: outputBinDir,
-				strip: 1,
-				filter: path => path === `package/bin/${binExecutableName}`,
-			});
-
-			pipeline(res, extractStream).then(resolve)
-				.catch(reject);
-		}).on('error', reject);
-	});
-};
-
-/**
- * @param {string} tarballUrl
- * @param {string} binExecutableName
- * @param {string} outputBinDir
- */
-const downloadAndExtract = async (
-	tarballUrl, binExecutableName, outputBinDir,
-) => {
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-		try {
-			await tryDownloadAndExtract(
-				tarballUrl, binExecutableName, outputBinDir,
-			);
-			return;
-		} catch (error) {
-			if (attempt < maxAttempts) {
-				const delay = initialBackoffMs * 2 ** (attempt - 1);
-				console.warn(`Download failed (attempt ${attempt.toString()}), retrying in ${delay.toString()}ms...`);
-			} else {
-				throw error;
-			}
-		}
-	}
-
-	try {
-		await chmod(join(outputBinDir, binExecutableName), 0o755);
-	} catch {
-		//
-	}
-};
-
-/**
- * @param {{ binExecutableName: string, targetPackage: string, outputBinDir: string }} options
- */
-export const loadMissingBinary = async ({
-	binExecutableName, targetPackage, outputBinDir,
-}) => {
-	const fullTargetPackageName = `@package-pal/${targetPackage}`;
-	/** @type {Record<string, string>} */
-	const optionalDeps = packageJson.optionalDependencies;
-	const targetPackageVersion = optionalDeps[fullTargetPackageName];
-
-	if (!targetPackageVersion) {
-		throw new Error(`No version found for target package '${fullTargetPackageName}'.`);
-	}
-
-	const tarballUrl = `https://registry.npmjs.org/${fullTargetPackageName}/-/${targetPackage}-${targetPackageVersion}.tgz`;
-	console.info(`Downloading '${fullTargetPackageName}' into '${outputBinDir}' from ${tarballUrl}...`);
-
-	await downloadAndExtract(
-		tarballUrl, binExecutableName, outputBinDir,
-	);
-};
+import { chmod } from 'fs/promises';
+import { get } from 'https';
+import { join } from 'path';
+import { pipeline } from 'stream/promises';
+import { x } from 'tar';
+import packageJson from '../../../../package.json' with { type: 'json' };
+
+const maxAttempts = 5;
+const initialBackoffMs = 500;
+
+/**
+ * @param {string} tarballUrl
+ * @param {string} binExecutableName
+ * @param {string} outputBinDir
+ */
+const tryDownloadAndExtract = (
+	tarballUrl, binExecutableName, outputBinDir,
+) => {
+	return new Promise((resolve, reject) => {
+		get(tarballUrl, (res) => {
+			const isRedirect = res.statusCode && (res.statusCode >= 300
+				&& res.statusCode < 400);
+			const isSuccess = res.statusCode === 200;
+
+			if (isRedirect) {
+				if (!res.headers.location) {
+					reject(new Error(`Failed to download binary: Redirect location missing.`));
+					return;
+				}
+				downloadAndExtract(
+					res.headers.location, binExecutableName, outputBinDir,
+				)
+					.then(resolve)
+					.catch(reject);
+				return;
+			}
+
+			if (!isSuccess) {
+				reject(new Error(`Failed to download binary: ${res.statusCode?.toString() ?? 'Unknown'}`));
+				return;
+			}
+
+			const extractStream = x({
+				cwd: outputBinDir,
+				strip: 1,
+				filter: path => path === `package/bin/${binExecutableName}`,
+			});
+
+			pipeline(res, extractStream).then(resolve)
+				.catch(reject);
+		}).on('error', reject);
+	});
+};
+
+/**
+ * @param {string} tarballUrl
+ * @param {string} binExecutableName
+ * @param {string} outputBinDir
+ */
+const downloadAndExtract = async (
+	tarballUrl, binExecutableName, outputBinDir,
+) => {
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			await tryDownloadAndExtract(
+				tarballUrl, binExecutableName, outputBinDir,
+			);
+			return;
+		} catch (error) {
+			if (attempt < maxAttempts) {
+				const delay = initialBackoffMs * 2 ** (attempt - 1);
+				console.warn(`Download failed (attempt ${attempt.toString()}), retrying in ${delay.toString()}ms...`);
+			} else {
+				throw error;
+			}
+		}
+	}
+
+	try {
+		await chmod(join(outputBinDir, binExecutableName), 0o755);
+	} catch {
+		//
+	}
+};
+
+/**
+ * @param {{ binExecutableName: string, targetPackage: string, outputBinDir: string }} options
+ */
+export const loadMissingBinary = async ({
+	binExecutableName, targetPackage, outputBinDir,
+}) => {
+	const fullTargetPackageName = `@package-pal/${targetPackage}`;
+	/** @type {Record<string, string>} */
+	const optionalDeps = packageJson.optionalDependencies;
+	const targetPackageVersion = optionalDeps[fullTargetPackageName];
+
+	if (!targetPackageVersion) {
+		throw new Error(`No version found for target package '${fullTargetPackageName}'.`);
+	}
+
+	const tarballUrl = `https://registry.npmjs.org/${fullTargetPackageName}/-/${targetPackage}-${targetPackageVersion}.tgz`;
+	console.info(`Downloading '${fullTargetPackageName}' into '${outputBinDir}' from ${tarballUrl}...`);
+
+	await downloadAndExtract(
+		tarballUrl, binExecutableName, outputBinDir,
+	);
+};

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

@@ -1,33 +1,33 @@
-import {
-	mkdirSync, rmSync,
-} from 'fs';
-import { linkExistingBinary } from './link-existing-binary.js';
-import { loadMissingBinary } from './load-missing-binary.js';
-
-/**
- * @param {{ platform: Bun.Platform, binExecutableName: string, targetPackage: string, targetBinPath: string | null, outputBinDir: string, outputBinBasePath: string, outputBinPath: string }} options
- */
-export const prepareBinary = ({
-	platform, binExecutableName, targetPackage, targetBinPath, outputBinDir, outputBinBasePath, outputBinPath,
-}) => {
-	rmSync(outputBinBasePath, { force: true });
-	rmSync(outputBinPath, { force: true });
-	mkdirSync(outputBinDir, { recursive: true });
-
-	if (targetBinPath) {
-		console.info(`Expected CLI binary package is available in '${targetBinPath}'.`);
-		linkExistingBinary({
-			platform,
-			targetBinPath,
-			outputBinPath,
-		});
-		return Promise.resolve();
-	}
-
-	console.warn(`Expected CLI binary was not found for '${targetPackage}'.`);
-	return loadMissingBinary({
-		binExecutableName,
-		targetPackage,
-		outputBinDir,
-	});
-};
+import {
+	mkdirSync, rmSync,
+} from 'fs';
+import { linkExistingBinary } from './link-existing-binary.js';
+import { loadMissingBinary } from './load-missing-binary.js';
+
+/**
+ * @param {{ platform: Bun.Platform, binExecutableName: string, targetPackage: string, targetBinPath: string | null, outputBinDir: string, outputBinBasePath: string, outputBinPath: string }} options
+ */
+export const prepareBinary = ({
+	platform, binExecutableName, targetPackage, targetBinPath, outputBinDir, outputBinBasePath, outputBinPath,
+}) => {
+	rmSync(outputBinBasePath, { force: true });
+	rmSync(outputBinPath, { force: true });
+	mkdirSync(outputBinDir, { recursive: true });
+
+	if (targetBinPath) {
+		console.info(`Expected CLI binary package is available in '${targetBinPath}'.`);
+		linkExistingBinary({
+			platform,
+			targetBinPath,
+			outputBinPath,
+		});
+		return Promise.resolve();
+	}
+
+	console.warn(`Expected CLI binary was not found for '${targetPackage}'.`);
+	return loadMissingBinary({
+		binExecutableName,
+		targetPackage,
+		outputBinDir,
+	});
+};

package/src/lib/install/functions/validate-binary-version.js

@@ -1,3 +1,14 @@
-// export const validateBinaryVersion = (targetVersion) => {
-// 	//
-// };
+import { exec } from './exec.js';
+
+/**
+ * @param {string} targetVersion
+ * @param {string} targetBinPath
+ */
+export const validateBinaryVersion = (targetVersion, targetBinPath) => {
+	const stdout = exec(targetBinPath).toString()
+		.trim();
+
+	if (stdout.toLowerCase() !== targetVersion.toLowerCase()) {
+		throw new Error(`'${targetBinPath}' binary version mismatch; expected ${targetVersion}, got ${stdout}.`);
+	}
+};

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

@@ -1,27 +1,33 @@
-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, binExecutableName, outputBinBasePath, outputBinPath, targetBinPath,
-	} = getPathInfo({
-		platform,
-		targetPackage,
-	});
-
-	await prepareBinary({
-		platform,
-		binExecutableName,
-		targetPackage,
-		targetBinPath,
-		outputBinDir,
-		outputBinBasePath,
-		outputBinPath,
-	});
-} catch (e) {
-	throw new Error('Postinstall failed to install CLI binary.', { cause: e });
-}
+import { getPathInfo } from './functions/get-path-info.js';
+import { getPlatformInfo } from './functions/get-platform-info.js';
+import { prepareBinary } from './functions/prepare-binary.js';
+import { validateBinaryVersion } from './functions/validate-binary-version.js';
+
+try {
+	const {
+		platform, targetPackage,
+	} = getPlatformInfo();
+
+	// Windows can't be optimised to run the binary directly (.exe).
+	if (platform !== 'win32') {
+		const {
+			outputBinDir, binExecutableName, outputBinBasePath, outputBinPath, targetBinPath, targetVersion,
+		} = getPathInfo({
+			platform,
+			targetPackage,
+		});
+
+		await prepareBinary({
+			platform,
+			binExecutableName,
+			targetPackage,
+			targetBinPath,
+			outputBinDir,
+			outputBinBasePath,
+			outputBinPath,
+		});
+		validateBinaryVersion(targetVersion, outputBinPath);
+	}
+} catch (e) {
+	throw new Error('Post install failed to install CLI binary.', { cause: e });
+}