sdkvm 1.0.0

package/dist/index.js

@@ -0,0 +1,1828 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/util/errors.ts
+var SdkvmError = class extends Error {
+  exitCode;
+  hint;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "SdkvmError";
+    this.exitCode = opts.exitCode ?? 1;
+    this.hint = opts.hint;
+  }
+};
+function toSdkvmError(err) {
+  if (err instanceof SdkvmError) return err;
+  if (err instanceof Error) return new SdkvmError(err.message, { hint: err.stack });
+  return new SdkvmError(String(err));
+}
+
+// src/ui/log.ts
+import pc from "picocolors";
+
+// src/core/env.ts
+function envOverride(newName, legacyName) {
+  const fresh = process.env[newName];
+  if (fresh !== void 0 && fresh !== "") return fresh;
+  const legacy = process.env[legacyName];
+  if (legacy !== void 0 && legacy !== "") return legacy;
+  return void 0;
+}
+
+// src/ui/log.ts
+var isQuiet = () => Boolean(envOverride("SDKVM_QUIET", "JVM_QUIET"));
+var label = {
+  info: pc.cyan("sdkvm"),
+  ok: pc.green("sdkvm"),
+  warn: pc.yellow("sdkvm"),
+  error: pc.red("sdkvm")
+};
+var log = {
+  info(msg) {
+    if (!isQuiet()) console.log(`${label.info} ${msg}`);
+  },
+  ok(msg) {
+    if (!isQuiet()) console.log(`${label.ok} ${msg}`);
+  },
+  warn(msg) {
+    if (!isQuiet()) console.error(`${label.warn} ${pc.yellow(msg)}`);
+  },
+  error(msg) {
+    console.error(`${label.error} ${pc.red(msg)}`);
+  },
+  /** 无前缀输出（列表、表格数据） */
+  raw(msg) {
+    console.log(msg);
+  }
+};
+
+// src/cli/install.ts
+import fs9 from "fs";
+import path8 from "path";
+
+// src/core/platform.ts
+function detectPlatform(override) {
+  const rawPlatform = override?.platform ?? process.platform;
+  const rawArch = override?.arch ?? process.arch;
+  const osMap = {
+    darwin: "mac",
+    linux: "linux",
+    win32: "windows"
+  };
+  const archMap = {
+    arm64: "aarch64",
+    aarch64: "aarch64",
+    x64: "x64"
+  };
+  const os6 = osMap[rawPlatform];
+  const arch = archMap[rawArch];
+  if (!os6) {
+    throw new SdkvmError(`Unsupported operating system: ${rawPlatform}`, {
+      hint: "sdkvm currently supports macOS, Linux and Windows."
+    });
+  }
+  if (!arch) {
+    throw new SdkvmError(`Unsupported CPU architecture: ${rawArch}`, {
+      hint: "sdkvm currently supports aarch64 (Apple Silicon / ARM) and x64."
+    });
+  }
+  return { os: os6, arch, rawPlatform, rawArch };
+}
+
+// src/core/config.ts
+import fs4 from "fs";
+import path4 from "path";
+
+// src/core/version.ts
+var LTS_MAJORS = /* @__PURE__ */ new Set([8, 11, 17, 21, 25]);
+var JAVA_VENDOR_IDS = ["temurin", "zulu", "corretto"];
+function parseVersion(vendor, input) {
+  const raw = input.trim();
+  const vendorPrefix = new RegExp(`^(${JAVA_VENDOR_IDS.join("|")})-`, "i");
+  let s = raw.replace(/^jdk-/i, "").replace(vendorPrefix, "").replace(/^v/i, "");
+  s = s.replace(/^zulu\d[\d.]*-ca-jdk[\d.]*-?/i, "");
+  const plusIdx = s.indexOf("+");
+  const basePart = plusIdx >= 0 ? s.slice(0, plusIdx) : s;
+  const build = plusIdx >= 0 ? s.slice(plusIdx + 1) : null;
+  const segs = basePart.split(".").filter((x) => x.length > 0);
+  if (segs.length === 0) {
+    throw new SdkvmError(`Invalid JDK version: "${input}"`);
+  }
+  const nums = segs.map((x) => Number(x));
+  if (nums.some((n) => !Number.isInteger(n) || n < 0)) {
+    throw new SdkvmError(`Invalid JDK version: "${input}"`, {
+      hint: "Expected forms: 21, 21.0.5, 21.0.5+11"
+    });
+  }
+  return {
+    vendor,
+    major: nums[0],
+    minor: nums[1] ?? 0,
+    patch: nums[2] ?? 0,
+    extra: segs.length > 3 ? segs.slice(3).join(".") : null,
+    build,
+    raw
+  };
+}
+function formatVersion(v) {
+  if (v.patch !== null && v.minor === 0 && v.patch === 0 && !v.extra && !v.build) return String(v.major);
+  let s = `${v.major}.${v.minor}.${v.patch ?? 0}`;
+  if (v.extra) s += `.${v.extra}`;
+  if (v.build) s += `+${v.build}`;
+  return s;
+}
+function parseDirName(dir) {
+  const m = new RegExp(`^(${JAVA_VENDOR_IDS.join("|")})-(.+)$`).exec(dir);
+  if (!m || !m[1] || !m[2]) return null;
+  try {
+    return parseVersion(m[1], m[2]);
+  } catch {
+    return null;
+  }
+}
+function numericPairwise(a, b) {
+  const as = a ? a.split(".") : [];
+  const bs = b ? b.split(".") : [];
+  const len = Math.max(as.length, bs.length);
+  for (let i = 0; i < len; i++) {
+    const x = as[i];
+    const y = bs[i];
+    if (x === void 0 && y !== void 0) return -1;
+    if (x !== void 0 && y === void 0) return 1;
+    const xn = Number(x);
+    const yn = Number(y);
+    if (Number.isInteger(xn) && Number.isInteger(yn)) {
+      if (xn !== yn) return xn - yn > 0 ? 1 : -1;
+    } else {
+      const c = String(x).localeCompare(String(y));
+      if (c !== 0) return c > 0 ? 1 : -1;
+    }
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  for (const key of ["major", "minor"]) {
+    if (a[key] !== b[key]) return a[key] - b[key] > 0 ? 1 : -1;
+  }
+  const pa = a.patch ?? 0;
+  const pb = b.patch ?? 0;
+  if (pa !== pb) return pa - pb > 0 ? 1 : -1;
+  const extra = numericPairwise(a.extra, b.extra);
+  if (extra !== 0) return extra;
+  return numericPairwise(a.build, b.build);
+}
+function parseUserSpec(input) {
+  let s = input.trim().toLowerCase();
+  let vendor;
+  const m = new RegExp(`^(${JAVA_VENDOR_IDS.join("|")})-(.+)$`).exec(s);
+  if (m && m[1] && m[2]) {
+    vendor = m[1];
+    s = m[2];
+  }
+  if (s === "lts" || s === "--lts") return { vendor, spec: { kind: "lts" } };
+  if (/^\d+$/.test(s)) return { vendor, spec: { kind: "major", major: Number(s) } };
+  if (/^\d+(\.\d+)*(\+[0-9.]+)?$/.test(s)) return { vendor, spec: { kind: "full", version: s } };
+  throw new SdkvmError(`Invalid version: "${input}"`, {
+    hint: "Expected: 21, lts, 21.0.5, 21.0.5+11, or with vendor prefix like temurin-21"
+  });
+}
+var GO_VENDOR_IDS = ["golang"];
+function parseGoVersion(vendor, input) {
+  const raw = input.trim();
+  const s = raw.replace(/^golang-/i, "").replace(/^go/i, "").replace(/^v/i, "");
+  const m = /^(\d+)\.(\d+)(?:\.(\d+))?$/.exec(s);
+  if (!m || !m[1] || !m[2]) {
+    throw new SdkvmError(`Invalid Go version: "${input}"`, {
+      hint: "Expected forms: 1.24, 1.24.5, go1.24.5"
+    });
+  }
+  return {
+    vendor,
+    major: Number(m[1]),
+    minor: Number(m[2]),
+    patch: m[3] !== void 0 ? Number(m[3]) : null,
+    extra: null,
+    build: null,
+    raw
+  };
+}
+function formatGoVersion(v) {
+  return v.patch === null ? `${v.major}.${v.minor}` : `${v.major}.${v.minor}.${v.patch}`;
+}
+function parseGoDirName(dir) {
+  const m = new RegExp(`^(${GO_VENDOR_IDS.join("|")})-(.+)$`).exec(dir);
+  if (!m || !m[1] || !m[2]) return null;
+  try {
+    return parseGoVersion(m[1], m[2]);
+  } catch {
+    return null;
+  }
+}
+function parseGoUserSpec(input) {
+  let s = input.trim().toLowerCase();
+  let vendor;
+  const m = new RegExp(`^(${GO_VENDOR_IDS.join("|")})-(.+)$`).exec(s);
+  if (m && m[1] && m[2]) {
+    vendor = m[1];
+    s = m[2];
+  }
+  if (s === "latest") return { vendor, spec: { kind: "latest" } };
+  if (/^\d+\.\d+\.\d+$/.test(s)) return { vendor, spec: { kind: "full", version: s } };
+  const line = /^(\d+)\.(\d+)$/.exec(s);
+  if (line && line[1] && line[2]) {
+    return { vendor, spec: { kind: "line", major: Number(line[1]), minor: Number(line[2]) } };
+  }
+  throw new SdkvmError(`Invalid version: "${input}"`, {
+    hint: "Expected: 1.24, 1.24.5, latest, or with vendor prefix like golang-1.24"
+  });
+}
+var FLUTTER_VENDOR_IDS = ["flutter"];
+function parseFlutterVersion(vendor, input) {
+  const raw = input.trim();
+  const s = raw.replace(/^flutter-/i, "").replace(/^v/i, "");
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(s);
+  if (!m || !m[1] || !m[2] || !m[3]) {
+    throw new SdkvmError(`Invalid Flutter version: "${input}"`, {
+      hint: "Expected forms: 3.47, 3.47.5, 3.49.0-0.1.pre, latest"
+    });
+  }
+  return {
+    vendor,
+    major: Number(m[1]),
+    minor: Number(m[2]),
+    patch: Number(m[3]),
+    extra: m[4] ?? null,
+    build: null,
+    raw
+  };
+}
+function formatFlutterVersion(v) {
+  const base = `${v.major}.${v.minor}.${v.patch ?? 0}`;
+  return v.extra ? `${base}-${v.extra}` : base;
+}
+function parseFlutterDirName(dir) {
+  const m = new RegExp(`^(${FLUTTER_VENDOR_IDS.join("|")})-(.+)$`).exec(dir);
+  if (!m || !m[1] || !m[2]) return null;
+  try {
+    return parseFlutterVersion(m[1], m[2]);
+  } catch {
+    return null;
+  }
+}
+function parseFlutterUserSpec(input) {
+  let s = input.trim().toLowerCase();
+  let vendor;
+  const m = new RegExp(`^(${FLUTTER_VENDOR_IDS.join("|")})-(.+)$`).exec(s);
+  if (m && m[1] && m[2]) {
+    vendor = m[1];
+    s = m[2];
+  }
+  if (s === "latest") return { vendor, spec: { kind: "latest" } };
+  if (/^\d+\.\d+\.\d+(-[0-9a-z.\-]+)?$/.test(s)) return { vendor, spec: { kind: "full", version: s } };
+  const line = /^(\d+)\.(\d+)$/.exec(s);
+  if (line && line[1] && line[2]) {
+    return { vendor, spec: { kind: "line", major: Number(line[1]), minor: Number(line[2]) } };
+  }
+  if (/^\d+$/.test(s)) {
+    throw new SdkvmError(`Invalid Flutter version: "${input}"`, {
+      hint: 'Bare major is ambiguous \u2014 use "latest" or a minor line like "3.47"'
+    });
+  }
+  throw new SdkvmError(`Invalid Flutter version: "${input}"`, {
+    hint: "Expected: 3.47, 3.47.5, 3.49.0-0.1.pre, latest, or with vendor prefix like flutter-3.47"
+  });
+}
+
+// src/core/paths.ts
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+
+// src/sdk/java.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/cli/misc.ts
+import fs from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+function getVersion() {
+  const fallback = "0.1.0";
+  try {
+    const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function versionCommand() {
+  log.raw(getVersion());
+}
+
+// src/net/http.ts
+var UA = `sdkvm/${getVersion()} (npm sdkvm)`;
+var CONNECT_TIMEOUT_MS = 3e4;
+var RETRIES = 3;
+var HttpError = class extends SdkvmError {
+  constructor(message, status, url) {
+    super(message, { hint: `URL: ${url}` });
+    this.status = status;
+    this.url = url;
+    this.name = "HttpError";
+  }
+  status;
+  url;
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function fetchOnce(url, init) {
+  const signal = init.signal ?? AbortSignal.timeout(CONNECT_TIMEOUT_MS);
+  const res = await fetch(url, { ...init, signal, headers: { "user-agent": UA, ...init.headers } });
+  return res;
+}
+async function httpFetch(url, init = {}) {
+  let lastErr;
+  for (let attempt = 1; attempt <= RETRIES; attempt++) {
+    try {
+      const res = await fetchOnce(url, init);
+      if (init.redirect === "manual" && res.status >= 300 && res.status < 400) {
+        return res;
+      }
+      if (res.status >= 500 && attempt < RETRIES) {
+        lastErr = new HttpError(`Server error ${res.status}`, res.status, url);
+        await sleep(500 * 2 ** (attempt - 1));
+        continue;
+      }
+      if (!res.ok) {
+        throw new HttpError(`HTTP ${res.status} ${res.statusText || ""}`.trim(), res.status, url);
+      }
+      return res;
+    } catch (err) {
+      if (err instanceof HttpError && err.status < 500) throw err;
+      lastErr = err;
+      if (attempt < RETRIES) await sleep(500 * 2 ** (attempt - 1));
+    }
+  }
+  if (lastErr instanceof SdkvmError) throw lastErr;
+  throw new SdkvmError(`Network error after ${RETRIES} attempts: ${url}`, {
+    hint: lastErr instanceof Error ? lastErr.message : String(lastErr)
+  });
+}
+async function httpJson(url) {
+  const res = await httpFetch(url, { headers: { accept: "application/json" } });
+  return await res.json();
+}
+async function httpText(url) {
+  const res = await httpFetch(url);
+  return await res.text();
+}
+
+// src/vendor/temurin.ts
+var API = "https://api.adoptium.net";
+async function resolveLatestRedirect(major, os6, arch) {
+  const url = `${API}/v3/binary/latest/${major}/ga/${os6}/${arch}/jdk/hotspot/normal/eclipse`;
+  const res = await httpFetch(url, { redirect: "manual" });
+  if (res.status !== 302 && res.status !== 307 && res.status !== 308) {
+    throw new SdkvmError(`Adoptium API returned ${res.status} for JDK ${major}`);
+  }
+  const location = res.headers.get("location");
+  if (!location) throw new SdkvmError(`Adoptium API returned no redirect for JDK ${major}`);
+  return location;
+}
+function versionFromGithubUrl(url) {
+  const m = /\/download\/jdk-([^/%]+(?:%2B[^/%]+)?)\//i.exec(url);
+  if (!m || !m[1]) throw new SdkvmError(`Cannot parse version from Adoptium URL: ${url}`);
+  return decodeURIComponent(m[1]);
+}
+function githubAssetUrl(version, os6, arch) {
+  const v = parseVersion("temurin", version);
+  const major = v.major;
+  const ext = os6 === "windows" ? "zip" : "tar.gz";
+  const underscored = formatVersion(v).replace("+", "_");
+  const file = `OpenJDK${major}U-jdk_${arch}_${os6}_hotspot_${underscored}.${ext}`;
+  return `https://github.com/adoptium/temurin${major}-binaries/releases/download/jdk-${encodeURIComponent(version)}/${file}`;
+}
+async function fetchAvailable() {
+  return httpJson(`${API}/v3/info/available_releases`);
+}
+async function resolveMajor(major, platform) {
+  const location = await resolveLatestRedirect(major, platform.os, platform.arch);
+  const version = versionFromGithubUrl(location);
+  return buildArtifact(version, platform, location);
+}
+function buildArtifact(version, platform, downloadUrl) {
+  const v = parseVersion("temurin", version);
+  const archive = platform.os === "windows" ? "zip" : "tar.gz";
+  return {
+    vendorId: "temurin",
+    version: v,
+    dirName: `temurin-${formatVersion(v)}`,
+    displayName: `Temurin ${formatVersion(v)}`,
+    downloadUrl,
+    checksum: { kind: "sha256", url: `${downloadUrl}.json` },
+    archive
+  };
+}
+var temurinVendor = {
+  id: "temurin",
+  label: "Adoptium Temurin",
+  sdk: "java",
+  supportsFullVersionList: true,
+  async listMajors() {
+    const data = await fetchAvailable();
+    return data.available_releases.slice().sort((a, b) => a - b).map((major) => ({ key: String(major), lts: data.available_lts_releases.includes(major) }));
+  },
+  async resolve(spec, platform) {
+    if (spec.kind === "major") {
+      return resolveMajor(spec.major, platform);
+    }
+    if (spec.kind === "lts") {
+      const data = await fetchAvailable();
+      const ltsMajors = data.available_releases.filter(
+        (m) => data.available_lts_releases.includes(m)
+      );
+      const latest = Math.max(...ltsMajors);
+      return resolveMajor(latest, platform);
+    }
+    if (spec.kind !== "full") {
+      throw new SdkvmError(`Unsupported version spec for Temurin: ${spec.kind}`);
+    }
+    const url = githubAssetUrl(spec.version, platform.os, platform.arch);
+    return buildArtifact(spec.version, platform, url);
+  }
+};
+
+// src/vendor/zulu.ts
+var API2 = "https://api.azul.com/metadata/v1";
+function azulParams(platform) {
+  return {
+    os: platform.os === "mac" ? "macos" : platform.os,
+    arch: platform.arch === "aarch64" ? "arm" : "x64"
+  };
+}
+function pickPlainJdk(packages, platform, versionPrefix) {
+  const ext = platform.os === "windows" ? ".zip" : ".tar.gz";
+  const wanted = versionPrefix ?? "";
+  const candidates = packages.filter((p) => {
+    if (!/^zulu[\d.]+-ca-jdk[\d.]*-/i.test(p.name)) return false;
+    if (!p.name.endsWith(ext)) return false;
+    if (wanted && !p.java_version.join(".").startsWith(wanted)) return false;
+    return true;
+  });
+  candidates.sort((a, b) => {
+    const ja = a.java_version.join(".").localeCompare(b.java_version.join("."), void 0, {
+      numeric: true
+    });
+    return ja;
+  });
+  return candidates[candidates.length - 1] ?? null;
+}
+async function queryPackages(javaVersion, platform) {
+  const { os: os6, arch } = azulParams(platform);
+  const url = `${API2}/zulu/packages/?java_version=${javaVersion}&os=${os6}&arch=${arch}&hw_bitness=64&release_status=ga&page_size=50`;
+  const data = await httpJson(url);
+  return Array.isArray(data) ? data : [];
+}
+var zuluVendor = {
+  id: "zulu",
+  label: "Azul Zulu",
+  sdk: "java",
+  supportsFullVersionList: true,
+  async listMajors() {
+    const universe = await temurinVendor.listMajors();
+    const results = await Promise.all(
+      universe.map(async ({ key }) => {
+        try {
+          const packages = await queryPackages(key, {
+            os: "mac",
+            arch: "aarch64"
+          });
+          const pick = pickPlainJdk(packages, { os: "mac", arch: "aarch64" });
+          if (!pick) return null;
+          return { key, lts: LTS_MAJORS.has(Number(key)), latestFullVersion: pick.java_version.join(".") };
+        } catch {
+          return null;
+        }
+      })
+    );
+    return results.filter((r) => r !== null);
+  },
+  async resolve(spec, platform) {
+    if (spec.kind === "lts") {
+      const majors = await this.listMajors();
+      const lts = majors.filter((m) => m.lts);
+      if (lts.length === 0) throw new SdkvmError("No Zulu LTS release found");
+      const latest = lts[lts.length - 1];
+      if (!latest) throw new SdkvmError("No Zulu LTS release found");
+      return this.resolve({ kind: "major", major: Number(latest.key) }, platform);
+    }
+    if (spec.kind !== "major" && spec.kind !== "full") {
+      throw new SdkvmError(`Unsupported version spec for Zulu: ${spec.kind}`);
+    }
+    const versionPrefix = spec.kind === "major" ? String(spec.major) : spec.version;
+    const major = spec.kind === "major" ? spec.major : parseVersion("zulu", spec.version).major;
+    const packages = await queryPackages(String(major), platform);
+    const pick = pickPlainJdk(packages, platform, versionPrefix);
+    if (!pick) {
+      throw new SdkvmError(`No Zulu JDK build matches "${versionPrefix}"`, {
+        hint: "Run `jvm ls -r` to see available versions."
+      });
+    }
+    const versionStr = pick.java_version.join(".");
+    const v = parseVersion("zulu", versionStr);
+    return {
+      vendorId: "zulu",
+      version: v,
+      dirName: `zulu-${formatVersion(v)}`,
+      displayName: `Zulu ${formatVersion(v)}`,
+      downloadUrl: pick.download_url,
+      checksum: pick.sha256_hash ? { kind: "sha256", expected: pick.sha256_hash } : null,
+      archive: platform.os === "windows" ? "zip" : "tar.gz"
+    };
+  }
+};
+
+// src/vendor/corretto.ts
+var BASE = "https://corretto.aws/downloads";
+var MAJORS = [8, 11, 17, 21, 25];
+function latestFileName(major, platform) {
+  const osName = platform.os === "mac" ? "macos" : platform.os;
+  const ext = platform.os === "windows" ? "zip" : "tar.gz";
+  return `amazon-corretto-${major}-${platform.arch}-${osName}-jdk.${ext}`;
+}
+function resourceFileName(version, platform) {
+  if (platform.os === "mac") return `amazon-corretto-${version}-macosx-${platform.arch}.tar.gz`;
+  if (platform.os === "linux") return `amazon-corretto-${version}-linux-${platform.arch}.tar.gz`;
+  return `amazon-corretto-${version}-windows-${platform.arch}-jdk.zip`;
+}
+function resourceUrl(version, platform) {
+  return `${BASE}/resources/${version}/${resourceFileName(version, platform)}`;
+}
+async function resolveLatestVersion(major, platform) {
+  const url = `${BASE}/latest/${latestFileName(major, platform)}`;
+  const res = await httpFetch(url, { redirect: "manual" });
+  if (res.status !== 301 && res.status !== 302 && res.status !== 307 && res.status !== 308) {
+    throw new SdkvmError(`Corretto returned ${res.status} for JDK ${major}`);
+  }
+  const location = res.headers.get("location") ?? "";
+  const m = /\/resources\/([^/]+)\//.exec(location);
+  if (!m || !m[1]) {
+    throw new SdkvmError(`Cannot parse Corretto version from redirect: ${location}`);
+  }
+  return m[1];
+}
+var correttoVendor = {
+  id: "corretto",
+  label: "Amazon Corretto",
+  sdk: "java",
+  supportsFullVersionList: false,
+  async listMajors() {
+    return MAJORS.map((major) => ({ key: String(major), lts: LTS_MAJORS.has(major) }));
+  },
+  async resolve(spec, platform) {
+    let version;
+    if (spec.kind === "lts") {
+      const latestLts = Math.max(...MAJORS);
+      version = await resolveLatestVersion(latestLts, platform);
+    } else if (spec.kind === "major") {
+      if (!MAJORS.includes(spec.major)) {
+        throw new SdkvmError(`Corretto does not publish JDK ${spec.major}`, {
+          hint: `Available majors: ${MAJORS.join(", ")}`
+        });
+      }
+      version = await resolveLatestVersion(spec.major, platform);
+    } else if (spec.kind === "full") {
+      const v2 = parseVersion("corretto", spec.version);
+      if (!MAJORS.includes(v2.major)) {
+        throw new SdkvmError(`Corretto does not publish JDK ${v2.major}`);
+      }
+      version = spec.version;
+    } else {
+      throw new SdkvmError(`Unsupported version spec for Corretto: ${spec.kind}`);
+    }
+    const v = parseVersion("corretto", version);
+    const url = resourceUrl(version, platform);
+    return {
+      vendorId: "corretto",
+      version: v,
+      dirName: `corretto-${formatVersion(v)}`,
+      displayName: `Corretto ${formatVersion(v)}`,
+      downloadUrl: url,
+      checksum: { kind: "sha256", url: `${url}.sha256` },
+      archive: platform.os === "windows" ? "zip" : "tar.gz"
+    };
+  }
+};
+
+// src/cli/cmdname.ts
+var CLI_BIN = "sdkvm";
+function cmdPath(type) {
+  return type === "java" ? CLI_BIN : `${CLI_BIN} ${type}`;
+}
+
+// src/vendor/golang.ts
+var LIST_URL = "https://go.dev/dl/?mode=json&include=all";
+var GO_OS = { mac: "darwin", linux: "linux", windows: "windows" };
+var GO_ARCH = { aarch64: "arm64", x64: "amd64" };
+async function fetchReleases() {
+  return httpJson(LIST_URL);
+}
+async function stableVersions() {
+  const releases = await fetchReleases();
+  const parsed = [];
+  for (const r of releases) {
+    if (!r.stable) continue;
+    try {
+      parsed.push({ raw: r, v: parseGoVersion("golang", r.version) });
+    } catch {
+    }
+  }
+  parsed.sort((a, b) => compareVersions(b.v, a.v));
+  return parsed;
+}
+function pickFile(r, platform) {
+  return r.files.find(
+    (f) => f.kind === "archive" && f.os === GO_OS[platform.os] && f.arch === GO_ARCH[platform.arch]
+  );
+}
+function buildArtifact2(r, f, v) {
+  return {
+    vendorId: "golang",
+    version: v,
+    dirName: `golang-${formatGoVersion(v)}`,
+    displayName: `Go ${formatGoVersion(v)}`,
+    downloadUrl: `https://go.dev/dl/${f.filename}`,
+    checksum: { kind: "sha256", expected: f.sha256 },
+    archive: f.filename.endsWith(".zip") ? "zip" : "tar.gz"
+  };
+}
+function specLabel(spec) {
+  if (spec.kind === "line") return `${spec.major}.${spec.minor}`;
+  if (spec.kind === "full") return spec.version;
+  return "latest";
+}
+var golangVendor = {
+  id: "golang",
+  label: "Go (official)",
+  sdk: "go",
+  supportsFullVersionList: true,
+  /** go 无 major 概念：一条 minor 线（1.24）等价 java 的一个 major */
+  async listMajors() {
+    const versions = await stableVersions();
+    const lines = /* @__PURE__ */ new Map();
+    for (const { v } of versions) {
+      const key = `${v.major}.${v.minor}`;
+      const cur = lines.get(key);
+      if (!cur || compareVersions(v, cur) > 0) lines.set(key, v);
+    }
+    return [...lines.entries()].map(([key, v]) => ({ key, lts: false, latestFullVersion: formatGoVersion(v) })).sort((a, b) => compareVersions(parseGoVersion("golang", b.key), parseGoVersion("golang", a.key)));
+  },
+  async resolve(spec, platform) {
+    if (spec.kind === "lts" || spec.kind === "major") {
+      throw new SdkvmError(`Unsupported version spec for Go: ${spec.kind}`);
+    }
+    const versions = await stableVersions();
+    let target;
+    if (spec.kind === "latest") {
+      target = versions[0];
+    } else if (spec.kind === "line") {
+      target = versions.find((x) => x.v.major === spec.major && x.v.minor === spec.minor);
+    } else {
+      target = versions.find((x) => formatGoVersion(x.v) === spec.version);
+    }
+    if (!target) {
+      throw new SdkvmError(`No Go release matches "${specLabel(spec)}"`, {
+        hint: `Run \`${cmdPath("go")} ls -r\` to see available versions.`
+      });
+    }
+    const file = pickFile(target.raw, platform);
+    if (!file) {
+      throw new SdkvmError(
+        `Go ${formatGoVersion(target.v)} has no archive for ${platform.os}/${platform.arch}`
+      );
+    }
+    return buildArtifact2(target.raw, file, target.v);
+  }
+};
+
+// src/vendor/flutter.ts
+var MANIFEST_BASE = "https://storage.googleapis.com/flutter_infra_release/releases";
+var FLUTTER_OS = { mac: "macos", linux: "linux", windows: "windows" };
+var FLUTTER_ARCH = { aarch64: "arm64", x64: "x64" };
+async function fetchEntries(platform) {
+  const manifest = await httpJson(`${MANIFEST_BASE}/releases_${FLUTTER_OS[platform.os]}.json`);
+  const arch = FLUTTER_ARCH[platform.arch];
+  const parsed = [];
+  for (const r of manifest.releases) {
+    if (r.dart_sdk_arch !== arch) continue;
+    try {
+      parsed.push({ raw: r, v: parseFlutterVersion("flutter", r.version) });
+    } catch {
+    }
+  }
+  parsed.sort((a, b) => compareVersions(b.v, a.v));
+  return {
+    baseUrl: manifest.base_url,
+    stable: parsed.filter((x) => x.raw.channel === "stable"),
+    all: parsed
+  };
+}
+function buildArtifact3(baseUrl, r, v, platform) {
+  return {
+    vendorId: "flutter",
+    version: v,
+    dirName: `flutter-${formatFlutterVersion(v)}`,
+    displayName: `Flutter ${formatFlutterVersion(v)}`,
+    downloadUrl: `${baseUrl}/${r.archive}`,
+    checksum: { kind: "sha256", expected: r.sha256 },
+    archive: platform.os === "linux" ? "tar.xz" : "zip"
+  };
+}
+function specLabel2(spec) {
+  if (spec.kind === "line") return `${spec.major}.${spec.minor}`;
+  if (spec.kind === "full") return spec.version;
+  return "latest";
+}
+var flutterVendor = {
+  id: "flutter",
+  label: "Flutter (official)",
+  sdk: "flutter",
+  supportsFullVersionList: true,
+  /** 一条 minor 线（3.47）等价 java 的一个 major；latest/line 只看 stable 通道 */
+  async listMajors() {
+    const { stable } = await fetchEntries(detectPlatform());
+    const lines = /* @__PURE__ */ new Map();
+    for (const { v } of stable) {
+      const key = `${v.major}.${v.minor}`;
+      const cur = lines.get(key);
+      if (!cur || compareVersions(v, cur) > 0) lines.set(key, v);
+    }
+    return [...lines.entries()].map(([key, v]) => ({ key, v })).sort((a, b) => compareVersions(b.v, a.v)).map(({ key, v }) => ({ key, lts: false, latestFullVersion: formatFlutterVersion(v) }));
+  },
+  async resolve(spec, platform) {
+    if (spec.kind === "lts" || spec.kind === "major") {
+      throw new SdkvmError(`Unsupported version spec for Flutter: ${spec.kind}`);
+    }
+    const { baseUrl, stable, all } = await fetchEntries(platform);
+    if (all.length === 0) {
+      throw new SdkvmError(
+        `No Flutter archive for ${platform.os}/${platform.arch} (official releases are x64-only on Linux/Windows)`
+      );
+    }
+    let target;
+    if (spec.kind === "latest") {
+      target = stable[0];
+    } else if (spec.kind === "line") {
+      target = stable.find((x) => x.v.major === spec.major && x.v.minor === spec.minor);
+    } else {
+      target = stable.find((x) => formatFlutterVersion(x.v) === spec.version) ?? all.find((x) => formatFlutterVersion(x.v) === spec.version);
+    }
+    if (!target) {
+      throw new SdkvmError(`No Flutter release matches "${specLabel2(spec)}"`, {
+        hint: `Run \`${cmdPath("flutter")} ls -r\` to see available versions.`
+      });
+    }
+    return buildArtifact3(baseUrl, target.raw, target.v, platform);
+  }
+};
+
+// src/vendor/index.ts
+var JAVA_VENDORS = [temurinVendor, zuluVendor, correttoVendor];
+var GO_VENDORS = [golangVendor];
+var FLUTTER_VENDORS = [flutterVendor];
+function vendorsFor(type) {
+  if (type === "java") return JAVA_VENDORS;
+  if (type === "go") return GO_VENDORS;
+  if (type === "flutter") return FLUTTER_VENDORS;
+  throw new SdkvmError(`Unknown SDK type: ${type}`);
+}
+function allVendorIds(type) {
+  return vendorsFor(type).map((v) => v.id);
+}
+function getVendor(type, id) {
+  const vendor = vendorsFor(type).find((v) => v.id === id);
+  if (!vendor) {
+    throw new SdkvmError(`Unknown vendor: ${id}`, {
+      hint: `Available vendors for ${type}: ${allVendorIds(type).join(", ")}`
+    });
+  }
+  return vendor;
+}
+function resolveVendorId(type, arg, config) {
+  const vendors = vendorsFor(type);
+  const id = arg ?? (type === "java" ? config.defaultVendor : vendors[0]?.id);
+  const found = vendors.find((v) => v.id === id);
+  if (!found) {
+    throw new SdkvmError(`Unknown vendor: ${arg}`, {
+      hint: `Available vendors: ${vendors.map((v) => v.id).join(", ")}`
+    });
+  }
+  return found.id;
+}
+
+// src/sdk/java.ts
+var javaSdk = {
+  id: "java",
+  label: "Java (JDK)",
+  installDirName: "jdks",
+  currentLinkName: "current-java",
+  envVar: "JAVA_HOME",
+  supportsLts: true,
+  vendors: JAVA_VENDORS,
+  parseUserSpec,
+  parseDirName,
+  formatVersion,
+  compareVersions,
+  binRelPath(platform) {
+    return `bin/${platform.os === "windows" ? "java.exe" : "java"}`;
+  },
+  locateHome(root) {
+    const contentsHome = path2.join(root, "Contents", "Home");
+    return fs2.existsSync(path2.join(contentsHome, "bin")) ? contentsHome : root;
+  },
+  versionCheck: { args: ["-version"], stream: "stderr" }
+};
+
+// src/sdk/go.ts
+var goSdk = {
+  id: "go",
+  label: "Go",
+  installDirName: "gos",
+  currentLinkName: "current-go",
+  envVar: "GOROOT",
+  supportsLts: false,
+  vendors: GO_VENDORS,
+  parseUserSpec: parseGoUserSpec,
+  parseDirName: parseGoDirName,
+  formatVersion: formatGoVersion,
+  compareVersions,
+  binRelPath(platform) {
+    return `bin/${platform.os === "windows" ? "go.exe" : "go"}`;
+  },
+  // go 归档是单根 go/ 目录，无 macOS bundle 概念
+  locateHome: (root) => root,
+  versionCheck: { args: ["version"], stream: "stdout" }
+};
+
+// src/sdk/flutter.ts
+var flutterSdk = {
+  id: "flutter",
+  label: "Flutter",
+  installDirName: "flutters",
+  currentLinkName: "current-flutter",
+  envVar: "FLUTTER_ROOT",
+  supportsLts: false,
+  vendors: FLUTTER_VENDORS,
+  parseUserSpec: parseFlutterUserSpec,
+  parseDirName: parseFlutterDirName,
+  formatVersion: formatFlutterVersion,
+  compareVersions,
+  binRelPath(platform) {
+    return `bin/${platform.os === "windows" ? "flutter.bat" : "flutter"}`;
+  },
+  // flutter 归档是单根 flutter/ 目录，无 macOS bundle 概念
+  locateHome: (root) => root,
+  versionCheck: { args: ["--version"], stream: "stdout" }
+};
+
+// src/sdk/index.ts
+var SPECS = {
+  java: javaSdk,
+  go: goSdk,
+  flutter: flutterSdk
+};
+var SDK_TYPES = ["java", "go", "flutter"];
+function getSdkType(id) {
+  const spec = SPECS[id];
+  if (!spec) throw new SdkvmError(`Unknown SDK type: ${id}`);
+  return spec;
+}
+
+// src/core/paths.ts
+function sdkvmHome() {
+  return envOverride("SDKVM_HOME", "JVM_HOME") ?? path3.join(os.homedir(), ".sdkvm");
+}
+var paths = {
+  root: sdkvmHome,
+  /** 各 SDK 类型的安装根（~/.sdkvm/jdks 等） */
+  sdks: (type) => path3.join(sdkvmHome(), getSdkType(type).installDirName),
+  /** 各 SDK 类型的 current 链接（~/.sdkvm/current-java 等） */
+  current: (type) => path3.join(sdkvmHome(), getSdkType(type).currentLinkName),
+  cache: () => path3.join(sdkvmHome(), "cache"),
+  tmp: () => path3.join(sdkvmHome(), "tmp"),
+  config: () => path3.join(sdkvmHome(), "config.json"),
+  lock: () => path3.join(sdkvmHome(), ".lock")
+};
+function ensureLayout() {
+  const dirs = [sdkvmHome(), ...SDK_TYPES.map((t) => paths.sdks(t)), paths.cache(), paths.tmp()];
+  for (const dir of dirs) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/core/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  defaultVendor: "temurin",
+  mirror: {}
+};
+function loadConfig() {
+  const file = paths.config();
+  if (!fs4.existsSync(file)) return { ...DEFAULT_CONFIG, mirror: {} };
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+    const config = {
+      version: 1,
+      defaultVendor: parsed.defaultVendor && JAVA_VENDOR_IDS.includes(parsed.defaultVendor) ? parsed.defaultVendor : "temurin",
+      mirror: {}
+    };
+    if (parsed.mirror && typeof parsed.mirror === "object") {
+      for (const [id, v] of Object.entries(parsed.mirror)) {
+        if (typeof v === "string" && v.length > 0) config.mirror[id] = v;
+      }
+    }
+    return config;
+  } catch (err) {
+    const bak = `${file}.bak`;
+    try {
+      fs4.renameSync(file, bak);
+      log.warn(`config.json was corrupted; backed up to ${bak}, using defaults`);
+    } catch {
+    }
+    void err;
+    return { ...DEFAULT_CONFIG, mirror: {} };
+  }
+}
+function saveConfig(config) {
+  ensureLayout();
+  const file = paths.config();
+  const tmp = path4.join(path4.dirname(file), `.config.json.tmp-${process.pid}`);
+  fs4.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`);
+  fs4.renameSync(tmp, file);
+}
+
+// src/core/lock.ts
+import fs5 from "fs";
+var STALE_MS = 5 * 60 * 1e3;
+function acquireLock() {
+  const lockDir = paths.lock();
+  fs5.mkdirSync(paths.root(), { recursive: true });
+  try {
+    fs5.mkdirSync(lockDir);
+    fs5.writeFileSync(
+      `${lockDir}/info.json`,
+      JSON.stringify({ pid: process.pid, startedAt: Date.now() })
+    );
+  } catch (err) {
+    const e = err;
+    if (e.code === "EEXIST") {
+      const stat = fs5.statSync(lockDir);
+      if (Date.now() - stat.mtimeMs > STALE_MS) {
+        fs5.rmSync(lockDir, { recursive: true, force: true });
+        return acquireLock();
+      }
+      throw new SdkvmError("Another sdkvm operation is in progress", {
+        hint: "If this is wrong, remove ~/.sdkvm/.lock manually."
+      });
+    }
+    throw e;
+  }
+}
+function releaseLock() {
+  fs5.rmSync(paths.lock(), { recursive: true, force: true });
+}
+async function withLock(fn) {
+  acquireLock();
+  try {
+    return await fn();
+  } finally {
+    releaseLock();
+  }
+}
+
+// src/vendor/mirror.ts
+function applyMirror(artifact, platform, mirrorRoot) {
+  if (!mirrorRoot) return artifact;
+  if (artifact.vendorId === "golang") {
+    const root2 = mirrorRoot.replace(/\/+$/, "");
+    const file = artifact.downloadUrl.split("/").pop();
+    if (!file) return artifact;
+    return { ...artifact, downloadUrl: `${root2}/${file}` };
+  }
+  if (artifact.vendorId === "flutter") {
+    const root2 = mirrorRoot.replace(/\/+$/, "");
+    const url2 = artifact.downloadUrl.replace(
+      /^https:\/\/storage\.googleapis\.com\/flutter_infra_release/,
+      root2
+    );
+    return { ...artifact, downloadUrl: url2 };
+  }
+  if (artifact.vendorId !== "temurin") return artifact;
+  const m = /^https:\/\/github\.com\/adoptium\/temurin(\d+)-binaries\/releases\/download\/[^/]+\/(.+)$/.exec(
+    artifact.downloadUrl
+  );
+  if (!m || !m[1] || !m[2]) return artifact;
+  const root = mirrorRoot.replace(/\/+$/, "");
+  const url = `${root}/${m[1]}/jdk/${platform.arch}/${platform.os}/${m[2]}`;
+  return { ...artifact, downloadUrl: url };
+}
+
+// src/net/download.ts
+import crypto from "crypto";
+import fs6 from "fs";
+import path5 from "path";
+var IDLE_TIMEOUT_MS = 6e4;
+async function downloadFile(url, destFile, onProgress) {
+  const partFile = `${destFile}.part`;
+  const hash = crypto.createHash("sha256");
+  const out = fs6.createWriteStream(partFile);
+  let bytes = 0;
+  let total = null;
+  let stalled = false;
+  const ac = new AbortController();
+  const timer = setTimeout(() => {
+    stalled = true;
+    ac.abort();
+  }, IDLE_TIMEOUT_MS);
+  try {
+    const res = await httpFetch(url, { signal: ac.signal });
+    timer.refresh();
+    total = Number(res.headers.get("content-length")) || null;
+    if (!res.body) throw new SdkvmError(`Empty response body: ${url}`);
+    for await (const chunk of res.body) {
+      timer.refresh();
+      out.write(chunk);
+      hash.update(chunk);
+      bytes += chunk.byteLength;
+      onProgress?.(bytes, total);
+    }
+    await new Promise((resolve, reject) => {
+      out.end((err) => err ? reject(err) : resolve());
+    });
+  } catch (err) {
+    await new Promise((resolve) => {
+      out.once("close", resolve);
+      out.destroy();
+    });
+    fs6.rmSync(partFile, { force: true });
+    if (stalled) {
+      throw new SdkvmError(`Download stalled: no data for ${IDLE_TIMEOUT_MS / 1e3}s (${bytes} bytes so far)`, {
+        hint: url
+      });
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (bytes === 0) {
+    fs6.rmSync(partFile, { force: true });
+    throw new SdkvmError(`Download incomplete: 0 bytes`, { hint: url });
+  }
+  if (total !== null && bytes !== total) {
+    fs6.rmSync(partFile, { force: true });
+    throw new SdkvmError(`Download incomplete: ${bytes}/${total} bytes`, { hint: url });
+  }
+  fs6.renameSync(partFile, destFile);
+  return { file: destFile, sha256: hash.digest("hex"), bytes };
+}
+function cacheFileName(url) {
+  const safe = path5.basename(new URL(url).pathname).replace(/[^\w.+-]/g, "_");
+  return safe || `download-${Date.now()}`;
+}
+
+// src/net/checksum.ts
+var HEX64 = /^[0-9a-f]{64}$/i;
+function extractExpectedChecksum(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.checksum && HEX64.test(obj.checksum)) return obj.checksum.toLowerCase();
+    } catch {
+    }
+    return null;
+  }
+  const token = trimmed.split(/\s+/)[0] ?? "";
+  return HEX64.test(token) ? token.toLowerCase() : null;
+}
+async function verifyChecksum(artifact, actual) {
+  const info = artifact.checksum;
+  if (!info) {
+    log.warn(`no checksum source for ${artifact.displayName}, skipping verification`);
+    return;
+  }
+  let expected = info.expected?.toLowerCase() ?? null;
+  if (!expected && info.url) {
+    try {
+      expected = extractExpectedChecksum(await httpText(info.url));
+    } catch {
+      log.warn(`cannot fetch checksum for ${artifact.displayName}, skipping verification`);
+      return;
+    }
+  }
+  if (!expected) {
+    log.warn(`checksum source has no valid hash for ${artifact.displayName}, skipping`);
+    return;
+  }
+  if (expected !== actual.toLowerCase()) {
+    throw new SdkvmError(`Checksum mismatch for ${artifact.displayName}`, {
+      hint: `expected ${expected}, got ${actual}`
+    });
+  }
+}
+
+// src/fs/extract.ts
+import fs7 from "fs";
+import path6 from "path";
+
+// src/util/spawn.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function run(cmd, args, opts = {}) {
+  try {
+    return await execFileAsync(cmd, args, {
+      cwd: opts.cwd,
+      windowsHide: true,
+      maxBuffer: 32 * 1024 * 1024
+    });
+  } catch (err) {
+    const e = err;
+    const detail = (e.stderr || e.message || "").split("\n")[0];
+    throw new SdkvmError(`Failed to run ${cmd}: ${detail}`, {
+      hint: `args: ${args.join(" ")}`
+    });
+  }
+}
+
+// src/fs/extract.ts
+var WIN_TAR = "C:\\Windows\\System32\\tar.exe";
+async function extractArchive(archiveFile, archiveType, destDir, platform) {
+  fs7.mkdirSync(destDir, { recursive: true });
+  if (platform.os === "windows") {
+    if (fs7.existsSync(WIN_TAR)) {
+      await run(WIN_TAR, ["-xf", archiveFile, "-C", destDir]);
+    } else {
+      await run("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -LiteralPath '${archiveFile.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force`
+      ]);
+    }
+    return;
+  }
+  if (archiveType === "zip" && platform.rawPlatform === "linux") {
+    await run("unzip", ["-q", "-o", archiveFile, "-d", destDir]);
+    return;
+  }
+  await run("tar", ["-xf", archiveFile, "-C", destDir]);
+}
+function tmpExtractDir(base) {
+  return path6.join(base, `extract-${Date.now()}-${process.pid}`);
+}
+
+// src/fs/layout.ts
+import fs8 from "fs";
+import path7 from "path";
+function normalizeExtracted(tmpDir, platform, type) {
+  const spec = getSdkType(type);
+  const entries = fs8.readdirSync(tmpDir).filter((e) => e !== "._" && !e.startsWith("._"));
+  const real = entries.filter((e) => e !== ".DS_Store");
+  let root;
+  if (real.length === 1 && fs8.statSync(path7.join(tmpDir, real[0])).isDirectory()) {
+    root = path7.join(tmpDir, real[0]);
+  } else {
+    root = tmpDir;
+  }
+  const home = spec.locateHome(root);
+  const bin = path7.join(home, spec.binRelPath(platform));
+  if (!fs8.existsSync(bin)) {
+    throw new SdkvmError(`Archive does not look like a valid ${spec.label} (bin not found)`, {
+      hint: `expected ${bin}`
+    });
+  }
+  return { root, home };
+}
+
+// src/ui/progress.ts
+var WIDTH = 26;
+function humanBytes(n) {
+  if (n < 1024) return `${n}B`;
+  const units = ["KB", "MB", "GB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(1)}${units[i]}`;
+}
+function createProgress(label2) {
+  const isTty = process.stderr.isTTY === true;
+  let lastLine = 0;
+  return {
+    update(bytes, total) {
+      if (isTty) {
+        const ratio = total ? Math.min(1, bytes / total) : null;
+        const bar = ratio === null ? humanBytes(bytes) : `${"\u2588".repeat(Math.round(ratio * WIDTH))}${"\u2591".repeat(WIDTH - Math.round(ratio * WIDTH))} ${(ratio * 100).toFixed(1)}%`;
+        process.stderr.write(`\r${label2} ${bar}`.padEnd(72));
+      } else if (bytes - lastLine >= 16 * 1024 * 1024) {
+        lastLine = bytes;
+        process.stderr.write(`${label2} ${humanBytes(bytes)}${total ? ` / ${humanBytes(total)}` : ""}
+`);
+      }
+    },
+    done(bytes, total) {
+      if (isTty) {
+        process.stderr.write(`\r${label2} ${humanBytes(bytes)}${total ? ` / ${humanBytes(total)}` : ""} \u2713
+`);
+      } else if (bytes - lastLine >= 0) {
+        process.stderr.write(`${label2} ${humanBytes(bytes)} complete
+`);
+      }
+    }
+  };
+}
+
+// src/cli/install.ts
+async function installCommand(type, specInput, opts) {
+  const platform = detectPlatform();
+  const config = loadConfig();
+  const { vendor: specVendor, spec } = getSdkType(type).parseUserSpec(specInput);
+  const vendorId = resolveVendorId(type, specVendor ?? opts.vendor, config);
+  const vendor = getVendor(type, vendorId);
+  log.info(`resolving ${vendor.label} ${specInput} for ${platform.os}/${platform.arch} ...`);
+  const resolved = await vendor.resolve(spec, platform);
+  const mirrorRoot = envOverride("SDKVM_MIRROR", "JVM_MIRROR") ?? config.mirror[vendorId] ?? null;
+  const artifact = applyMirror(resolved, platform, mirrorRoot);
+  const finalDir = path8.join(paths.sdks(type), artifact.dirName);
+  const hintVersion = type === "java" ? String(artifact.version.major) : `${artifact.version.major}.${artifact.version.minor}`;
+  if (fs9.existsSync(finalDir)) {
+    if (!opts.force) {
+      log.warn(`${artifact.displayName} is already installed`);
+      log.info(`run: ${cmdPath(type)} use ${hintVersion}`);
+      return;
+    }
+    log.warn(`--force: removing existing ${artifact.dirName}`);
+  }
+  await withLock(async () => {
+    ensureLayout();
+    for (const f of fs9.readdirSync(paths.cache())) {
+      if (f.endsWith(".part")) fs9.rmSync(path8.join(paths.cache(), f), { force: true });
+    }
+    const dest = path8.join(paths.cache(), cacheFileName(artifact.downloadUrl));
+    const progress = createProgress(`\u2193 ${artifact.displayName}`);
+    log.info(`downloading ${artifact.downloadUrl}`);
+    const dl = await downloadFile(artifact.downloadUrl, dest, (b, t) => progress.update(b, t));
+    progress.done(dl.bytes, null);
+    await verifyChecksum(artifact, dl.sha256);
+    const tmp = tmpExtractDir(paths.tmp());
+    let finalTmp = tmp;
+    try {
+      log.info("extracting ...");
+      await extractArchive(dest, artifact.archive, tmp, platform);
+      const normalized = normalizeExtracted(tmp, platform, type);
+      finalTmp = normalized.root;
+      if (fs9.existsSync(finalDir)) fs9.rmSync(finalDir, { recursive: true, force: true });
+      fs9.renameSync(normalized.root, finalDir);
+    } catch (err) {
+      fs9.rmSync(finalTmp, { recursive: true, force: true });
+      fs9.rmSync(tmp, { recursive: true, force: true });
+      throw err instanceof SdkvmError ? err : err;
+    } finally {
+      fs9.rmSync(dest, { force: true });
+      fs9.rmSync(paths.tmp(), { recursive: true, force: true });
+      fs9.mkdirSync(paths.tmp(), { recursive: true });
+    }
+  });
+  log.ok(`installed ${artifact.displayName} \u2192 ${finalDir}`);
+  log.info(`switch to it: ${cmdPath(type)} use ${hintVersion}`);
+}
+
+// src/cli/use.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import path14 from "path";
+
+// src/core/registry.ts
+import fs11 from "fs";
+import path10 from "path";
+
+// src/fs/link.ts
+import fs10 from "fs";
+import path9 from "path";
+function setCurrent(type, target, platform) {
+  const link = paths.current(type);
+  if (platform.os === "windows") {
+    try {
+      fs10.rmSync(link, { force: true });
+    } catch {
+      fs10.rmSync(link, { recursive: true, force: true });
+    }
+    fs10.symlinkSync(target, link, "junction");
+    return;
+  }
+  const tmp = `${link}.tmp-${process.pid}`;
+  fs10.rmSync(tmp, { force: true });
+  fs10.symlinkSync(target, tmp);
+  fs10.renameSync(tmp, link);
+}
+function readCurrent(type) {
+  const link = paths.current(type);
+  try {
+    const st = fs10.lstatSync(link);
+    if (!st.isSymbolicLink()) return null;
+    const raw = fs10.readlinkSync(link);
+    return path9.resolve(path9.dirname(link), raw);
+  } catch {
+    return null;
+  }
+}
+function clearCurrent(type) {
+  const link = paths.current(type);
+  try {
+    fs10.rmSync(link, { force: true });
+  } catch {
+    fs10.rmSync(link, { recursive: true, force: true });
+  }
+}
+
+// src/core/registry.ts
+function listInstalled(type) {
+  const spec = getSdkType(type);
+  const root = paths.sdks(type);
+  if (!fs11.existsSync(root)) return [];
+  const result = [];
+  for (const name of fs11.readdirSync(root)) {
+    const version = spec.parseDirName(name);
+    if (!version) continue;
+    const dirPath = path10.join(root, name);
+    if (!fs11.statSync(dirPath).isDirectory()) continue;
+    result.push({ type, version, dirPath, home: spec.locateHome(dirPath) });
+  }
+  result.sort((a, b) => spec.compareVersions(a.version, b.version));
+  return result;
+}
+function currentSdk(type) {
+  const current = readCurrent(type);
+  if (!current) return null;
+  return listInstalled(type).find(
+    (j) => j.home === current || j.dirPath === current || current.startsWith(j.dirPath + path10.sep)
+  ) ?? null;
+}
+function findInstalled(type, specInput, vendorArg) {
+  const spec = getSdkType(type);
+  const { vendor: specVendor, spec: parsed } = spec.parseUserSpec(specInput);
+  const vendor = vendorArg ?? specVendor;
+  const all = listInstalled(type);
+  const candidates = vendor ? all.filter((j) => j.version.vendor === vendor) : all;
+  let matched;
+  if (parsed.kind === "major") {
+    matched = candidates.filter((j) => j.version.major === parsed.major);
+  } else if (parsed.kind === "line") {
+    matched = candidates.filter(
+      (j) => j.version.major === parsed.major && j.version.minor === parsed.minor
+    );
+  } else if (parsed.kind === "lts") {
+    if (!spec.supportsLts) {
+      throw new SdkvmError("Go has no LTS releases", {
+        hint: `Try: ${cmdPath(type)} install latest`
+      });
+    }
+    matched = candidates.filter((j) => LTS_MAJORS.has(j.version.major));
+  } else if (parsed.kind === "latest") {
+    matched = candidates;
+  } else {
+    const v = parsed.version;
+    matched = candidates.filter((j) => {
+      const f = spec.formatVersion(j.version);
+      return f === v || f.startsWith(`${v}+`) || f.startsWith(`${v}.`);
+    });
+  }
+  if (matched.length === 0) {
+    const installedList = all.map((j) => `  ${j.version.vendor}-${spec.formatVersion(j.version)}`).join("\n");
+    const want = parsed.kind === "full" ? parsed.version : specInput;
+    throw new SdkvmError(`No installed ${spec.label} matches "${specInput}"`, {
+      hint: (all.length > 0 ? `Installed:
+${installedList}
+` : "") + `Install one first: ${cmdPath(type)} install ${want}`
+    });
+  }
+  return matched[matched.length - 1];
+}
+
+// src/shell/detect.ts
+import os2 from "os";
+import path11 from "path";
+function detectRcFile(platform) {
+  if (platform === "windows") return null;
+  const shell = process.env.SHELL ?? "";
+  const base = path11.basename(shell);
+  const home = os2.homedir();
+  if (base === "zsh" || base === "-zsh") return path11.join(home, ".zshrc");
+  if (base === "bash" || base === "-bash") {
+    return platform === "mac" ? path11.join(home, ".bash_profile") : path11.join(home, ".bashrc");
+  }
+  if (base === "fish") return null;
+  return null;
+}
+
+// src/shell/rc.ts
+import fs12 from "fs";
+import os3 from "os";
+import path12 from "path";
+var LEGACY_RC_BEGIN = "# >>> jvm init >>>";
+var LEGACY_RC_END = "# <<< jvm init <<<";
+function rcBegin(type) {
+  return `# >>> ${CLI_BIN} ${type} init >>>`;
+}
+function rcEnd(type) {
+  return `# <<< ${CLI_BIN} ${type} init <<<`;
+}
+function rcBlock(type) {
+  const spec = getSdkType(type);
+  const abs = paths.current(type);
+  const rel = path12.relative(os3.homedir(), abs);
+  const link = rel.startsWith("..") ? abs : `$HOME/${rel}`;
+  return [
+    rcBegin(type),
+    `export ${spec.envVar}="${link}"`,
+    `case ":$PATH:" in *":$${spec.envVar}/bin:"*) ;; *) export PATH="$${spec.envVar}/bin:$PATH";; esac`,
+    rcEnd(type)
+  ].join("\n");
+}
+function stripRcBlock(content, type) {
+  return stripBlockBetween(content, rcBegin(type), rcEnd(type));
+}
+function stripLegacyRcBlock(content) {
+  return stripBlockBetween(content, LEGACY_RC_BEGIN, LEGACY_RC_END);
+}
+function stripBlockBetween(content, begin, end) {
+  const re = new RegExp(`\\n*${escapeRegex(begin)}[\\s\\S]*?${escapeRegex(end)}\\n*`, "g");
+  return content.replace(re, "\n");
+}
+function upsertRcContent(content, type) {
+  const stripped = stripLegacyRcBlock(stripRcBlock(content, type)).replace(/\s+$/, "");
+  return `${stripped}
+
+${rcBlock(type)}
+`;
+}
+function upsertRcFile(file, type) {
+  const content = fs12.existsSync(file) ? fs12.readFileSync(file, "utf8") : "";
+  fs12.writeFileSync(file, upsertRcContent(content, type));
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/shell/winenv.ts
+import os4 from "os";
+import path13 from "path";
+function encoded(ps) {
+  return ["-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(ps, "utf16le").toString("base64")];
+}
+function currentLinkWin(type) {
+  const rel = path13.relative(os4.homedir(), paths.current(type));
+  return `%USERPROFILE%\\${rel.split(path13.sep).join("\\")}`;
+}
+async function setEnvWin(name, value) {
+  await run("setx", [name, value]);
+}
+async function setSdkEnvWin(type) {
+  const spec = getSdkType(type);
+  await setEnvWin(spec.envVar, currentLinkWin(type));
+}
+async function ensureUserPathWin(entry) {
+  const ps = [
+    "$k=[Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment',$true)",
+    "if(-not $k){ throw 'no Environment key' }",
+    "$fmt=[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames",
+    "$raw=[string]$k.GetValue('Path','',$fmt)",
+    "$parts=@($raw -split ';' | Where-Object { $_ -ne '' })",
+    `if($parts -notcontains '${entry.replace(/'/g, "''")}'){`,
+    `  $parts += '${entry.replace(/'/g, "''")}'`,
+    "  $kind=[Microsoft.Win32.RegistryValueKind]::ExpandString",
+    "  if($k.GetValueKind('Path') -eq [Microsoft.Win32.RegistryValueKind]::String){ $kind=[Microsoft.Win32.RegistryValueKind]::String }",
+    "  $k.SetValue('Path', ($parts -join ';'), $kind)",
+    "}",
+    `$sig='[DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)] public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam, uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);'`,
+    "Add-Type -MemberDefinition $sig -Name NativeMethods -Namespace Win32",
+    "$r=[UIntPtr]::Zero",
+    "[Win32.NativeMethods]::SendMessageTimeout([IntPtr]0xffff, 0x1A, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$r) | Out-Null"
+  ].join("\n");
+  await run("powershell.exe", encoded(ps));
+}
+function sdkPathEntry(type) {
+  return `%${getSdkType(type).envVar}%\\bin`;
+}
+
+// src/cli/use.ts
+var execFileAsync2 = promisify2(execFile2);
+async function showSdkVersion(binPath, type) {
+  const spec = getSdkType(type);
+  try {
+    const { stdout, stderr } = await execFileAsync2(binPath, spec.versionCheck.args, {
+      timeout: 3e4
+    });
+    const text = spec.versionCheck.stream === "stdout" ? stdout : stderr;
+    const line = (text || "").split("\n").find((l) => l.includes("version"));
+    if (line) log.info(line.trim());
+  } catch {
+  }
+}
+async function useCommand(type, specInput, opts) {
+  const platform = detectPlatform();
+  const spec = getSdkType(type);
+  const installed = findInstalled(type, specInput, opts.vendor);
+  const label2 = `${installed.version.vendor}-${spec.formatVersion(installed.version)}`;
+  setCurrent(type, installed.home, platform);
+  log.ok(`current \u2192 ${label2}`);
+  if (platform.os === "windows") {
+    await setSdkEnvWin(type);
+    await ensureUserPathWin(sdkPathEntry(type));
+    log.info(`${spec.envVar} and PATH updated in user environment`);
+    log.warn("reopen your terminal (or restart your IDE) for the change to take effect");
+  } else {
+    const rc = detectRcFile(platform.os);
+    if (rc) {
+      upsertRcFile(rc, type);
+      log.info(`updated ${rc} \u2014 run: source ${rc} (or open a new terminal)`);
+    } else {
+      log.warn("could not detect your shell; add this to your rc file manually:");
+      console.log(rcBlock(type));
+    }
+  }
+  await showSdkVersion(path14.join(installed.home, spec.binRelPath(platform)), type);
+}
+
+// src/cli/ls.ts
+async function lsCommand(type, opts) {
+  if (opts.remote) return listRemote(type, opts);
+  listLocal(type);
+}
+function listLocal(type) {
+  const spec = getSdkType(type);
+  const installed = listInstalled(type);
+  if (installed.length === 0) {
+    log.info(`no ${spec.label} installed`);
+    log.info(`try: ${cmdPath(type)} install ${spec.supportsLts ? "lts" : "latest"}`);
+    return;
+  }
+  const current = currentSdk(type);
+  for (const j of installed) {
+    const name = `${j.version.vendor}-${spec.formatVersion(j.version)}`;
+    const marker = current?.dirPath === j.dirPath ? "\u2192" : " ";
+    log.raw(`${marker} ${name}`);
+  }
+}
+async function listRemote(type, opts) {
+  const config = loadConfig();
+  const ids = opts.vendor ? [resolveVendorId(type, opts.vendor, config)] : allVendorIds(type);
+  const sections = await Promise.all(
+    ids.map(async (id) => {
+      const vendor = getVendor(type, id);
+      try {
+        const lines = (await vendor.listMajors()).slice().sort((a, b) => b.key.localeCompare(a.key, void 0, { numeric: true }));
+        return { vendor, lines };
+      } catch (err) {
+        log.warn(`${vendor.label}: list unavailable (${toSdkvmError(err).message})`);
+        return null;
+      }
+    })
+  );
+  for (const sec of sections) {
+    if (!sec || sec.lines.length === 0) continue;
+    const { vendor, lines } = sec;
+    log.raw("");
+    log.raw(`# ${vendor.label}`);
+    const width = Math.max(...lines.map((m) => `${vendor.id}-${m.key}`.length)) + 2;
+    const MAX_LINES = 12;
+    const shown = lines.slice(0, MAX_LINES);
+    for (const m of shown) {
+      const name = `${vendor.id}-${m.key}`.padEnd(width);
+      const lts = m.lts ? "(lts) " : "";
+      const latest = m.latestFullVersion ? `latest: ${vendor.id}-${m.latestFullVersion}` : "";
+      log.raw(`  ${name}${lts}${latest}`.trimEnd());
+    }
+    if (lines.length > shown.length) {
+      log.raw(`  # note: ${lines.length - shown.length} older version lines hidden; install older ones by exact name, e.g. ${vendor.id}-${lines[lines.length - 1]?.key}`);
+    }
+    if (!vendor.supportsFullVersionList) {
+      const first = lines[0]?.key ?? "";
+      log.raw(`  # note: no version-list API; install resolves to the latest patch, e.g. ${cmdPath(type)} install ${vendor.id}-${first}`);
+    }
+  }
+  log.raw("");
+  log.raw(`# install with: ${cmdPath(type)} install <name>`);
+}
+function currentCommand(types = SDK_TYPES) {
+  let any = false;
+  for (const type of types) {
+    const spec = getSdkType(type);
+    const current = currentSdk(type);
+    if (!current) continue;
+    any = true;
+    log.raw(`${type}: ${current.version.vendor}-${spec.formatVersion(current.version)}`);
+    log.raw(`  ${spec.envVar} \u2192 ${current.home}`);
+  }
+  if (!any) {
+    log.info("no current SDK");
+    log.info(`run: ${cmdPath("java")} use <version>   (see: ${cmdPath("java")} ls)`);
+  }
+}
+
+// src/cli/uninstall.ts
+import fs13 from "fs";
+async function uninstallCommand(type, specInput, opts) {
+  const spec = getSdkType(type);
+  const installed = findInstalled(type, specInput, opts.vendor);
+  await withLock(async () => {
+    if (currentSdk(type)?.dirPath === installed.dirPath) {
+      clearCurrent(type);
+      log.warn(`uninstalled the current ${spec.label}; ${spec.envVar} is now dangling`);
+      log.info(`select another: ${cmdPath(type)} use <version>`);
+    }
+    fs13.rmSync(installed.dirPath, { recursive: true, force: true });
+  });
+  log.ok(`removed ${installed.version.vendor}-${spec.formatVersion(installed.version)}`);
+}
+
+// src/cli/mirror.ts
+var RECOMMENDED = {
+  temurin: "https://mirrors.nju.edu.cn/adoptium",
+  golang: "https://golang.google.cn/dl",
+  flutter: "https://mirror.nju.edu.cn/flutter/flutter_infra_release"
+};
+function mirrorCommand(type, action, urlOrVendor, maybeUrl) {
+  const config = loadConfig();
+  const mirrorable = allVendorIds(type).filter((id) => id in RECOMMENDED);
+  const first = mirrorable[0] ?? allVendorIds(type)[0] ?? "";
+  if (action === "set") {
+    let vendor;
+    let url;
+    if (maybeUrl !== void 0) {
+      vendor = urlOrVendor ?? "";
+      url = maybeUrl;
+    } else {
+      vendor = first;
+      url = urlOrVendor;
+    }
+    if (!url) throw new SdkvmError(`usage: ${cmdPath(type)} mirror set [vendor] <url>`);
+    if (!mirrorable.includes(vendor)) {
+      throw new SdkvmError(`mirroring is only supported for ${mirrorable.join(", ") || "none"} (got "${vendor}")`, {
+        hint: `recommended: ${cmdPath(type)} mirror set ${first} ${RECOMMENDED[first] ?? ""}`.trim()
+      });
+    }
+    try {
+      new URL(url);
+    } catch {
+      throw new SdkvmError(`invalid URL: ${url}`);
+    }
+    config.mirror[vendor] = url.replace(/\/+$/, "");
+    saveConfig(config);
+    log.ok(`mirror for ${vendor} \u2192 ${config.mirror[vendor]}`);
+    return;
+  }
+  if (action === "unset") {
+    const vendor = urlOrVendor ?? first;
+    if (!mirrorable.includes(vendor)) {
+      throw new SdkvmError(`mirroring is only supported for ${mirrorable.join(", ") || "none"}`);
+    }
+    config.mirror[vendor] = null;
+    saveConfig(config);
+    log.ok(`mirror for ${vendor} cleared (official source)`);
+    return;
+  }
+  log.raw("mirrors:");
+  for (const id of allVendorIds(type)) {
+    const url = config.mirror[id];
+    log.raw(`  ${id.padEnd(8)} ${url ?? "(official)"}`);
+  }
+  if (first in RECOMMENDED) {
+    log.raw(`recommended for CN users: ${cmdPath(type)} mirror set ${first} ${RECOMMENDED[first]}`);
+  }
+}
+
+// src/core/migrate.ts
+import fs14 from "fs";
+import os5 from "os";
+import path15 from "path";
+async function migrateLegacyHomeIfNeeded(opts = {}) {
+  const oldHome = opts.oldHome ?? path15.join(os5.homedir(), ".jvm");
+  const newHome = opts.newHome ?? sdkvmHome();
+  if (opts.newHome === void 0 && envOverride("SDKVM_HOME", "JVM_HOME")) return "not-needed";
+  if (!fs14.existsSync(oldHome)) return "not-needed";
+  if (fs14.existsSync(newHome)) {
+    log.warn(`found both ${oldHome} and ${newHome}; keeping ${newHome}, not merging`);
+    log.warn(`move SDKs into ${newHome} manually if needed, then remove ${oldHome}`);
+    return "conflict";
+  }
+  const platform = opts.platform ?? detectPlatform();
+  const rc = opts.rcFile !== void 0 ? opts.rcFile : detectRcFile(platform.os);
+  const oldLock = path15.join(oldHome, ".lock");
+  if (fs14.existsSync(oldLock)) {
+    const stat = fs14.statSync(oldLock);
+    if (Date.now() - stat.mtimeMs <= 5 * 60 * 1e3) {
+      log.warn("another sdkvm operation seems in progress; skipping migration this run");
+      return "not-needed";
+    }
+  }
+  fs14.renameSync(oldHome, newHome);
+  const prevHome = process.env.SDKVM_HOME;
+  process.env.SDKVM_HOME = newHome;
+  try {
+    await fixupAfterRename(oldHome, newHome, platform, rc);
+  } finally {
+    if (prevHome === void 0) delete process.env.SDKVM_HOME;
+    else process.env.SDKVM_HOME = prevHome;
+  }
+  log.ok(`migrated ${oldHome} \u2192 ${newHome} (your installed JDKs are untouched)`);
+  return "migrated";
+}
+async function fixupAfterRename(oldHome, newHome, platform, rc) {
+  try {
+    const oldLink = path15.join(newHome, "current");
+    let target = null;
+    try {
+      const st = fs14.lstatSync(oldLink);
+      if (st.isSymbolicLink()) {
+        target = path15.resolve(path15.dirname(oldLink), fs14.readlinkSync(oldLink));
+      }
+    } catch {
+    }
+    if (target) {
+      const newTarget = target.startsWith(oldHome) ? newHome + target.slice(oldHome.length) : target;
+      if (fs14.existsSync(newTarget)) setCurrent("java", newTarget, platform);
+    }
+    try {
+      fs14.rmSync(oldLink, { force: true });
+    } catch {
+      fs14.rmSync(oldLink, { recursive: true, force: true });
+    }
+  } catch (err) {
+    log.warn(
+      `current link not migrated (${err instanceof Error ? err.message : String(err)}); run: sdkvm java use <version>`
+    );
+  }
+  if (platform.os === "windows") {
+    try {
+      await setSdkEnvWin("java");
+    } catch (err) {
+      log.warn(`registry JAVA_HOME not updated: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (rc && fs14.existsSync(rc)) {
+    try {
+      if (fs14.readFileSync(rc, "utf8").includes(LEGACY_RC_BEGIN)) upsertRcFile(rc, "java");
+    } catch {
+      log.warn(`rc file not updated: ${rc}`);
+    }
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("sdkvm").description("SDK version manager \u2014 install & switch JDKs (Temurin / Zulu / Corretto), Go toolchains, and Flutter SDKs").version(getVersion());
+function registerSdkCommands(cmd, type) {
+  const s = getSdkType(type);
+  const isJava = type === "java";
+  const installHelp = isJava ? "21 | lts | 21.0.5 | 21.0.5+11 | temurin-21" : type === "go" ? "1.24 | 1.24.5 | latest | golang-1.24" : "3.47 | 3.47.5 | 3.49.0-0.1.pre | latest | flutter-3.47";
+  const vendorIds = s.vendors.map((v) => v.id).join(" | ");
+  cmd.command("install").description(`install a ${s.label}: ${installHelp}`).argument("<version>", "version spec (optional vendor- prefix)").option("--vendor <id>", `vendor: ${vendorIds}`).option("--force", "reinstall even if already installed").action((v, o) => installCommand(type, v, o));
+  cmd.command("use").description(`switch the current ${s.label} (updates ${s.envVar} / PATH)`).argument("<version>", `installed version, e.g. ${isJava ? "21 / temurin-21.0.5+11" : type === "go" ? "1.24 / golang-1.24.5" : "3.47 / flutter-3.47.5"}`).option("--vendor <id>", "restrict matching to a vendor").action((v, o) => useCommand(type, v, o));
+  cmd.command("ls").alias("list").description(`list installed ${s.label}s (\u2192 marks current); -r lists installable versions`).option("-r, --remote", "list installable versions from all vendors").option("--vendor <id>", "filter --remote output to one vendor").action((o) => lsCommand(type, o));
+  cmd.command("current").description(`show the current ${s.label}`).action(() => currentCommand([type]));
+  cmd.command("uninstall").description(`remove an installed ${s.label}`).argument("<version>", `installed version, e.g. ${isJava ? "21 / temurin-21.0.5+11" : type === "go" ? "1.24 / golang-1.24.5" : "3.47 / flutter-3.47.5"}`).option("--vendor <id>", "restrict matching to a vendor").action((v, o) => uninstallCommand(type, v, o));
+  cmd.command("mirror").description("show or set the download mirror").argument("[action]", "show | set | unset").argument("[vendor]", "vendor id").argument("[url]", "mirror root URL").action(
+    (a, v, u) => mirrorCommand(type, a, v, u)
+  );
+}
+registerSdkCommands(program, "java");
+var javaCmd = program.command("java").description("Java (JDK) subcommands (same as the bare commands)");
+registerSdkCommands(javaCmd, "java");
+javaCmd.action(() => javaCmd.help());
+var goCmd = program.command("go").description("Go toolchain subcommands");
+registerSdkCommands(goCmd, "go");
+goCmd.action(() => goCmd.help());
+var flutterCmd = program.command("flutter").description("Flutter SDK subcommands");
+registerSdkCommands(flutterCmd, "flutter");
+flutterCmd.action(() => flutterCmd.help());
+program.commands.find((c) => c.name() === "current")?.action(() => currentCommand());
+program.command("version").description("print sdkvm CLI version").action(versionCommand);
+program.hook("preAction", async () => {
+  await migrateLegacyHomeIfNeeded();
+});
+program.parseAsync(process.argv).catch((err) => {
+  const e = toSdkvmError(err);
+  log.error(e.message);
+  if (e.hint) log.info(e.hint);
+  process.exitCode = e.exitCode;
+});