@foundry-rs/forge 1.3.2 → 1.3.4-nightly.20250906.05d4a02

package/bin/forge.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import * as NodeModule from "node:module";
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/const.ts
+const BINARY_DISTRIBUTION_PACKAGES = {
+	darwin: {
+		x64: "@foundry-rs/forge-darwin-amd64",
+		arm64: "@foundry-rs/forge-darwin-arm64"
+	},
+	linux: {
+		x64: "@foundry-rs/forge-linux-amd64",
+		arm64: "@foundry-rs/forge-linux-arm64"
+	},
+	win32: { x64: "@foundry-rs/forge-win32-amd64" }
+};
+const BINARY_NAME = process.platform === "win32" ? "forge.exe" : "forge";
+const PLATFORM_SPECIFIC_PACKAGE_NAME = BINARY_DISTRIBUTION_PACKAGES[process.platform][process.arch];
+
+//#endregion
+//#region src/forge.ts
+const require = NodeModule.createRequire(import.meta.url);
+const __dirname = NodePath.dirname(fileURLToPath(import.meta.url));
+function getBinaryPath() {
+	const { platform, arch } = process;
+	let packageName;
+	let binaryName = "forge";
+	switch (platform) {
+		case "win32":
+			binaryName += ".exe";
+			if (arch === "x64") packageName = "@foundry-rs/forge-win32-amd64";
+			break;
+		case "darwin":
+			if (arch === "x64") packageName = "@foundry-rs/forge-darwin-amd64";
+			else if (arch === "arm64") packageName = "@foundry-rs/forge-darwin-arm64";
+			break;
+		case "linux":
+			if (arch === "x64") packageName = "@foundry-rs/forge-linux-amd64";
+			else if (arch === "arm64") packageName = "@foundry-rs/forge-linux-arm64";
+			break;
+		default: throw new Error(`Unsupported platform: ${platform}-${arch}`);
+	}
+	if (!packageName) {
+		console.error(`Unsupported platform: ${platform}-${arch}`);
+		process.exit(1);
+	}
+	try {
+		const binaryPath = require.resolve(`${packageName}/bin/${binaryName}`);
+		if (NodeFS.existsSync(binaryPath)) return binaryPath;
+	} catch (error) {
+		return NodePath.join(__dirname, "..", "dist", BINARY_NAME);
+	}
+	console.error(`Platform-specific package ${packageName} not found.`);
+	console.error("This usually means the installation failed or your platform is not supported.");
+	console.error(`Platform: ${platform}, Architecture: ${arch}`);
+	process.exit(1);
+}
+NodeChildProcess.spawn(getBinaryPath(), process.argv.slice(2), { stdio: "inherit" });
+
+//#endregion
+export {  };

package/dist/index.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import NodeModule from "node:module";
+import NodeChildProcess from "node:child_process";
+import NodePath from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/const.ts
+const BINARY_DISTRIBUTION_PACKAGES = {
+	darwin: {
+		x64: "@foundry-rs/forge-darwin-amd64",
+		arm64: "@foundry-rs/forge-darwin-arm64"
+	},
+	linux: {
+		x64: "@foundry-rs/forge-linux-amd64",
+		arm64: "@foundry-rs/forge-linux-arm64"
+	},
+	win32: { x64: "@foundry-rs/forge-win32-amd64" }
+};
+const BINARY_NAME = process.platform === "win32" ? "forge.exe" : "forge";
+const PLATFORM_SPECIFIC_PACKAGE_NAME = BINARY_DISTRIBUTION_PACKAGES[process.platform][process.arch];
+
+//#endregion
+//#region src/index.ts
+const require = NodeModule.createRequire(import.meta.url);
+const __dirname = NodePath.dirname(fileURLToPath(import.meta.url));
+function getBinaryPath() {
+	try {
+		return require.resolve(`${PLATFORM_SPECIFIC_PACKAGE_NAME}/bin/${BINARY_NAME}`);
+	} catch (_error) {
+		return NodePath.join(__dirname, BINARY_NAME);
+	}
+}
+if (import.meta.url === `file://${process.argv[1]}`) NodeChildProcess.execFileSync(getBinaryPath(), process.argv.slice(2), { stdio: "inherit" });
+
+//#endregion
+export {  };

package/dist/install.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import * as NodeModule from "node:module";
+import * as NodeCrypto from "node:crypto";
+import * as NodeFS from "node:fs";
+import * as NodeHttp from "node:http";
+import * as NodeHttps from "node:https";
+import * as NodePath from "node:path";
+import { fileURLToPath } from "node:url";
+import * as NodeZlib from "node:zlib";
+
+//#region src/const.ts
+function getRegistryUrl() {
+	return process.env.npm_config_registry || process.env.REGISTRY_URL || "https://registry.npmjs.org";
+}
+const BINARY_DISTRIBUTION_PACKAGES = {
+	darwin: {
+		x64: "@foundry-rs/forge-darwin-amd64",
+		arm64: "@foundry-rs/forge-darwin-arm64"
+	},
+	linux: {
+		x64: "@foundry-rs/forge-linux-amd64",
+		arm64: "@foundry-rs/forge-linux-arm64"
+	},
+	win32: { x64: "@foundry-rs/forge-win32-amd64" }
+};
+const BINARY_NAME = process.platform === "win32" ? "forge.exe" : "forge";
+const PLATFORM_SPECIFIC_PACKAGE_NAME = BINARY_DISTRIBUTION_PACKAGES[process.platform][process.arch];
+const colors = {
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	white: "\x1B[37m",
+	reset: "\x1B[0m"
+};
+
+//#endregion
+//#region src/install.ts
+const __dirname = NodePath.dirname(fileURLToPath(import.meta.url));
+const fallbackBinaryPath = NodePath.join(__dirname, BINARY_NAME);
+const require = NodeModule.createRequire(import.meta.url);
+function makeRequest(url) {
+	return new Promise((resolve, reject) => {
+		const client = url.startsWith("https:") ? NodeHttps : NodeHttp;
+		client.get(url, (response) => {
+			if (response?.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+				const chunks = [];
+				response.on("data", (chunk) => chunks.push(chunk));
+				response.on("end", () => {
+					resolve(Buffer.concat(chunks));
+				});
+			} else if (response?.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) makeRequest(response.headers.location).then(resolve, reject);
+			else reject(/* @__PURE__ */ new Error(`npm responded with status code ${response.statusCode} when downloading the package!`));
+		}).on("error", (error) => {
+			reject(error);
+		});
+	});
+}
+function encodePackageNameForRegistry(name) {
+	return name.startsWith("@") ? encodeURIComponent(name) : name;
+}
+function extractFileFromTarball(tarballBuffer, filepath) {
+	let offset = 0;
+	while (offset < tarballBuffer.length) {
+		const header = tarballBuffer.subarray(offset, offset + 512);
+		offset += 512;
+		const fileName = header.toString("utf-8", 0, 100).replace(/\0.*/g, "");
+		const fileSize = Number.parseInt(header.toString("utf-8", 124, 136).replace(/\0.*/g, ""), 8);
+		if (fileName === filepath) return tarballBuffer.subarray(offset, offset + fileSize);
+		offset = offset + fileSize + 511 & -512;
+	}
+	throw new Error(`File ${filepath} not found in tarball`);
+}
+async function downloadBinaryFromNpm() {
+	const registryUrl = getRegistryUrl().replace(/\/$/, "");
+	const encodedName = encodePackageNameForRegistry(PLATFORM_SPECIFIC_PACKAGE_NAME);
+	let desiredVersion;
+	try {
+		const pkgJsonPath = NodePath.join(__dirname, "..", "package.json");
+		const pkgJson = JSON.parse(NodeFS.readFileSync(pkgJsonPath, "utf8"));
+		desiredVersion = pkgJson?.optionalDependencies?.[PLATFORM_SPECIFIC_PACKAGE_NAME] || pkgJson?.version;
+	} catch {}
+	const metaUrl = `${registryUrl}/${encodedName}`;
+	const metaBuffer = await makeRequest(metaUrl);
+	const metadata = JSON.parse(metaBuffer.toString("utf8"));
+	const version = desiredVersion || metadata?.["dist-tags"]?.latest;
+	const versionMeta = metadata?.versions?.[version];
+	const dist = versionMeta?.dist;
+	if (!dist?.tarball) throw new Error(`Could not find tarball for ${PLATFORM_SPECIFIC_PACKAGE_NAME}@${version} from ${metaUrl}`);
+	console.info(colors.green, "Downloading binary from:\n", dist.tarball, "\n", colors.reset);
+	const tarballDownloadBuffer = await makeRequest(dist.tarball);
+	if (dist.integrity && dist.integrity.startsWith("sha512-")) {
+		const expected = dist.integrity.split("sha512-")[1];
+		const actual = NodeCrypto.createHash("sha512").update(tarballDownloadBuffer).digest("base64");
+		if (expected !== actual) throw new Error("Downloaded tarball failed integrity check (sha512 mismatch)");
+	}
+	const tarballBuffer = NodeZlib.gunzipSync(tarballDownloadBuffer);
+	NodeFS.writeFileSync(fallbackBinaryPath, extractFileFromTarball(tarballBuffer, `package/bin/${BINARY_NAME}`), { mode: 493 });
+}
+function isPlatformSpecificPackageInstalled() {
+	try {
+		require.resolve(`${PLATFORM_SPECIFIC_PACKAGE_NAME}/bin/${BINARY_NAME}`);
+		return true;
+	} catch (_error) {
+		return false;
+	}
+}
+if (!PLATFORM_SPECIFIC_PACKAGE_NAME) throw new Error("Platform not supported!");
+if (!isPlatformSpecificPackageInstalled()) {
+	console.log("Platform specific package not found. Will manually download binary.");
+	downloadBinaryFromNpm();
+} else console.log("Platform specific package already installed. Skipping manual download.");
+
+//#endregion
+export {  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundry-rs/forge",
-  "version": "1.3.2",
+  "version": "1.3.4-nightly.20250906.05d4a02",
   "type": "module",
   "homepage": "https://getfoundry.sh/forge",
   "description": "Fast and flexible Ethereum testing framework",
@@ -19,11 +19,11 @@
     "postinstall": "node ./dist/install.mjs"
   },
   "optionalDependencies": {
-    "@foundry-rs/forge-darwin-arm64": "1.3.2",
-    "@foundry-rs/forge-darwin-amd64": "1.3.2",
-    "@foundry-rs/forge-linux-arm64": "1.3.2",
-    "@foundry-rs/forge-linux-amd64": "1.3.2",
-    "@foundry-rs/forge-win32-amd64": "1.3.2"
+    "@foundry-rs/forge-darwin-arm64": "1.3.4-nightly.20250906.05d4a02",
+    "@foundry-rs/forge-darwin-amd64": "1.3.4-nightly.20250906.05d4a02",
+    "@foundry-rs/forge-linux-arm64": "1.3.4-nightly.20250906.05d4a02",
+    "@foundry-rs/forge-linux-amd64": "1.3.4-nightly.20250906.05d4a02",
+    "@foundry-rs/forge-win32-amd64": "1.3.4-nightly.20250906.05d4a02"
   },
   "publishConfig": {
     "access": "public",