@foundry-rs/chisel 1.4.4-nightly.20251028.9273fd8 → 1.4.4-nightly.20251028.c2a3538

package/bin.mjs

@@ -0,0 +1,117 @@
+import { BINARY_NAME, colors, KNOWN_TOOLS, PLATFORM_SPECIFIC_PACKAGE_NAME, resolveTargetTool } from './postinstall.mjs'
+import * as NodeChildProcess from 'node:child_process'
+import * as NodeFS from 'node:fs'
+import * as NodeModule from 'node:module'
+import * as NodePath from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * @typedef {import('./postinstall.mjs').Tool} Tool
+ */
+
+const require = NodeModule.createRequire(import.meta.url)
+const __dirname = NodePath.dirname(fileURLToPath(import.meta.url))
+
+const targetTool = resolveTool()
+process.env.TARGET_TOOL ??= targetTool
+
+const binaryName = BINARY_NAME(targetTool)
+const platformPackage = PLATFORM_SPECIFIC_PACKAGE_NAME(targetTool)
+
+if (!platformPackage) {
+  console.error(colors.red, 'Platform not supported!')
+  console.error(colors.reset)
+  console.error(colors.yellow, `Platform: ${process.platform}, Architecture: ${process.arch}`)
+  console.error(colors.reset)
+  process.exit(1)
+}
+
+NodeChildProcess.spawn(selectBinaryPath(), process.argv.slice(2), { stdio: 'inherit' })
+
+/**
+ * Determines which tool wrapper is executing.
+ * @returns {Tool}
+ */
+function resolveTool() {
+  const candidates = [
+    process.env.TARGET_TOOL,
+    toolFromPackageName(process.env.npm_package_name),
+    toolFromLocalPackage(),
+    toolFromPath()
+  ]
+
+  for (const candidate of candidates) {
+    if (!candidate) continue
+    try {
+      return resolveTargetTool(candidate)
+    } catch {
+      // try next
+    }
+  }
+
+  throw new Error('TARGET_TOOL must be set to one of: ' + KNOWN_TOOLS.join(', '))
+}
+
+/**
+ * Attempts to read the tool name from the nearest package.json.
+ * @returns {Tool | undefined}
+ */
+function toolFromLocalPackage() {
+  try {
+    const packageJsonPath = NodePath.join(__dirname, 'package.json')
+    if (!NodeFS.existsSync(packageJsonPath)) return undefined
+    const pkg = require(packageJsonPath)
+    return toolFromPackageName(pkg?.name)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Extracts the tool name from an @foundry-rs scoped package identifier.
+ * @param {unknown} name
+ * @returns {Tool | undefined}
+ */
+function toolFromPackageName(name) {
+  if (typeof name !== 'string') return undefined
+  const match = name.match(/^@foundry-rs\/(forge|cast|anvil|chisel)(?:$|-)/)
+  return match ? /** @type {Tool} */ (match[1]) : undefined
+}
+
+/**
+ * Walks up the directory tree to infer the tool name from the folder structure.
+ * @returns {Tool | undefined}
+ */
+function toolFromPath() {
+  const segments = NodePath.resolve(__dirname).split(NodePath.sep)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const candidate = segments[i]
+    if (isTool(candidate)) return candidate
+  }
+  return undefined
+}
+
+/**
+ * Type guard verifying a candidate string is a known tool.
+ * @param {string | undefined} candidate
+ * @returns {candidate is Tool}
+ */
+function isTool(candidate) {
+  if (typeof candidate !== 'string') return false
+  return KNOWN_TOOLS.includes(/** @type {Tool} */ (candidate))
+}
+
+/**
+ * Determines the executable file path for the current platform.
+ * @returns {string}
+ */
+function selectBinaryPath() {
+  try {
+    const candidate = require.resolve(`${platformPackage}/bin/${binaryName}`)
+    if (NodeFS.existsSync(candidate)) return candidate
+  } catch {
+    // fall through to dist/ binary
+  }
+
+  return NodePath.join(__dirname, '..', 'dist', binaryName)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundry-rs/chisel",
-  "version": "1.4.4-nightly.20251028.9273fd8",
+  "version": "1.4.4-nightly.20251028.c2a3538",
   "type": "module",
   "homepage": "https://getfoundry.sh/chisel",
   "description": "Chisel is a fast, utilitarian, and verbose Solidity REPL",
@@ -8,18 +8,18 @@
     "chisel": "./bin.mjs"
   },
   "files": [
-    "bin",
-    "dist"
+    "bin.mjs",
+    "postinstall.mjs"
   ],
   "scripts": {
-    "postinstall": "node ./dist/install.mjs"
+    "postinstall": "node ./postinstall.mjs"
   },
   "optionalDependencies": {
-    "@foundry-rs/chisel-darwin-arm64": "1.4.4-nightly.20251028.9273fd8",
-    "@foundry-rs/chisel-darwin-amd64": "1.4.4-nightly.20251028.9273fd8",
-    "@foundry-rs/chisel-linux-arm64": "1.4.4-nightly.20251028.9273fd8",
-    "@foundry-rs/chisel-linux-amd64": "1.4.4-nightly.20251028.9273fd8",
-    "@foundry-rs/chisel-win32-amd64": "1.4.4-nightly.20251028.9273fd8"
+    "@foundry-rs/chisel-darwin-arm64": "1.4.4-nightly.20251028.c2a3538",
+    "@foundry-rs/chisel-darwin-amd64": "1.4.4-nightly.20251028.c2a3538",
+    "@foundry-rs/chisel-linux-arm64": "1.4.4-nightly.20251028.c2a3538",
+    "@foundry-rs/chisel-linux-amd64": "1.4.4-nightly.20251028.c2a3538",
+    "@foundry-rs/chisel-win32-amd64": "1.4.4-nightly.20251028.c2a3538"
   },
   "publishConfig": {
     "access": "public",
@@ -30,5 +30,8 @@
   "repository": {
     "directory": "npm",
     "url": "https://github.com/foundry-rs/foundry"
+  },
+  "imports": {
+    "#const.mjs": "./postinstall.mjs"
   }
 }

package/postinstall.mjs

@@ -0,0 +1,265 @@
+// src/install.mjs
+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 NodeModule from "node:module";
+import * as NodePath2 from "node:path";
+import { fileURLToPath } from "node:url";
+import * as NodeZlib from "node:zlib";
+
+// src/const.mjs
+import * as NodePath from "node:path";
+var KNOWN_TOOLS = Object.freeze(["forge", "cast", "anvil", "chisel"]);
+var TOOL_SET = new Set(KNOWN_TOOLS);
+function resolveTargetTool(raw = process.env.TARGET_TOOL) {
+  const value = typeof raw === "string" ? raw.trim() : "";
+  if (!value)
+    throw new Error("TARGET_TOOL must be set to one of: " + KNOWN_TOOLS.join(", "));
+  if (value !== NodePath.basename(value) || value.includes("..") || value.includes("/") || value.includes("\\"))
+    throw new Error("TARGET_TOOL contains invalid path segments");
+  if (!TOOL_SET.has(value))
+    throw new Error(`TARGET_TOOL "${value}" is not supported. Expected: ${KNOWN_TOOLS.join(", ")}`);
+  return value;
+}
+function getRegistryUrl() {
+  return process.env.npm_config_registry || process.env.REGISTRY_URL || "https://registry.npmjs.org";
+}
+var BINARY_DISTRIBUTION_PACKAGES = (tool) => ({
+  darwin: {
+    x64: `@foundry-rs/${tool}-darwin-amd64`,
+    arm64: `@foundry-rs/${tool}-darwin-arm64`
+  },
+  linux: {
+    x64: `@foundry-rs/${tool}-linux-amd64`,
+    arm64: `@foundry-rs/${tool}-linux-arm64`
+  },
+  win32: {
+    x64: `@foundry-rs/${tool}-win32-amd64`
+  }
+});
+var BINARY_NAME = (tool) => process.platform === "win32" ? `${tool}.exe` : tool;
+var PLATFORM_SPECIFIC_PACKAGE_NAME = (tool) => {
+  const platformPackages = BINARY_DISTRIBUTION_PACKAGES(tool)[process.platform];
+  if (!platformPackages)
+    return;
+  return platformPackages?.[process.arch];
+};
+var 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"
+};
+
+// src/install.mjs
+var __dirname2 = NodePath2.dirname(fileURLToPath(import.meta.url));
+var targetTool = resolveTargetTool();
+var binaryName = BINARY_NAME(targetTool);
+var fallbackBinaryPath = NodePath2.join(__dirname2, binaryName);
+var platformSpecificPackageName = PLATFORM_SPECIFIC_PACKAGE_NAME(targetTool);
+var expectedTarEntryPath = `package/bin/${binaryName}`;
+if (NodePath2.relative(__dirname2, fallbackBinaryPath).startsWith(".."))
+  throw new Error("Resolved binary path escapes package directory");
+if (!platformSpecificPackageName)
+  throw new Error("Platform not supported!");
+var require2 = NodeModule.createRequire(import.meta.url);
+function ensureSecureUrl(urlString, purpose) {
+  try {
+    const url = new URL(urlString);
+    if (url.protocol === "http:") {
+      const allowInsecure = process.env.ALLOW_INSECURE_REGISTRY === "true";
+      if (!["localhost", "127.0.0.1", "::1"].includes(url.hostname) && !allowInsecure) {
+        throw new Error(`Refusing to use insecure HTTP for ${purpose}: ${urlString}. ` + `Set ALLOW_INSECURE_REGISTRY=true to override (not recommended).`);
+      }
+    }
+  } catch {}
+}
+var MAX_REDIRECTS = 10;
+var REQUEST_TIMEOUT = 30000;
+var MAX_METADATA_BYTES = 5 * 1024 * 1024;
+var MAX_TARBALL_BYTES = 200 * 1024 * 1024;
+var MAX_BINARY_BYTES = 500 * 1024 * 1024;
+function makeRequest(url, options = {}) {
+  const {
+    parentSignal,
+    redirectDepth = 0,
+    visited = new Set,
+    maxBytes,
+    collect = true,
+    onChunk
+  } = options;
+  if (redirectDepth > MAX_REDIRECTS)
+    throw new Error("Maximum redirect depth exceeded");
+  if (visited.has(url))
+    throw new Error("Circular redirect detected");
+  visited.add(url);
+  ensureSecureUrl(url, "HTTP request");
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+  const signal = parentSignal ? AbortSignal.any([parentSignal, controller.signal]) : controller.signal;
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https:") ? NodeHttps : NodeHttp;
+    const request = client.get(url, { signal }, (response) => {
+      const finish = (error, value = undefined) => {
+        clearTimeout(timer);
+        if (error)
+          reject(error);
+        else
+          resolve(value);
+      };
+      if (response?.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+        let totalBytes = 0;
+        const chunks = collect ? [] : undefined;
+        response.on("data", (chunk) => {
+          totalBytes += chunk.length;
+          if (maxBytes && totalBytes > maxBytes) {
+            response.destroy(new Error("Response exceeded maximum allowed size"));
+            return;
+          }
+          if (chunks)
+            chunks.push(chunk);
+          if (onChunk) {
+            try {
+              onChunk(chunk, response);
+            } catch (error) {
+              response.destroy(error instanceof Error ? error : new Error(`Error occurred: ${error}`));
+            }
+          }
+        });
+        response.on("end", () => {
+          finish(null, chunks ? Buffer.concat(chunks) : undefined);
+        });
+        response.on("error", finish);
+      } else if (response?.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        clearTimeout(timer);
+        const nextUrl = new URL(response.headers.location, url).href;
+        return makeRequest(nextUrl, {
+          parentSignal: signal,
+          redirectDepth: redirectDepth + 1,
+          visited,
+          maxBytes,
+          collect,
+          onChunk
+        }).then(resolve, reject);
+      } else {
+        finish(new Error(`Package registry responded with status code ${response?.statusCode ?? "(none)"} when downloading the package.`));
+      }
+    });
+    request.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+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) {
+      if (!Number.isFinite(fileSize) || Number.isNaN(fileSize) || fileSize < 0)
+        throw new Error(`Invalid size for ${filepath} in tarball`);
+      if (fileSize > MAX_BINARY_BYTES)
+        throw new Error(`Binary size for ${filepath} exceeds maximum allowed threshold`);
+      return tarballBuffer.subarray(offset, offset + fileSize);
+    }
+    offset = offset + fileSize + 511 & ~511;
+  }
+  throw new Error(`File ${filepath} not found in tarball`);
+}
+async function downloadBinaryFromRegistry() {
+  if (!platformSpecificPackageName)
+    throw new Error("Platform-specific package name is not defined");
+  const registryUrl = getRegistryUrl().replace(/\/$/, "");
+  ensureSecureUrl(registryUrl, "registry URL");
+  const encodedName = platformSpecificPackageName.startsWith("@") ? encodeURIComponent(platformSpecificPackageName) : platformSpecificPackageName;
+  let desiredVersion;
+  try {
+    const pkgJsonPath = NodePath2.join(__dirname2, "..", "package.json");
+    const pkgJson = JSON.parse(NodeFS.readFileSync(pkgJsonPath, "utf8"));
+    desiredVersion = pkgJson?.optionalDependencies[platformSpecificPackageName] || pkgJson?.version;
+  } catch {}
+  const metaUrl = `${registryUrl}/${encodedName}`;
+  const metaBuffer = await makeRequest(metaUrl, { maxBytes: MAX_METADATA_BYTES });
+  if (!metaBuffer)
+    throw new Error("Failed to download package metadata");
+  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 ${platformSpecificPackageName}@${version} from ${metaUrl}`);
+  }
+  ensureSecureUrl(dist.tarball, "tarball URL");
+  console.info(colors.green, `Downloading binary from:
+`, dist.tarball, `
+`, colors.reset);
+  const integrity = typeof dist.integrity === "string" ? dist.integrity : "";
+  const sriMatch = integrity.match(/^([a-z0-9]+)-([A-Za-z0-9+/=]+)$/i);
+  const allowedSRIAlgorithms = new Set(["sha512", "sha256", "sha1"]);
+  const sriAlgo = sriMatch && allowedSRIAlgorithms.has(sriMatch[1].toLowerCase()) ? sriMatch[1].toLowerCase() : undefined;
+  const expectedSri = sriAlgo ? sriMatch?.[2] : undefined;
+  const sriHasher = sriAlgo ? NodeCrypto.createHash(sriAlgo) : undefined;
+  const expectedSha1Hex = typeof dist.shasum === "string" && dist.shasum.length === 40 ? dist.shasum.toLowerCase() : undefined;
+  const sha1Hasher = expectedSha1Hex ? NodeCrypto.createHash("sha1") : undefined;
+  const tarballDownloadBuffer = await makeRequest(dist.tarball, {
+    maxBytes: MAX_TARBALL_BYTES,
+    onChunk: (chunk) => {
+      sriHasher?.update(chunk);
+      sha1Hasher?.update(chunk);
+    }
+  });
+  if (!tarballDownloadBuffer)
+    throw new Error("Failed to download tarball contents");
+  let verified = false;
+  if (sriHasher && expectedSri) {
+    const actual = sriHasher.digest("base64");
+    if (expectedSri !== actual) {
+      throw new Error(`Downloaded tarball failed integrity check (${sriAlgo} mismatch)`);
+    }
+    verified = true;
+  }
+  if (!verified && sha1Hasher && expectedSha1Hex) {
+    const actualSha1Hex = sha1Hasher.digest("hex");
+    if (expectedSha1Hex !== actualSha1Hex) {
+      throw new Error("Downloaded tarball failed integrity check (sha1 shasum mismatch)");
+    }
+    verified = true;
+  }
+  if (!verified) {
+    const allowNoIntegrity = process.env.ALLOW_NO_INTEGRITY === "true" || process.env.ALLOW_UNVERIFIED_TARBALL === "true";
+    if (!allowNoIntegrity) {
+      throw new Error("No integrity metadata found for downloaded tarball. " + "Set ALLOW_NO_INTEGRITY=true to bypass (not recommended).");
+    }
+    console.warn(colors.yellow, "Warning: proceeding without integrity verification (explicitly allowed).", colors.reset);
+  }
+  const tarballBuffer = NodeZlib.gunzipSync(tarballDownloadBuffer);
+  NodeFS.writeFileSync(fallbackBinaryPath, extractFileFromTarball(tarballBuffer, expectedTarEntryPath), { mode: 493 });
+}
+function isPlatformSpecificPackageInstalled() {
+  try {
+    require2.resolve(`${platformSpecificPackageName}/bin/${binaryName}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+if (!isPlatformSpecificPackageInstalled()) {
+  console.log("Platform specific package not found. Will manually download binary.");
+  downloadBinaryFromRegistry().catch((error) => {
+    console.error(colors.red, "Failed to download binary:", error, colors.reset);
+    process.exitCode = 1;
+  });
+} else {
+  console.log("Platform specific package already installed. Skipping manual download.");
+}
+export {
+  makeRequest
+};