@hexclave/cli 1.0.68 → 1.0.70

package/dist/index.js

@@ -18,6 +18,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { createUrlIfValid } from "@hexclave/shared/dist/utils/urls";
 import { createTar } from "@hexclave/shared/dist/utils/tar";
+import * as zlib from "node:zlib";
 import { gzipSync } from "node:zlib";
 import { hexclaveDevEnvStatePath } from "@hexclave/shared/dist/utils/dev-env-state-path";
 import { createHash, randomBytes } from "crypto";
@@ -32,6 +33,7 @@ import { createInitPrompt } from "@hexclave/shared/dist/helpers/init-prompt";
 import { execFileSync, spawn } from "child_process";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
+import * as tar from "tar";
 import extractZip from "extract-zip";
 import { randomBytes as randomBytes$1 } from "node:crypto";
 import { KnownErrors } from "@hexclave/shared";
@@ -884,7 +886,7 @@ async function dashboardRequest(path, options, secret, port) {
 		throw new CliError(`Failed to reach local Hexclave dashboard at ${url}: ${errorMessage(error)}`);
 	}
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function responseErrorMessage(response) {
@@ -892,10 +894,10 @@ async function responseErrorMessage(response) {
 	if (text.length === 0) return "empty response body";
 	try {
 		const parsed = JSON.parse(text);
-		if (isRecord$1(parsed)) {
+		if (isRecord$2(parsed)) {
 			const error = parsed.error;
 			if (typeof error === "string") return error;
-			if (isRecord$1(error) && typeof error.message === "string") return error.message;
+			if (isRecord$2(error) && typeof error.message === "string") return error.message;
 		}
 	} catch {}
 	return text;
@@ -1842,6 +1844,9 @@ const DASHBOARD_CACHE_DIR_NAME = "dashboards";
 const DASHBOARD_COMPLETE_MARKER = ".hexclave-complete";
 const LOG_PREFIX$1 = "[Hexclave] ";
 const SAFE_VERSION_REGEX = /^v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)*$/;
+function isRecord$1(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
 const MANIFEST_FETCH_TIMEOUT_MS = 1e4;
 const DASHBOARD_DOWNLOAD_TIMEOUT_MS = 5 * 6e4;
 function isAllowedDownloadUrl(url) {
@@ -1855,19 +1860,65 @@ function isAllowedDownloadUrl(url) {
 	if (parsed.protocol === "http:") return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]" || parsed.hostname === "::1";
 	return false;
 }
+const DASHBOARD_PLATFORM_KEYS = [
+	"darwin-arm64",
+	"darwin-x64",
+	"linux-arm64",
+	"linux-x64",
+	"win32-arm64",
+	"win32-x64"
+];
 function logDashboard(message) {
 	console.warn(`${LOG_PREFIX$1}${message}`);
 }
 function parseDashboardManifest(raw) {
-	if (raw == null || typeof raw !== "object") return null;
+	if (!isRecord$1(raw)) return null;
 	const manifest = raw;
 	if (typeof manifest.version !== "string" || !SAFE_VERSION_REGEX.test(manifest.version)) return null;
 	if (typeof manifest.sha256 !== "string" || !/^[0-9a-f]{64}$/i.test(manifest.sha256)) return null;
 	if (typeof manifest.url !== "string" || !isAllowedDownloadUrl(manifest.url)) return null;
+	let platformArchives;
+	if (manifest.platformArchives != null) {
+		if (!isRecord$1(manifest.platformArchives)) return {
+			version: manifest.version,
+			sha256: manifest.sha256.toLowerCase(),
+			url: manifest.url
+		};
+		const validPlatformArchives = {};
+		for (const [platform, value] of Object.entries(manifest.platformArchives)) {
+			if (!DASHBOARD_PLATFORM_KEYS.some((supportedKey) => supportedKey === platform)) continue;
+			if (!isRecord$1(value)) continue;
+			const archive = value;
+			if (typeof archive.sha256 !== "string" || !/^[0-9a-f]{64}$/i.test(archive.sha256) || typeof archive.url !== "string" || !isAllowedDownloadUrl(archive.url)) continue;
+			validPlatformArchives[platform] = {
+				sha256: archive.sha256.toLowerCase(),
+				url: archive.url
+			};
+		}
+		if (Object.keys(validPlatformArchives).length > 0) platformArchives = validPlatformArchives;
+	}
 	return {
 		version: manifest.version,
 		sha256: manifest.sha256.toLowerCase(),
+		url: manifest.url,
+		...platformArchives == null ? {} : { platformArchives }
+	};
+}
+function dashboardPlatformKey(platform = process.platform, arch = process.arch) {
+	const key = `${platform}-${arch}`;
+	return DASHBOARD_PLATFORM_KEYS.find((supportedKey) => supportedKey === key);
+}
+function hasZstdSupport(zlibModule = zlib) {
+	return typeof zlibModule.createZstdCompress === "function" && typeof zlibModule.createZstdDecompress === "function";
+}
+function selectDashboardArchive(manifest, platformKey = dashboardPlatformKey(), zstdAvailable = hasZstdSupport()) {
+	const platformArchive = !zstdAvailable || platformKey == null ? void 0 : manifest.platformArchives?.[platformKey];
+	return platformArchive == null ? {
+		sha256: manifest.sha256,
 		url: manifest.url
+	} : {
+		...platformArchive,
+		cacheSuffix: platformKey
 	};
 }
 function dashboardDirOverride(env = process.env) {
@@ -1881,11 +1932,11 @@ function dashboardManifestUrl(env = process.env) {
 function dashboardCacheRoot() {
 	return join(dirname(devEnvStatePath()), DASHBOARD_CACHE_DIR_NAME);
 }
-function dashboardVersionDir(version) {
-	return join(dashboardCacheRoot(), version);
+function dashboardVersionDir(version, cacheSuffix) {
+	return join(dashboardCacheRoot(), cacheSuffix == null ? version : `${version}--${cacheSuffix}`);
 }
-function isDashboardCached(version) {
-	const dir = dashboardVersionDir(version);
+function isDashboardCached(version, cacheSuffix, cacheRoot = dashboardCacheRoot()) {
+	const dir = join(cacheRoot, cacheSuffix == null ? version : `${version}--${cacheSuffix}`);
 	return existsSync(join(dir, DASHBOARD_COMPLETE_MARKER)) && existsSync(join(dir, DASHBOARD_SERVER_RELATIVE_PATH));
 }
 function parseVersion(version) {
@@ -1917,10 +1968,19 @@ function isVersionNewer$1(candidate, current) {
 	if (candidate.hasPrerelease !== current.hasPrerelease) return !candidate.hasPrerelease;
 	return false;
 }
-function latestCachedDashboardVersion() {
-	const root = dashboardCacheRoot();
-	if (!existsSync(root)) return void 0;
-	return pickLatestVersion(readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isDashboardCached(entry.name)).map((entry) => entry.name));
+function latestCachedDashboard(platformKey, cacheRoot = dashboardCacheRoot()) {
+	if (!existsSync(cacheRoot)) return void 0;
+	const suffix = platformKey == null ? "" : `--${platformKey}`;
+	const cached = readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && (platformKey == null ? !DASHBOARD_PLATFORM_KEYS.some((supportedKey) => entry.name.endsWith(`--${supportedKey}`)) : entry.name.endsWith(suffix))).map((entry) => {
+		const version = suffix.length === 0 ? entry.name : entry.name.slice(0, -suffix.length);
+		const root = join(cacheRoot, platformKey == null ? version : `${version}--${platformKey}`);
+		return isDashboardCached(version, platformKey, cacheRoot) ? {
+			version,
+			root
+		} : void 0;
+	}).filter((entry) => entry != null);
+	const version = pickLatestVersion(cached.map((entry) => entry.version));
+	return version == null ? void 0 : cached.find((entry) => entry.version === version);
 }
 async function fetchDashboardManifest(env = process.env) {
 	const url = dashboardManifestUrl(env);
@@ -1945,39 +2005,44 @@ async function sha256File(path) {
 	await pipeline(createReadStream(path), hash);
 	return hash.digest("hex");
 }
-async function downloadDashboardRelease(manifest, onProgress) {
+async function downloadDashboardRelease(manifest, archive, onProgress) {
 	const cacheRoot = dashboardCacheRoot();
 	mkdirSync(cacheRoot, { recursive: true });
 	const suffix = `${process.pid}-${randomBytes(8).toString("hex")}`;
-	const tmpZip = join(cacheRoot, `.download-${manifest.version}-${suffix}.zip`);
+	const tmpArchive = join(cacheRoot, `.download-${manifest.version}-${suffix}${archive.cacheSuffix == null ? ".zip" : ".tar.zst"}`);
 	const tmpDir = join(cacheRoot, `.extract-${manifest.version}-${suffix}`);
-	const targetDir = dashboardVersionDir(manifest.version);
+	const targetDir = dashboardVersionDir(manifest.version, archive.cacheSuffix);
 	try {
 		onProgress?.(`Downloading Hexclave dashboard ${manifest.version}`);
-		const response = await fetch(manifest.url, {
+		const response = await fetch(archive.url, {
 			redirect: "follow",
 			signal: AbortSignal.timeout(DASHBOARD_DOWNLOAD_TIMEOUT_MS)
 		});
 		if (!isAllowedDownloadUrl(response.url)) throw new CliError(`Dashboard ${manifest.version} download was redirected to a disallowed URL (${response.url}).`);
-		if (!response.ok || response.body == null) throw new CliError(`Failed to download dashboard ${manifest.version} (HTTP ${response.status}) from ${manifest.url}.`);
-		await pipeline(Readable.fromWeb(response.body), createWriteStream(tmpZip));
+		if (!response.ok || response.body == null) throw new CliError(`Failed to download dashboard ${manifest.version} (HTTP ${response.status}) from ${archive.url}.`);
+		await pipeline(Readable.fromWeb(response.body), createWriteStream(tmpArchive));
 		onProgress?.(`Verifying Hexclave dashboard ${manifest.version}`);
-		const digest = await sha256File(tmpZip);
-		if (digest !== manifest.sha256) throw new CliError(`Dashboard ${manifest.version} failed its integrity check (expected ${manifest.sha256}, got ${digest}).`);
+		const digest = await sha256File(tmpArchive);
+		if (digest !== archive.sha256) throw new CliError(`Dashboard ${manifest.version} failed its integrity check (expected ${archive.sha256}, got ${digest}).`);
 		rmSync(tmpDir, {
 			recursive: true,
 			force: true
 		});
 		mkdirSync(tmpDir, { recursive: true });
 		onProgress?.(`Extracting Hexclave dashboard ${manifest.version}`);
-		await extractZip(tmpZip, { dir: tmpDir });
+		if (archive.cacheSuffix == null) await extractZip(tmpArchive, { dir: tmpDir });
+		else await pipeline(createReadStream(tmpArchive), zlib.createZstdDecompress(), tar.x({
+			cwd: tmpDir,
+			strict: true,
+			preservePaths: false
+		}));
 		if (!existsSync(join(tmpDir, DASHBOARD_SERVER_RELATIVE_PATH))) throw new CliError(`Dashboard ${manifest.version} archive is missing its server entrypoint.`);
-		writeFileSync(join(tmpDir, DASHBOARD_COMPLETE_MARKER), `${manifest.sha256}\n`);
-		if (isDashboardCached(manifest.version)) return;
+		writeFileSync(join(tmpDir, DASHBOARD_COMPLETE_MARKER), `${archive.sha256}\n`);
+		if (isDashboardCached(manifest.version, archive.cacheSuffix)) return;
 		try {
 			renameSync(tmpDir, targetDir);
 		} catch {
-			if (isDashboardCached(manifest.version)) return;
+			if (isDashboardCached(manifest.version, archive.cacheSuffix)) return;
 			rmSync(targetDir, {
 				recursive: true,
 				force: true
@@ -1985,7 +2050,7 @@ async function downloadDashboardRelease(manifest, onProgress) {
 			renameSync(tmpDir, targetDir);
 		}
 	} finally {
-		rmSync(tmpZip, { force: true });
+		rmSync(tmpArchive, { force: true });
 		rmSync(tmpDir, {
 			recursive: true,
 			force: true
@@ -2003,35 +2068,30 @@ async function resolveDashboardRuntime(opts = {}) {
 	}
 	const manifest = opts.manifest !== void 0 ? opts.manifest : await fetchDashboardManifest();
 	if (manifest != null) {
-		if (isDashboardCached(manifest.version)) return {
-			root: dashboardVersionDir(manifest.version),
+		const archive = selectDashboardArchive(manifest);
+		if (isDashboardCached(manifest.version, archive.cacheSuffix)) return {
+			root: dashboardVersionDir(manifest.version, archive.cacheSuffix),
 			version: manifest.version
 		};
 		try {
-			await downloadDashboardRelease(manifest, opts.onProgress);
+			await downloadDashboardRelease(manifest, archive, opts.onProgress);
 			return {
-				root: dashboardVersionDir(manifest.version),
+				root: dashboardVersionDir(manifest.version, archive.cacheSuffix),
 				version: manifest.version
 			};
 		} catch (error) {
-			const cached = latestCachedDashboardVersion();
+			const cached = latestCachedDashboard(dashboardPlatformKey()) ?? latestCachedDashboard();
 			if (cached != null) {
-				logDashboard(`Failed to download dashboard ${manifest.version} (${errorMessage$1(error)}); using cached ${cached}.`);
-				return {
-					root: dashboardVersionDir(cached),
-					version: cached
-				};
+				logDashboard(`Failed to download dashboard ${manifest.version} (${errorMessage$1(error)}); using cached ${cached.version}.`);
+				return cached;
 			}
 			throw error;
 		}
 	}
-	const cached = latestCachedDashboardVersion();
+	const cached = latestCachedDashboard(dashboardPlatformKey()) ?? latestCachedDashboard();
 	if (cached != null) {
-		logDashboard(`Offline: using cached Hexclave dashboard ${cached}.`);
-		return {
-			root: dashboardVersionDir(cached),
-			version: cached
-		};
+		logDashboard(`Offline: using cached Hexclave dashboard ${cached.version}.`);
+		return cached;
 	}
 	throw new CliError(["Could not download the Hexclave development-environment dashboard and no cached copy is available.", `Check your network connection, or set ${DASHBOARD_DIR_OVERRIDE_ENV_VAR} to a local dashboard build.`].join(" "));
 }