@vantaloom/cli 0.5.3 → 0.13.6

package/src/lib/registry.mjs

@@ -0,0 +1,237 @@
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+} from "node:fs"
+import { writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+export function detectNpmRegistry() {
+  // 1. NPM_CONFIG_REGISTRY env var (highest priority, set by npm/npx when running)
+  if (process.env.NPM_CONFIG_REGISTRY) {
+    return process.env.npm_config_registry || process.env.NPM_CONFIG_REGISTRY
+  }
+  // npm also sets the lowercase variant
+  if (process.env.npm_config_registry) {
+    return process.env.npm_config_registry
+  }
+
+  // 2. Read user .npmrc
+  try {
+    const npmrcPaths = [
+      path.join(os.homedir(), ".npmrc"),
+    ]
+    // Also check project-level .npmrc
+    const localNpmrc = path.resolve(".npmrc")
+    if (localNpmrc !== npmrcPaths[0]) {
+      npmrcPaths.unshift(localNpmrc)
+    }
+    for (const npmrcPath of npmrcPaths) {
+      if (existsSync(npmrcPath)) {
+        const content = readFileSync(npmrcPath, "utf8")
+        const match = content.match(/^\s*registry\s*=\s*(.+)/m)
+        if (match) {
+          return match[1].trim()
+        }
+      }
+    }
+  } catch {
+    // Ignore .npmrc read errors
+  }
+
+  return ""
+}
+
+export async function resolveNpmPackageWithFallback({ registries, name, version }) {
+  const errors = []
+  for (const registry of registries) {
+    try {
+      const result = await resolveNpmPackage({ registry, name, version })
+      return { ...result, registry }
+    } catch (error) {
+      const causeCode = error?.cause?.code || ""
+      const isNetworkError = causeCode === "ECONNREFUSED"
+        || causeCode === "ENOTFOUND"
+        || causeCode === "ETIMEDOUT"
+        || causeCode === "ECONNRESET"
+        || causeCode === "UND_ERR_CONNECT_TIMEOUT"
+        || (error instanceof TypeError && error.message === "fetch failed")
+      const isSslError = causeCode === "UNABLE_TO_GET_ISSUER_CERT_LOCALLY"
+        || causeCode === "CERT_HAS_EXPIRED"
+        || causeCode === "DEPTH_ZERO_SELF_SIGNED_CERT"
+        || causeCode === "SELF_SIGNED_CERT_IN_CHAIN"
+        || causeCode === "ERR_TLS_CERT_ALTNAME_INVALID"
+      const isRetryable = isNetworkError || isSslError
+      errors.push({ registry, error, isRetryable, isSslError })
+
+      if (isRetryable && registries.length > 1) {
+        const hint = isSslError ? " (SSL certificate error)" : ""
+        console.error(`vantaloom: ${registry} unreachable${hint}, trying next registry...`)
+        continue
+      }
+      if (isSslError) {
+        throw new Error(
+          `SSL certificate error connecting to ${registry}: ${causeCode}\n` +
+          `  Fix: run with --no-strict-ssl, or set npm config: npm config set strict-ssl false`
+        )
+      }
+      // Non-network error (404, parse error, etc.) — don't try fallbacks
+      throw error
+    }
+  }
+
+  // All registries failed
+  const hasSslError = errors.some((e) => e.isSslError)
+  const tried = errors.map((e) => e.registry).join(", ")
+  const sslHint = hasSslError
+    ? `\n  SSL fix: run with --no-strict-ssl, or set npm config: npm config set strict-ssl false`
+    : ""
+  throw new Error(
+    `all registries unreachable (tried: ${tried}). ` +
+    `Check your network or specify --npm-registry <url>${sslHint}`
+  )
+}
+
+export async function resolveNpmPackage({ registry, name, version }) {
+  const metadataUrl = `${registry}/${encodeURIComponent(name).replace("%2F", "%2f")}`
+  let response
+  try {
+    response = await fetch(metadataUrl, {
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json",
+        "User-Agent": "vantaloom-cli",
+      },
+      signal: AbortSignal.timeout(15000),
+    })
+  } catch (error) {
+    if (error instanceof TypeError && error.message === "fetch failed") {
+      const causeCode = error.cause?.code || ""
+      const causeMsg = causeCode || error.cause?.message || String(error.cause || "")
+      throw Object.assign(
+        new Error(`cannot reach registry ${registry} (${causeMsg})`),
+        { cause: error.cause }
+      )
+    }
+    throw error
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "")
+    throw new Error(`failed to inspect npm package ${name}: HTTP ${response.status}${detail ? ` ${detail.slice(0, 200)}` : ""}`)
+  }
+
+  const metadata = await response.json()
+  const selectedVersion = metadata["dist-tags"]?.[version] ?? version
+  const packageVersion = metadata.versions?.[selectedVersion]
+  if (!packageVersion?.dist?.tarball) {
+    const available = Object.keys(metadata.versions ?? {}).slice(-8).join(", ") || "none"
+    throw new Error(`missing npm package ${name}@${version}; available versions: ${available}`)
+  }
+  return {
+    version: selectedVersion,
+    tarball: packageVersion.dist.tarball,
+  }
+}
+
+export async function downloadNpmTarball({ tarballUrl, target, packageName, version }) {
+  console.log(`  downloading ${packageName}@${version}...`)
+  let response
+  try {
+    response = await fetch(tarballUrl, {
+      headers: {
+        "User-Agent": "vantaloom-cli",
+      },
+      signal: AbortSignal.timeout(120000),
+    })
+  } catch (error) {
+    const causeCode = error?.cause?.code || ""
+    const causeMsg = causeCode || error?.cause?.message || error.message || ""
+    const isSsl = causeCode.includes("CERT") || causeCode === "UNABLE_TO_GET_ISSUER_CERT_LOCALLY"
+    const hint = isSsl ? `\n  Fix: run with --no-strict-ssl` : ""
+    throw new Error(`failed to download ${packageName}@${version} from ${tarballUrl}: ${causeMsg}${hint}`)
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "")
+    throw new Error(`failed to download ${packageName}@${version}: HTTP ${response.status}${detail ? ` ${detail.slice(0, 200)}` : ""}`)
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer())
+  await writeFile(target, buffer)
+  console.log(`  downloaded ${(buffer.length / 1024 / 1024).toFixed(1)} MB`)
+}
+
+export async function downloadReleaseAsset({ repo, releaseTag, assetName, target, token }) {
+  const releaseUrl = `https://api.github.com/repos/${repo}/releases/tags/${releaseTag}`
+  const headers = {
+    "User-Agent": "vantaloom-cli",
+  }
+  const githubToken = token || process.env.VANTALOOM_GITHUB_TOKEN || process.env.GITHUB_TOKEN
+  if (githubToken) {
+    headers.Authorization = `Bearer ${githubToken}`
+  }
+
+  const releaseResponse = await fetch(releaseUrl, { headers })
+  if (!releaseResponse.ok) {
+    const detail = await releaseResponse.text().catch(() => "")
+    const authHint = releaseResponse.status === 404 || releaseResponse.status === 403
+      ? " If the repository is private, set VANTALOOM_GITHUB_TOKEN to a GitHub token that can read releases."
+      : ""
+    throw new Error(`failed to inspect ${repo}@${releaseTag}: HTTP ${releaseResponse.status}.${authHint}${detail ? ` ${detail.slice(0, 200)}` : ""}`)
+  }
+
+  const release = await releaseResponse.json()
+  const asset = release.assets?.find((asset) => asset.name === assetName)
+  if (!asset) {
+    const names = release.assets?.map((asset) => asset.name).join(", ") || "none"
+    throw new Error(`missing release asset ${assetName} in ${repo}@${releaseTag}; available assets: ${names}`)
+  }
+
+  const response = await fetch(asset.url, {
+    headers: {
+      ...headers,
+      Accept: "application/octet-stream",
+    },
+  })
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "")
+    const authHint = response.status === 404 || response.status === 403
+      ? " If the repository is private, set VANTALOOM_GITHUB_TOKEN to a GitHub token that can read releases."
+      : ""
+    throw new Error(`failed to download ${assetName} from ${repo}@${releaseTag}: HTTP ${response.status}.${authHint}${detail ? ` ${detail.slice(0, 200)}` : ""}`)
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer())
+  await writeFile(target, buffer)
+}
+
+export function findExtractedPackage(extractRoot, platform) {
+  const expected = path.join(extractRoot, `vantaloom-${platform}`)
+  if (existsSync(expected)) {
+    return expected
+  }
+
+  const directories = readdirSync(extractRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(extractRoot, entry.name))
+  if (directories.length === 1) {
+    return directories[0]
+  }
+
+  throw new Error(`could not find extracted Vantaloom package in ${extractRoot}`)
+}
+
+export function findExtractedNpmPackage(extractRoot) {
+  const expected = path.join(extractRoot, "package")
+  if (existsSync(expected)) {
+    return expected
+  }
+
+  const directories = readdirSync(extractRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(extractRoot, entry.name))
+  if (directories.length === 1) {
+    return directories[0]
+  }
+
+  throw new Error(`could not find extracted npm package in ${extractRoot}`)
+}