@etherscan-npm/cli 1.0.3 → 1.0.4

package/README.md

@@ -52,7 +52,7 @@ Or run it once without keeping a global installation:
 npx @etherscan-npm/cli version
 ```
 
-The npm package downloads the matching native release archive and verifies its SHA-256 checksum during installation. Lifecycle scripts must be enabled.
+The npm package selects a platform-specific optional dependency containing the native binary. It does not run installation lifecycle scripts. Installing with `--omit=optional` is not supported.
 
 > The package is currently published as `@etherscan-npm/cli` while the `@etherscan` npm scope is being transferred. The `etherscan` command is unchanged.
 
@@ -488,9 +488,20 @@ go build -o etherscan ./cmd/etherscan
 
 Installer changes can be checked with `sh scripts/test-install.sh` on macOS/Linux or `./scripts/test-install.ps1` in PowerShell on Windows.
 
-The npm distribution can be checked with `sh scripts/test-npm.sh` on macOS/Linux or `./scripts/test-npm.ps1` in PowerShell. These tests pack and install the package against local fixture release archives; they do not publish to npm.
+The npm distribution can be checked with `sh scripts/test-npm.sh` on macOS/Linux or `./scripts/test-npm.ps1` in PowerShell. These tests pack and install the umbrella and current-platform packages with lifecycle scripts disabled; they do not publish to npm.
 
-For the first npm release, publish the GitHub release assets before publishing the package. From an exact release-tag checkout, run `npm version --no-git-tag-version <version>` followed by `npm publish --access public`. Then configure npm trusted publishing for `etherscan/etherscan-cli` and `.github/workflows/release.yml`, and set the `NPM_PUBLISH_ENABLED` repository variable to `true` for later tagged releases.
+The first seven-package npm release requires a one-time bootstrap by an npm administrator with publish access to the `@etherscan-npm` scope. After the matching GitHub release succeeds, check out its exact tag and run:
+
+```sh
+gh release download v1.0.4 --dir dist
+npm login
+npm whoami
+VERSION=1.0.4 node npm/publish.js
+```
+
+The publisher verifies all six archives against `checksums.txt`, creates the six public platform packages by publishing them first, and publishes `@etherscan-npm/cli` last. It safely skips exact versions that already exist so a partial publication can be retried. Replace `1.0.4` with the actual unused release version if necessary.
+
+After the bootstrap, configure npm trusted publishing for the umbrella and all six platform packages, targeting `etherscan/etherscan-cli` and `.github/workflows/release.yml`. Set the `NPM_PUBLISH_ENABLED` repository variable to `true`; subsequent tagged releases publish through GitHub Actions with provenance.
 
 ## API coverage and support
 

package/npm/bin/etherscan.js

@@ -3,22 +3,45 @@
 "use strict";
 
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
 const packageInfo = require("../../package.json");
+const { PLATFORMS, platformPackage } = require("../platform");
 
 const packageRoot = path.resolve(__dirname, "..", "..");
-const executable = path.join(
-  packageRoot,
-  "vendor",
-  process.platform === "win32" ? "etherscan.exe" : "etherscan",
-);
+
+// Resolve these once so the package lookup and executable name cannot disagree.
+const platform = os.platform();
+const arch = os.arch();
+const binaryName = platform === "win32" ? "etherscan.exe" : "etherscan";
+const reinstallHint = `Reinstall ${packageInfo.name} without --omit=optional.`;
+
+function getExecutable() {
+  const packageName = platformPackage(platform, arch);
+  if (!packageName) {
+    console.error(
+      `Etherscan CLI does not support ${platform} ${arch}. ` +
+        `Supported platforms: ${Object.keys(PLATFORMS).join(", ")}.`,
+    );
+    process.exit(1);
+  }
+
+  try {
+    const manifest = require.resolve(`${packageName}/package.json`, {
+      paths: [packageRoot],
+    });
+    return path.join(path.dirname(manifest), binaryName);
+  } catch {
+    console.error(`The platform package ${packageName} is not installed. ${reinstallHint}`);
+    process.exit(1);
+  }
+}
+
+const executable = getExecutable();
 
 if (!fs.existsSync(executable)) {
-  console.error(
-    "Etherscan CLI is not installed in this npm package. " +
-      "Reinstall @etherscan-npm/cli without --ignore-scripts.",
-  );
+  console.error(`The platform package executable is missing: ${executable}. ${reinstallHint}`);
   process.exit(1);
 }
 

package/npm/platform.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const PLATFORMS = Object.freeze({
+  "darwin arm64": "@etherscan-npm/cli-darwin-arm64",
+  "darwin x64": "@etherscan-npm/cli-darwin-x64",
+  "linux arm64": "@etherscan-npm/cli-linux-arm64",
+  "linux x64": "@etherscan-npm/cli-linux-x64",
+  "win32 arm64": "@etherscan-npm/cli-win32-arm64",
+  "win32 x64": "@etherscan-npm/cli-win32-x64",
+});
+
+function platformPackage(platform, arch) {
+  return PLATFORMS[`${platform} ${arch}`] || null;
+}
+
+module.exports = { PLATFORMS, platformPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherscan-npm/cli",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Command-line client and interactive explorer for the Etherscan V2 API",
   "license": "MIT",
   "homepage": "https://github.com/etherscan/etherscan-cli",
@@ -16,7 +16,6 @@
     "etherscan": "npm/bin/etherscan.js"
   },
   "scripts": {
-    "postinstall": "node npm/postinstall.js",
     "prepublishOnly": "node npm/prepublish-check.js",
     "test:package": "npm pack --dry-run",
     "test:release": "node npm/publish.test.js",
@@ -24,13 +23,18 @@
   },
   "files": [
     "npm/bin/etherscan.js",
-    "npm/postinstall.js",
-    "npm/prepublish-check.js",
-    "scripts/install.sh",
-    "scripts/install.ps1",
+    "npm/platform.js",
     "README.md",
     "LICENSE"
   ],
+  "optionalDependencies": {
+    "@etherscan-npm/cli-darwin-arm64": "1.0.4",
+    "@etherscan-npm/cli-darwin-x64": "1.0.4",
+    "@etherscan-npm/cli-linux-arm64": "1.0.4",
+    "@etherscan-npm/cli-linux-x64": "1.0.4",
+    "@etherscan-npm/cli-win32-arm64": "1.0.4",
+    "@etherscan-npm/cli-win32-x64": "1.0.4"
+  },
   "engines": {
     "node": ">=18"
   },

package/npm/postinstall.js

@@ -1,58 +0,0 @@
-"use strict";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const { spawnSync } = require("node:child_process");
-const packageInfo = require("../package.json");
-
-const packageRoot = path.resolve(__dirname, "..");
-const installDir = path.join(packageRoot, "vendor");
-const version = `v${packageInfo.version}`;
-
-let command;
-let args;
-if (process.platform === "win32") {
-  command = "powershell.exe";
-  args = [
-    "-NoLogo",
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-File",
-    path.join(packageRoot, "scripts", "install.ps1"),
-    "-Version",
-    version,
-    "-InstallDir",
-    installDir,
-    "-NoPathUpdate",
-  ];
-} else {
-  command = "sh";
-  args = [
-    path.join(packageRoot, "scripts", "install.sh"),
-    "--version",
-    version,
-    "--install-dir",
-    installDir,
-    "--no-path-update",
-  ];
-}
-
-const result = spawnSync(command, args, { stdio: "inherit", env: process.env });
-if (result.error) {
-  console.error(`Unable to run the Etherscan CLI installer: ${result.error.message}`);
-  process.exit(1);
-}
-if (result.status !== 0) {
-  process.exit(result.status === null ? 1 : result.status);
-}
-
-const executable = path.join(
-  installDir,
-  process.platform === "win32" ? "etherscan.exe" : "etherscan",
-);
-if (!fs.existsSync(executable)) {
-  console.error(`The installer did not create ${executable}.`);
-  process.exit(1);
-}

package/npm/prepublish-check.js

@@ -1,81 +0,0 @@
-"use strict";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const packageInfo = require("../package.json");
-
-const versionPattern =
-  /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-
-// npm treats these as glob metacharacters in package.json "files".
-const globPattern = /[*?[\]{}]/;
-
-function checkVersion(version) {
-  if (version === "0.0.0-development") {
-    throw new Error("the development placeholder version cannot be published");
-  }
-  if (!versionPattern.test(version)) {
-    throw new Error(`invalid release version: ${version}`);
-  }
-}
-
-// `npm pack` copies the working tree, not the committed blobs. On Windows a
-// checkout with core.autocrlf=true turns the LF blobs into CRLF, and a CRLF
-// scripts/install.sh cannot be run by /bin/sh on Linux or macOS, which is how
-// @etherscan-npm/cli@1.0.1 shipped an installer that failed on both.
-function checkFileLineEndings(filePath, label) {
-  const contents = fs.readFileSync(filePath);
-  // Skip binaries using the same NUL-byte heuristic git applies for text=auto.
-  if (contents.includes(0x00)) {
-    return;
-  }
-  if (contents.includes(0x0d)) {
-    throw new Error(`${label} contains CRLF line endings`);
-  }
-}
-
-// Checks the literal entries of package.json "files". This fails closed: npm
-// also accepts globs and directories there, and silently skipping what it cannot
-// resolve would let a future "files" edit disable the gate while leaving the
-// publish green — the same silent-pass shape that let 1.0.1 ship.
-function checkLineEndings(baseDir, files = packageInfo.files) {
-  for (const entry of files) {
-    if (globPattern.test(entry)) {
-      throw new Error(
-        `${entry} is a glob pattern; this check only understands literal file paths, so update it before publishing`,
-      );
-    }
-    const filePath = path.join(baseDir, entry);
-    let stats;
-    try {
-      stats = fs.statSync(filePath);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw new Error(`${entry} is listed in package.json "files" but does not exist`);
-      }
-      throw error;
-    }
-    if (stats.isDirectory()) {
-      throw new Error(
-        `${entry} is a directory; this check only understands literal file paths, so update it before publishing`,
-      );
-    }
-    checkFileLineEndings(filePath, entry);
-  }
-}
-
-function main() {
-  checkVersion(packageInfo.version);
-  checkLineEndings(path.resolve(__dirname, ".."));
-}
-
-module.exports = { checkVersion, checkFileLineEndings, checkLineEndings };
-
-if (require.main === module) {
-  try {
-    main();
-  } catch (error) {
-    console.error(`Refusing to publish @etherscan/cli: ${error.message}`);
-    process.exit(1);
-  }
-}

package/scripts/install.ps1

@@ -1,362 +0,0 @@
-[CmdletBinding()]
-param(
-    [string]$Version = $env:ETHERSCAN_VERSION,
-    [string]$InstallDir = $env:ETHERSCAN_INSTALL_DIR,
-    [switch]$NoPathUpdate,
-    [int]$WaitForProcessId = 0,
-    [switch]$CleanupScript,
-    [switch]$Uninstall
-)
-
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-
-$Repository = "etherscan/etherscan-cli"
-$DownloadBaseUrl = $env:ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL
-$InstallMarkerName = ".etherscan-cli-path-added"
-$InstallMarkerContent = "etherscan-cli:path-added:v1"
-
-function Get-EtherscanArchitecture {
-    $architecture = $env:PROCESSOR_ARCHITEW6432
-    if ([string]::IsNullOrWhiteSpace($architecture)) {
-        $architecture = $env:PROCESSOR_ARCHITECTURE
-    }
-
-    switch -Regex ($architecture) {
-        "^(AMD64|x86_64)$" { return "amd64" }
-        "^(ARM64|aarch64)$" { return "arm64" }
-        default { throw "Unsupported Windows architecture: $architecture. Etherscan CLI supports amd64 and arm64." }
-    }
-}
-
-function Get-GitHubApiHeaders {
-    $headers = @{
-        Accept = "application/vnd.github+json"
-        "User-Agent" = "etherscan-cli-installer"
-        "X-GitHub-Api-Version" = "2022-11-28"
-    }
-    if (-not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
-        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
-    }
-    return $headers
-}
-
-function Resolve-EtherscanVersion {
-    param([string]$RequestedVersion)
-
-    if (-not [string]::IsNullOrWhiteSpace($RequestedVersion) -and $RequestedVersion -ne "latest") {
-        $tag = if ($RequestedVersion.StartsWith("v")) { $RequestedVersion } else { "v$RequestedVersion" }
-    }
-    else {
-        if (-not [string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
-            throw "A version is required when the installer test download source is used."
-        }
-        $release = Invoke-RestMethod `
-            -Uri "https://api.github.com/repos/$Repository/releases/latest" `
-            -Headers (Get-GitHubApiHeaders)
-        $tag = [string]$release.tag_name
-    }
-
-    if ($tag -notmatch '^v[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$') {
-        throw "Invalid release version: $tag"
-    }
-
-    return @{
-        Tag = $tag
-        Version = $tag.Substring(1)
-    }
-}
-
-function Copy-InstallerFile {
-    param(
-        [string]$Base,
-        [string]$Name,
-        [string]$Destination
-    )
-
-    if (Test-Path -LiteralPath $Base -PathType Container) {
-        Copy-Item -LiteralPath (Join-Path $Base $Name) -Destination $Destination
-        return
-    }
-
-    $uri = "$($Base.TrimEnd('/'))/$Name"
-    $parsedUri = [Uri]$uri
-    if ($parsedUri.Scheme -ne "https") {
-        throw "Remote downloads must use HTTPS: $uri"
-    }
-
-    $headers = @{
-        "User-Agent" = "etherscan-cli-installer"
-    }
-    if ($parsedUri.Host -in @("github.com", "api.github.com") -and
-        -not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_GITHUB_TOKEN)) {
-        $headers.Authorization = "Bearer $($env:ETHERSCAN_GITHUB_TOKEN)"
-    }
-
-    Invoke-WebRequest -Uri $uri -OutFile $Destination -Headers $headers -UseBasicParsing
-}
-
-function Get-SHA256FileHash {
-    param([string]$Path)
-
-    $sha256 = [Security.Cryptography.SHA256]::Create()
-    try {
-        $stream = [IO.File]::OpenRead($Path)
-        try {
-            return ([BitConverter]::ToString($sha256.ComputeHash($stream))).Replace("-", "").ToLowerInvariant()
-        }
-        finally {
-            $stream.Dispose()
-        }
-    }
-    finally {
-        $sha256.Dispose()
-    }
-}
-
-function Add-EtherscanToUserPath {
-    param([string]$Directory)
-
-    $fullDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\')
-    $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
-    $entries = @($userPath -split ';' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
-    $alreadyPresent = $entries | Where-Object {
-        $entry = $_
-        try {
-            $expandedEntry = [Environment]::ExpandEnvironmentVariables($entry)
-            [IO.Path]::GetFullPath($expandedEntry).TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-        catch {
-            $entry.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-    }
-
-    if (-not $alreadyPresent) {
-        $newUserPath = if ([string]::IsNullOrWhiteSpace($userPath)) {
-            $fullDirectory
-        }
-        else {
-            "$($userPath.TrimEnd(';'));$fullDirectory"
-        }
-        [Environment]::SetEnvironmentVariable("Path", $newUserPath, "User")
-        Write-Host "Added $fullDirectory to your user PATH."
-        $pathAdded = $true
-    }
-    else {
-        $pathAdded = $false
-    }
-
-    $processEntries = @($env:Path -split ';')
-    if (-not ($processEntries | Where-Object { $_.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase) })) {
-        $env:Path = "$env:Path;$fullDirectory"
-    }
-    return $pathAdded
-}
-
-function Remove-EtherscanFromUserPath {
-    param([string]$Directory)
-
-    $fullDirectory = [IO.Path]::GetFullPath($Directory).TrimEnd('\')
-    $entries = @([Environment]::GetEnvironmentVariable("Path", "User") -split ';' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
-    $kept = @($entries | Where-Object {
-        $entry = $_
-        try {
-            $expandedEntry = [Environment]::ExpandEnvironmentVariables($entry)
-            -not [IO.Path]::GetFullPath($expandedEntry).TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-        catch {
-            -not $entry.TrimEnd('\').Equals($fullDirectory, [StringComparison]::OrdinalIgnoreCase)
-        }
-    })
-    if ($kept.Count -ne $entries.Count) {
-        [Environment]::SetEnvironmentVariable("Path", ($kept -join ';'), "User")
-        Write-Host "Removed $fullDirectory from your user PATH."
-    }
-}
-
-function Test-EtherscanInstallMarker {
-    param([string]$Path)
-    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) { return $false }
-    $item = Get-Item -LiteralPath $Path -Force
-    if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { return $false }
-    return (Get-Content -LiteralPath $Path -Raw) -eq $InstallMarkerContent
-}
-
-function Get-EtherscanConfigDirectory {
-    if (-not [string]::IsNullOrWhiteSpace($env:XDG_CONFIG_HOME)) {
-        return Join-Path $env:XDG_CONFIG_HOME "etherscan"
-    }
-    return Join-Path $env:USERPROFILE ".etherscan"
-}
-
-if ($env:OS -ne "Windows_NT") {
-    throw "This installer supports Windows only. Use install.sh on macOS or Linux."
-}
-
-if ([string]::IsNullOrWhiteSpace($InstallDir)) {
-    $localAppData = [Environment]::GetFolderPath([Environment+SpecialFolder]::LocalApplicationData)
-    $InstallDir = Join-Path $localAppData "Programs\Etherscan\bin"
-}
-if ($InstallDir.Contains(';')) {
-    throw "The installation directory cannot contain a semicolon."
-}
-if ($InstallDir.IndexOfAny([char[]]"`r`n") -ge 0) {
-    throw "The installation directory cannot contain a line break."
-}
-if ($WaitForProcessId -gt 0) {
-    Wait-Process -Id $WaitForProcessId -ErrorAction SilentlyContinue
-}
-
-if ($Uninstall) {
-    try {
-        $targetExecutable = Join-Path $InstallDir "etherscan.exe"
-        $marker = Join-Path $InstallDir $InstallMarkerName
-        $validMarker = Test-EtherscanInstallMarker -Path $marker
-        $localAppData = [Environment]::GetFolderPath([Environment+SpecialFolder]::LocalApplicationData)
-        $defaultInstallDir = Join-Path $localAppData "Programs\Etherscan\bin"
-        $legacyDefault = [IO.Path]::GetFullPath($InstallDir).TrimEnd('\').Equals(
-            [IO.Path]::GetFullPath($defaultInstallDir).TrimEnd('\'), [StringComparison]::OrdinalIgnoreCase)
-        $removed = $false
-
-        if (Test-Path -LiteralPath $targetExecutable) {
-            Remove-Item -LiteralPath $targetExecutable -Force
-            Write-Host "Removed $targetExecutable"
-            $removed = $true
-        }
-
-        $otherEntries = @()
-        if (Test-Path -LiteralPath $InstallDir -PathType Container) {
-            $otherEntries = @(Get-ChildItem -LiteralPath $InstallDir -Force | Where-Object {
-                -not ($validMarker -and $_.FullName -eq $marker)
-            } | Select-Object -First 1)
-        }
-        if (-not $NoPathUpdate -and ($validMarker -or $legacyDefault) -and $otherEntries.Count -eq 0) {
-            Remove-EtherscanFromUserPath -Directory $InstallDir
-            if ($validMarker) { Remove-Item -LiteralPath $marker -Force }
-            Remove-Item -LiteralPath $InstallDir -Force -ErrorAction SilentlyContinue
-            $removed = $true
-        }
-        elseif (-not $NoPathUpdate -and (Test-Path -LiteralPath $InstallDir)) {
-            Write-Host "Left $InstallDir on PATH because ownership was not proven or the directory is shared."
-        }
-
-        $configDirectory = Get-EtherscanConfigDirectory
-        if (Test-Path -LiteralPath $configDirectory) {
-            Remove-Item -LiteralPath $configDirectory -Recurse -Force
-            Write-Host "Removed $configDirectory"
-            $removed = $true
-        }
-        if ($removed) { Write-Host "Etherscan CLI uninstalled." } else { Write-Host "Nothing to remove." }
-        if (-not [string]::IsNullOrWhiteSpace($env:ETHERSCAN_API_KEY)) {
-            Write-Warning "ETHERSCAN_API_KEY remains set; unset it in your shell."
-        }
-    }
-    finally {
-        if ($CleanupScript -and -not [string]::IsNullOrWhiteSpace($PSCommandPath)) {
-            Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
-        }
-    }
-    return
-}
-
-$resolved = Resolve-EtherscanVersion -RequestedVersion $Version
-$architecture = Get-EtherscanArchitecture
-$archiveName = "etherscan_$($resolved.Version)_windows_$architecture.zip"
-$baseUrl = if ([string]::IsNullOrWhiteSpace($DownloadBaseUrl)) {
-    "https://github.com/$Repository/releases/download/$($resolved.Tag)"
-}
-else {
-    $DownloadBaseUrl
-}
-
-$tempDirectory = Join-Path ([IO.Path]::GetTempPath()) "etherscan-install-$PID-$([Guid]::NewGuid().ToString('N'))"
-$archivePath = Join-Path $tempDirectory $archiveName
-$checksumPath = Join-Path $tempDirectory "checksums.txt"
-$sourceExecutable = Join-Path $tempDirectory "etherscan.exe"
-
-try {
-    New-Item -ItemType Directory -Path $tempDirectory -Force | Out-Null
-
-    Write-Host "Downloading Etherscan CLI $($resolved.Version) for windows/$architecture..."
-    Copy-InstallerFile -Base $baseUrl -Name $archiveName -Destination $archivePath
-    Copy-InstallerFile -Base $baseUrl -Name "checksums.txt" -Destination $checksumPath
-
-    $pattern = '^([0-9A-Fa-f]{64})\s+\*?' + [Regex]::Escape($archiveName) + '$'
-    $checksumLine = Get-Content -LiteralPath $checksumPath | Where-Object { $_ -match $pattern } | Select-Object -First 1
-    if (-not $checksumLine -or $checksumLine -notmatch $pattern) {
-        throw "No checksum was published for $archiveName."
-    }
-
-    $expectedHash = $Matches[1].ToLowerInvariant()
-    $actualHash = Get-SHA256FileHash -Path $archivePath
-    if ($actualHash -ne $expectedHash) {
-        throw "Checksum verification failed for $archiveName. Expected $expectedHash, received $actualHash."
-    }
-
-    Add-Type -AssemblyName System.IO.Compression.FileSystem
-    $zip = [IO.Compression.ZipFile]::OpenRead($archivePath)
-    try {
-        $executableEntries = @($zip.Entries | Where-Object { $_.FullName.Replace('\', '/') -eq "etherscan.exe" })
-        if ($executableEntries.Count -ne 1) {
-            throw "$archiveName must contain exactly one root-level etherscan.exe."
-        }
-
-        $inputStream = $executableEntries[0].Open()
-        $outputStream = [IO.File]::Create($sourceExecutable)
-        try {
-            $inputStream.CopyTo($outputStream)
-        }
-        finally {
-            $outputStream.Dispose()
-            $inputStream.Dispose()
-        }
-    }
-    finally {
-        $zip.Dispose()
-    }
-
-    New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
-    $targetExecutable = Join-Path $InstallDir "etherscan.exe"
-    $stagedExecutable = Join-Path $InstallDir ".etherscan.exe.new-$PID"
-    $backupExecutable = Join-Path $InstallDir ".etherscan.exe.old-$PID"
-    Copy-Item -LiteralPath $sourceExecutable -Destination $stagedExecutable -Force
-
-    try {
-        if (Test-Path -LiteralPath $targetExecutable) {
-            Move-Item -LiteralPath $targetExecutable -Destination $backupExecutable -Force
-        }
-        Move-Item -LiteralPath $stagedExecutable -Destination $targetExecutable -Force
-        Remove-Item -LiteralPath $backupExecutable -Force -ErrorAction SilentlyContinue
-    }
-    catch {
-        Remove-Item -LiteralPath $stagedExecutable -Force -ErrorAction SilentlyContinue
-        if ((Test-Path -LiteralPath $backupExecutable) -and -not (Test-Path -LiteralPath $targetExecutable)) {
-            Move-Item -LiteralPath $backupExecutable -Destination $targetExecutable -Force
-        }
-        throw
-    }
-
-    if (-not $NoPathUpdate) {
-        $pathAdded = Add-EtherscanToUserPath -Directory $InstallDir
-        if ($pathAdded) {
-            Set-Content -LiteralPath (Join-Path $InstallDir $InstallMarkerName) -Value $InstallMarkerContent -NoNewline
-        }
-    }
-
-    Write-Host ""
-    Write-Host "Etherscan CLI $($resolved.Version) installed successfully."
-    Write-Host "Installed to: $targetExecutable"
-    if ($NoPathUpdate) {
-        Write-Host "Add $InstallDir to PATH to run etherscan from any directory."
-    }
-    else {
-        Write-Host "Run 'etherscan version' to verify the installation."
-        Write-Host "Open a new terminal if the command is not yet available."
-    }
-}
-finally {
-    Remove-Item -LiteralPath $tempDirectory -Recurse -Force -ErrorAction SilentlyContinue
-    if ($CleanupScript -and -not [string]::IsNullOrWhiteSpace($PSCommandPath)) {
-        Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue
-    }
-}

package/scripts/install.sh

@@ -1,340 +0,0 @@
-#!/bin/sh
-
-set -eu
-
-repository="etherscan/etherscan-cli"
-version=${ETHERSCAN_VERSION:-}
-install_dir=${ETHERSCAN_INSTALL_DIR:-"$HOME/.local/bin"}
-download_base=${ETHERSCAN_INSTALL_TEST_DOWNLOAD_BASE_URL:-}
-update_path=1
-uninstall=0
-marker_name=.etherscan-cli-path-added
-marker_content=etherscan-cli:path-added:v1
-
-usage() {
-    cat <<'EOF'
-Install Etherscan CLI.
-
-Usage: install.sh [options]
-
-Options:
-  --version VERSION         Install a specific version (for example, v1.1.0).
-  --install-dir DIRECTORY   Install into DIRECTORY (default: ~/.local/bin).
-  --no-path-update          Do not update the shell profile.
-  --uninstall               Remove the CLI and saved configuration.
-  -h, --help                Show this help.
-EOF
-}
-
-die() {
-    printf 'error: %s\n' "$*" >&2
-    exit 1
-}
-
-while [ "$#" -gt 0 ]; do
-    case "$1" in
-        --version)
-            [ "$#" -ge 2 ] || die "--version requires a value"
-            version=$2
-            shift 2
-            ;;
-        --install-dir)
-            [ "$#" -ge 2 ] || die "--install-dir requires a value"
-            install_dir=$2
-            shift 2
-            ;;
-        --no-path-update)
-            update_path=0
-            shift
-            ;;
-        --uninstall)
-            uninstall=1
-            shift
-            ;;
-        -h|--help)
-            usage
-            exit 0
-            ;;
-        *)
-            die "unknown option: $1"
-            ;;
-    esac
-done
-
-if printf '%s' "$install_dir" | LC_ALL=C grep '[[:cntrl:]]' >/dev/null 2>&1; then
-    die "the installation directory cannot contain control characters"
-fi
-
-config_dir() {
-    if [ -n "${XDG_CONFIG_HOME:-}" ]; then
-        printf '%s\n' "$XDG_CONFIG_HOME/etherscan"
-    else
-        printf '%s\n' "$HOME/.etherscan"
-    fi
-}
-
-profile_has_block() {
-    profile=$1
-    target=$2
-    [ -f "$profile" ] && [ ! -L "$profile" ] || return 1
-    ETHERSCAN_PROFILE_TARGET=$target awk '
-        BEGIN { target = ENVIRON["ETHERSCAN_PROFILE_TARGET"] }
-        previous == "# Etherscan CLI" && $0 == target { found = 1; exit }
-        { previous = $0 }
-        END { exit found ? 0 : 1 }
-    ' "$profile"
-}
-
-remove_profile_block() {
-    profile=$1
-    target=$2
-    profile_has_block "$profile" "$target" || return 0
-    tmp=$(mktemp "${profile}.etherscan-uninstall.XXXXXX") || die "could not create a profile temporary file"
-    if ! cp -p "$profile" "$tmp"; then
-        rm -f "$tmp"
-        die "could not preserve permissions for $profile"
-    fi
-    if ! ETHERSCAN_PROFILE_TARGET=$target awk '
-        BEGIN { target = ENVIRON["ETHERSCAN_PROFILE_TARGET"] }
-        {
-            if (pending) {
-                if ($0 == target) { pending = 0; next }
-                print "# Etherscan CLI"
-                pending = 0
-            }
-            if ($0 == "# Etherscan CLI") { pending = 1; next }
-            print
-        }
-        END { if (pending) print "# Etherscan CLI" }
-    ' "$profile" >"$tmp"; then
-        rm -f "$tmp"
-        die "could not update $profile"
-    fi
-    mv -f "$tmp" "$profile"
-    printf 'Removed the PATH entry from %s\n' "$profile"
-}
-
-directory_empty_except_marker() {
-    directory=$1
-    marker=$2
-    [ -d "$directory" ] || return 0
-    for entry in "$directory"/.[!.]* "$directory"/..?* "$directory"/*; do
-        [ -e "$entry" ] || [ -L "$entry" ] || continue
-        [ "$entry" = "$marker" ] && continue
-        return 1
-    done
-    return 0
-}
-
-if [ "$uninstall" -eq 1 ]; then
-    binary="$install_dir/etherscan"
-    marker="$install_dir/$marker_name"
-    marker_valid=0
-    if [ -f "$marker" ] && [ ! -L "$marker" ] && [ "$(cat "$marker")" = "$marker_content" ]; then
-        marker_valid=1
-    fi
-
-    escaped_install_dir=$(printf '%s' "$install_dir" | sed 's/[\\"$`]/\\&/g')
-    posix_path_line="export PATH=\"$escaped_install_dir:\$PATH\""
-    fish_path_line="fish_add_path \"$escaped_install_dir\""
-    legacy_provenance=0
-    for candidate in "$HOME/.zshrc" "$HOME/.bashrc" "$HOME/.profile"; do
-        if profile_has_block "$candidate" "$posix_path_line"; then
-            legacy_provenance=1
-        fi
-    done
-    if profile_has_block "$HOME/.config/fish/config.fish" "$fish_path_line"; then
-        legacy_provenance=1
-    fi
-
-    removed=0
-    if [ -e "$binary" ] || [ -L "$binary" ]; then
-        rm -f "$binary"
-        printf 'Removed %s\n' "$binary"
-        removed=1
-    fi
-
-    if [ "$update_path" -eq 1 ] && { [ "$marker_valid" -eq 1 ] || [ "$legacy_provenance" -eq 1 ]; } && directory_empty_except_marker "$install_dir" "$marker"; then
-        for candidate in "$HOME/.zshrc" "$HOME/.bashrc" "$HOME/.profile"; do
-            remove_profile_block "$candidate" "$posix_path_line"
-        done
-        remove_profile_block "$HOME/.config/fish/config.fish" "$fish_path_line"
-        if [ "$marker_valid" -eq 1 ]; then
-            rm -f "$marker"
-        fi
-        rmdir "$install_dir" 2>/dev/null || true
-        removed=1
-    elif [ "$update_path" -eq 1 ] && [ -d "$install_dir" ]; then
-        printf 'Left %s on PATH because ownership was not proven or the directory is shared.\n' "$install_dir"
-    fi
-
-    etherscan_config=$(config_dir)
-    if [ -e "$etherscan_config" ] || [ -L "$etherscan_config" ]; then
-        rm -rf "$etherscan_config"
-        printf 'Removed %s\n' "$etherscan_config"
-        removed=1
-    fi
-    if [ "$removed" -eq 1 ]; then
-        printf 'Etherscan CLI uninstalled.\n'
-    else
-        printf 'Nothing to remove.\n'
-    fi
-    if [ -n "${ETHERSCAN_API_KEY:-}" ]; then
-        printf 'note: ETHERSCAN_API_KEY remains set; unset it in your shell.\n' >&2
-    fi
-    exit 0
-fi
-
-fetch_stdout() {
-    url=$1
-    if command -v curl >/dev/null 2>&1; then
-        curl -fsSL -A etherscan-cli-installer "$url"
-    elif command -v wget >/dev/null 2>&1; then
-        wget -qO- --user-agent=etherscan-cli-installer "$url"
-    else
-        die "curl or wget is required"
-    fi
-}
-
-fetch_file() {
-    base=$1
-    name=$2
-    destination=$3
-
-    if [ -d "$base" ]; then
-        cp "$base/$name" "$destination"
-        return
-    fi
-
-    case "$base" in
-        file://*)
-            cp "${base#file://}/$name" "$destination"
-            ;;
-        https://*)
-            if command -v curl >/dev/null 2>&1; then
-                curl -fsSL -A etherscan-cli-installer "$base/$name" -o "$destination"
-            elif command -v wget >/dev/null 2>&1; then
-                wget -q --user-agent=etherscan-cli-installer "$base/$name" -O "$destination"
-            else
-                die "curl or wget is required"
-            fi
-            ;;
-        *)
-            die "invalid download base URL or directory: $base"
-            ;;
-    esac
-}
-
-if [ -z "$version" ] || [ "$version" = latest ]; then
-    [ -z "$download_base" ] || die "a version is required with the installer test download source"
-    release_json=$(fetch_stdout "https://api.github.com/repos/$repository/releases/latest")
-    version=$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | sed -n '1p')
-    [ -n "$version" ] || die "could not resolve the latest Etherscan CLI version"
-fi
-
-case "$version" in
-    v*) tag=$version; release_version=${version#v} ;;
-    *) tag="v$version"; release_version=$version ;;
-esac
-
-printf '%s\n' "$tag" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$' || die "invalid release version: $tag"
-
-system_name=${ETHERSCAN_INSTALL_TEST_OS:-$(uname -s)}
-case "$system_name" in
-    Linux|linux) os=linux ;;
-    Darwin|darwin) os=darwin ;;
-    *) die "unsupported operating system: $system_name" ;;
-esac
-
-machine_arch=${ETHERSCAN_INSTALL_TEST_ARCH:-$(uname -m)}
-case "$machine_arch" in
-    x86_64|amd64) arch=amd64 ;;
-    arm64|aarch64) arch=arm64 ;;
-    *) die "unsupported architecture: $machine_arch. Etherscan CLI supports amd64 and arm64." ;;
-esac
-
-archive_name="etherscan_${release_version}_${os}_${arch}.tar.gz"
-if [ -z "$download_base" ]; then
-    download_base="https://github.com/$repository/releases/download/$tag"
-fi
-
-temp_dir=$(mktemp -d 2>/dev/null || mktemp -d -t etherscan-install)
-trap 'rm -rf "$temp_dir"' EXIT HUP INT TERM
-archive_path="$temp_dir/$archive_name"
-checksum_path="$temp_dir/checksums.txt"
-source_executable="$temp_dir/etherscan"
-
-printf 'Downloading Etherscan CLI %s for %s/%s...\n' "$release_version" "$os" "$arch"
-fetch_file "$download_base" "$archive_name" "$archive_path"
-fetch_file "$download_base" checksums.txt "$checksum_path"
-
-expected_hash=$(awk -v name="$archive_name" '$2 == name || $2 == ("*" name) { print tolower($1); exit }' "$checksum_path")
-[ -n "$expected_hash" ] || die "no checksum was published for $archive_name"
-printf '%s\n' "$expected_hash" | grep -Eq '^[0-9a-f]{64}$' || die "invalid checksum published for $archive_name"
-
-if command -v sha256sum >/dev/null 2>&1; then
-    actual_hash=$(sha256sum "$archive_path" | awk '{ print tolower($1) }')
-elif command -v shasum >/dev/null 2>&1; then
-    actual_hash=$(shasum -a 256 "$archive_path" | awk '{ print tolower($1) }')
-else
-    die "sha256sum or shasum is required to verify the download"
-fi
-
-[ "$actual_hash" = "$expected_hash" ] || die "checksum verification failed for $archive_name"
-
-entry_count=$(tar -tzf "$archive_path" | awk '$0 == "etherscan" { count++ } END { print count + 0 }')
-[ "$entry_count" -eq 1 ] || die "$archive_name must contain exactly one root-level etherscan"
-tar -xOzf "$archive_path" etherscan >"$source_executable"
-[ -s "$source_executable" ] || die "$archive_name contains an empty etherscan executable"
-
-mkdir -p "$install_dir"
-staged_executable="$install_dir/.etherscan.new.$$"
-cp "$source_executable" "$staged_executable"
-chmod 0755 "$staged_executable"
-mv -f "$staged_executable" "$install_dir/etherscan"
-
-path_updated=0
-if [ "$update_path" -eq 1 ]; then
-    case ":$PATH:" in
-        *:"$install_dir":*) ;;
-        *)
-            shell_name=${SHELL:-sh}
-            shell_name=${shell_name##*/}
-            escaped_install_dir=$(printf '%s' "$install_dir" | sed 's/[\\"$`]/\\&/g')
-            if [ "$shell_name" = fish ]; then
-                profile="$HOME/.config/fish/config.fish"
-                mkdir -p "$(dirname "$profile")"
-                path_line="fish_add_path \"$escaped_install_dir\""
-            else
-                case "$shell_name" in
-                    zsh) profile="$HOME/.zshrc" ;;
-                    bash) profile="$HOME/.bashrc" ;;
-                    *) profile="$HOME/.profile" ;;
-                esac
-                path_line="export PATH=\"$escaped_install_dir:\$PATH\""
-            fi
-
-            # Match the exact line we would write (whole-line, fixed-string) so an
-            # unrelated profile line that merely contains the path does not suppress
-            # the update, and a genuine duplicate is not appended.
-            if ! [ -f "$profile" ] || ! grep -Fx -e "$path_line" "$profile" >/dev/null 2>&1; then
-                {
-                    printf '\n# Etherscan CLI\n'
-                    printf '%s\n' "$path_line"
-                } >>"$profile"
-                path_updated=1
-                printf '%s' "$marker_content" >"$install_dir/$marker_name"
-            fi
-            ;;
-    esac
-fi
-
-printf '\nEtherscan CLI %s installed successfully.\n' "$release_version"
-printf 'Installed to: %s\n' "$install_dir/etherscan"
-if [ "$update_path" -eq 0 ]; then
-    printf 'Add %s to PATH to run etherscan from any directory.\n' "$install_dir"
-elif [ "$path_updated" -eq 1 ]; then
-    printf 'Open a new terminal, then run: etherscan version\n'
-else
-    printf 'Run: etherscan version\n'
-fi