@n-seiji/nuthatch 0.1.4 → 0.1.7

package/dist/cli-update-7exha1em.js

@@ -0,0 +1,891 @@
+import {
+  isRunningAsCompiledBinary,
+  wantsJson,
+  reportFatalError,
+  firstExecutable,
+  VERSION
+} from "./cli-3ya15je0.js";
+import {
+  parentDir,
+  baseName,
+  absoluteCandidates,
+  splitPathEnv,
+  messageOf
+} from "./cli-qrxgkskr.js";
+import {
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_USAGE_ERROR,
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail
+} from "./cli-2bhb9p0x.js";
+
+// src/domain/install-roots.ts
+var MANAGER_ROOTS = [
+  {
+    markers: ["/Cellar/", "/Caskroom/"],
+    manager: "Homebrew",
+    update: '"brew upgrade"',
+    ownsNpmPrefix: true
+  },
+  {
+    markers: ["/nix/store/"],
+    manager: "Nix",
+    update: "Nix (the store is read-only)",
+    ownsNpmPrefix: true
+  },
+  {
+    markers: ["/aquaproj-aqua/", "/aqua/pkgs/"],
+    manager: "aqua",
+    update: "aqua",
+    ownsNpmPrefix: false
+  },
+  { markers: ["/.proto/tools/"], manager: "proto", update: "proto", ownsNpmPrefix: false }
+];
+var reasonWithin = (path, roots) => {
+  const root = roots.find(({ markers }) => markers.some((marker) => path.includes(marker)));
+  return root === undefined ? null : `installed by ${root.manager} (${path}); update it with ${root.update}`;
+};
+var managerRootReason = (binaryPath) => reasonWithin(binaryPath, MANAGER_ROOTS);
+var managerNpmPrefixReason = (prefix) => reasonWithin(prefix, MANAGER_ROOTS.filter(({ ownsNpmPrefix }) => ownsNpmPrefix));
+
+// src/domain/self-update.ts
+var NPM_PACKAGE = "@n-seiji/nuthatch";
+var NPM_PACKAGE_LATEST = `${NPM_PACKAGE}@latest`;
+var GITHUB_REPO = "n-seiji/nuthatch";
+var GITHUB_LATEST_RELEASE_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+var NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE.replace("/", "%2F")}/latest`;
+var releaseAssetUrl = (version, assetName) => `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+var VERSION_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)$/u;
+var TAG_PATTERN = /^v(?<version>\d+\.\d+\.\d+)$/u;
+var SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/iu;
+var parseVersion = (text) => {
+  const groups = VERSION_PATTERN.exec(text)?.groups;
+  if (groups?.major === undefined || groups.minor === undefined || groups.patch === undefined) {
+    throw new Error(`unrecognized version "${text}" (expected x.y.z)`);
+  }
+  return [Number(groups.major), Number(groups.minor), Number(groups.patch)];
+};
+var compareVersions = (a, b) => {
+  const [aMajor, aMinor, aPatch] = parseVersion(a);
+  const [bMajor, bMinor, bPatch] = parseVersion(b);
+  return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
+};
+var requireVersion = (text) => {
+  parseVersion(text);
+  return text;
+};
+var versionFromTag = (tag) => {
+  const version = TAG_PATTERN.exec(tag)?.groups?.version;
+  if (version === undefined) {
+    throw new Error(`unrecognized release tag "${tag}" (expected vX.Y.Z)`);
+  }
+  return version;
+};
+var parseChecksumFile = (text, assetName) => {
+  const [digest, file] = text.trim().split(/\s+/u);
+  if (digest === undefined || !SHA256_HEX_PATTERN.test(digest)) {
+    return { ok: false, reason: "is malformed" };
+  }
+  const named = file?.replace(/^\*/u, "");
+  if (named !== undefined && named !== assetName && !named.endsWith(`/${assetName}`)) {
+    return { ok: false, reason: `is for "${named}", not ${assetName}` };
+  }
+  return { ok: true, digest: digest.toLowerCase() };
+};
+var pathExecutableCandidates = (name, pathEnv, preferredDir = null) => absoluteCandidates([...preferredDir === null ? [] : [preferredDir], ...splitPathEnv(pathEnv)], name);
+var isWriteDenied = (error) => error instanceof Error && ("code" in error) && (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS");
+
+// src/domain/install-script.ts
+var NPX_MARKER = "/_npx/";
+var BUNX_MARKER = "/bunx-";
+var BUN_GLOBAL_MARKER = "/.bun/install/global/node_modules/";
+var NPM_GLOBAL_MARKER = `/lib/node_modules/${NPM_PACKAGE}/`;
+var NODE_MODULES_MARKER = `/node_modules/${NPM_PACKAGE}/`;
+var PNPM_GLOBAL_MARKER = "/pnpm/global/";
+var YARN_GLOBAL_MARKER = "/yarn/global/";
+var unsupported = (reason) => ({ kind: "unsupported", reason });
+var npmGlobalPrefixOf = (scriptPath) => {
+  const index = scriptPath.lastIndexOf(NPM_GLOBAL_MARKER);
+  return index > 0 ? scriptPath.slice(0, index) : null;
+};
+var otherNodeModulesReason = (scriptPath) => {
+  if (scriptPath.includes(PNPM_GLOBAL_MARKER)) {
+    return `installed globally with pnpm, which hop does not drive; run "pnpm add -g ${NPM_PACKAGE_LATEST}" yourself`;
+  }
+  if (scriptPath.includes(YARN_GLOBAL_MARKER)) {
+    return `installed globally with yarn, which hop does not drive; run "yarn global add ${NPM_PACKAGE_LATEST}" yourself`;
+  }
+  return "installed as a project dependency (a local node_modules); update it in that project";
+};
+var detectScriptInstall = (scriptPath, npmGlobalPrefix) => {
+  if (scriptPath.includes(NPX_MARKER)) {
+    return unsupported("running through npx, which already fetches the published version on every run");
+  }
+  if (scriptPath.includes(BUNX_MARKER)) {
+    return unsupported("running through bunx, which already fetches the published version on every run");
+  }
+  if (scriptPath.includes(BUN_GLOBAL_MARKER)) {
+    return { kind: "bun" };
+  }
+  if (npmGlobalPrefix !== null) {
+    const managedBy = managerNpmPrefixReason(npmGlobalPrefix);
+    return managedBy === null ? { kind: "npm", prefix: npmGlobalPrefix } : unsupported(managedBy);
+  }
+  if (scriptPath.includes(NODE_MODULES_MARKER)) {
+    return unsupported(otherNodeModulesReason(scriptPath));
+  }
+  return unsupported("running from a source checkout; update it with git (git pull)");
+};
+
+// src/domain/mise-tool.ts
+var MISE_WALK_LIMIT = 8;
+var HOP_BACKEND_PATTERN = /^[a-z0-9_-]+:@?n-seiji\/nuthatch$/iu;
+var HOP_TOOL_DIR_PATTERN = /(?:^|-)n-seiji-nuthatch$/iu;
+var parseMiseBackendToml = (text) => {
+  const match = /^\s*full\s*=\s*"(?<tool>[^"]+)"\s*$/mu.exec(text);
+  return match?.groups?.tool ?? null;
+};
+var parseLegacyMiseBackend = (text) => {
+  const lines = text.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  return lines.at(-1) ?? null;
+};
+var withoutToolOptions = (backend) => backend.replace(/\[[^\]]*\]$/u, "");
+var isHopBackend = (backend) => HOP_BACKEND_PATTERN.test(backend);
+var isHopToolDirName = (name) => HOP_TOOL_DIR_PATTERN.test(name);
+var ancestorDirs = (path, limit) => {
+  const dirs = [];
+  let dir = parentDir(path);
+  while (dirs.length < limit && dir !== "/" && dir !== ".") {
+    dirs.push(dir);
+    dir = parentDir(dir);
+  }
+  return dirs;
+};
+var miseToolDir = (path) => ancestorDirs(path, MISE_WALK_LIMIT).find((dir) => baseName(parentDir(dir)) === "installs") ?? null;
+
+// src/domain/install-method.ts
+var RELEASE_ASSETS = new Map([
+  ["darwin-arm64", "hop-darwin-arm64"],
+  ["darwin-x64", "hop-darwin-x64"],
+  ["linux-x64", "hop-linux-x64"]
+]);
+var releaseAssetName = (platform, arch) => RELEASE_ASSETS.get(`${platform}-${arch}`) ?? null;
+var GITHUB_BACKEND_PREFIXES = ["github:", "ubi:", "aqua:"];
+var NPM_BACKEND_PREFIX = "npm:";
+var unsupported2 = (reason) => ({
+  kind: "unsupported",
+  reason
+});
+var miseChannel = (tool) => {
+  if (tool.startsWith(NPM_BACKEND_PREFIX)) {
+    return "npm";
+  }
+  return GITHUB_BACKEND_PREFIXES.some((prefix) => tool.startsWith(prefix)) ? "github" : null;
+};
+var insideVersionManager = (dir, marker) => unsupported2(`installed under a version manager's install dir (${dir}) ${marker}; update it with the tool that installed it`);
+var detectUnmarkedToolDir = (dir, compiled) => {
+  if (isHopToolDirName(baseName(dir))) {
+    return unsupported2(`installed by mise, but its backend is unknown (no readable marker in ${dir}); run "mise upgrade" yourself`);
+  }
+  return compiled ? insideVersionManager(dir, "without a readable mise marker") : null;
+};
+var detectMise = ({ mise, compiled }) => {
+  if (mise === null) {
+    return null;
+  }
+  if (mise.backend === null) {
+    return detectUnmarkedToolDir(mise.dir, compiled);
+  }
+  const tool = withoutToolOptions(mise.backend);
+  if (!isHopBackend(tool)) {
+    return compiled ? insideVersionManager(mise.dir, `whose marker names "${tool}", not hop`) : null;
+  }
+  const channel = miseChannel(tool);
+  return channel === null ? unsupported2(`mise installed hop through "${tool}", which is neither a GitHub nor an npm backend; run "mise upgrade ${tool}" yourself`) : { kind: "mise", tool, channel };
+};
+var detectStandalone = (facts) => {
+  const { executablePath, platform, arch } = facts;
+  if (executablePath === null) {
+    return unsupported2("cannot tell where the hop binary is installed");
+  }
+  const managedBy = managerRootReason(executablePath);
+  if (managedBy !== null) {
+    return unsupported2(managedBy);
+  }
+  const assetName = releaseAssetName(platform, arch);
+  if (assetName === null) {
+    return unsupported2(`there is no prebuilt binary for ${platform}-${arch}; install with npm instead (npm i -g ${NPM_PACKAGE})`);
+  }
+  return {
+    kind: "standalone",
+    binaryPath: executablePath,
+    installDir: parentDir(executablePath),
+    assetName
+  };
+};
+var detectInstallMethod = (facts) => {
+  const mise = detectMise(facts);
+  if (mise !== null) {
+    return mise;
+  }
+  return facts.compiled ? detectStandalone(facts) : detectScriptInstall(facts.scriptPath ?? "", facts.npmGlobalPrefix);
+};
+var latestChannel = (method) => {
+  if (method.kind === "mise") {
+    return method.channel;
+  }
+  return method.kind === "standalone" ? "github" : "npm";
+};
+var upgradeCommand = (method) => {
+  if (method.kind === "mise") {
+    return ["mise", "upgrade", method.tool];
+  }
+  return method.kind === "npm" ? ["npm", "install", "-g", "--prefix", method.prefix, NPM_PACKAGE_LATEST] : ["bun", "add", "-g", NPM_PACKAGE_LATEST];
+};
+var miseDryRunCommand = (method) => [
+  "mise",
+  "upgrade",
+  "--dry-run-code",
+  method.tool
+];
+var preferredProgramDir = (method) => method.kind === "npm" ? `${method.prefix}/bin` : null;
+
+// src/commands/self-update-attempt.ts
+var attempt = async (run) => {
+  try {
+    return { ok: true, value: await run() };
+  } catch (error) {
+    return { ok: false, error };
+  }
+};
+
+// src/commands/self-update-delegated.ts
+var MISE_WOULD_NOT_UPGRADE = 0;
+var runLogged = (port, term, executable, [, ...args]) => {
+  const command = [executable, ...args];
+  term.logStderr(`Running: ${command.join(" ")}`);
+  return attempt(() => port.runCommand(command));
+};
+var miseNothingToUpgradeWarning = ({ tool }, { current, latest }) => [
+  `mise has nothing to upgrade for ${tool}, so hop stays at ${current} although ${latest} is the latest release.`,
+  "Likely causes: the version is pinned in your global mise config, a minimum_release_age setting holds the release back,",
+  `or ${tool} is not in your global mise config (hop runs mise from your home directory, so a project's mise.toml does not count).`,
+  `Run "mise upgrade --dry-run ${tool}" from your home directory to see what mise decides.`
+].join(" ");
+var runDelegated = async (port, term, method, base) => {
+  const argv = upgradeCommand(method);
+  const [program] = argv;
+  const command = argv.join(" ");
+  const executable = await port.resolveExecutable(program, preferredProgramDir(method));
+  if (executable === null) {
+    return fail(EXIT_GENERAL_ERROR, `Cannot find "${program}" on PATH. Run it yourself: ${command}`);
+  }
+  if (method.kind === "mise") {
+    const question = miseDryRunCommand(method);
+    const answer = await runLogged(port, term, executable, question);
+    if (!answer.ok) {
+      return fail(EXIT_GENERAL_ERROR, `Failed to run ${question.join(" ")}: ${messageOf(answer.error)}`);
+    }
+    if (answer.value === MISE_WOULD_NOT_UPGRADE) {
+      return ok({ data: base, warnings: [miseNothingToUpgradeWarning(method, base)] });
+    }
+  }
+  const run = await runLogged(port, term, executable, argv);
+  if (!run.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to run ${command}: ${messageOf(run.error)}`);
+  }
+  if (run.value !== 0) {
+    return fail(EXIT_GENERAL_ERROR, `${command} exited with code ${run.value}.`);
+  }
+  term.logStderr(`${command} finished; run "hop --version" to see which version you have now.`);
+  return ok({ data: { ...base, action: "delegated", command: [...argv] } });
+};
+
+// src/commands/self-update-standalone.ts
+var checksumRejection = (port, assetName, checksumText, bytes) => {
+  const expected = parseChecksumFile(checksumText, assetName);
+  if (!expected.ok) {
+    return fail(EXIT_SAFE_REJECTION, `The checksum file ${assetName}.sha256 ${expected.reason}; refusing to install an unverified binary.`);
+  }
+  const actual = port.sha256Hex(bytes);
+  if (actual !== expected.digest) {
+    return fail(EXIT_SAFE_REJECTION, `Checksum mismatch for ${assetName} (expected ${expected.digest}, got ${actual}); refusing to install it. Nothing was changed.`);
+  }
+  return null;
+};
+var replaceFailureMessage = (method, error) => isWriteDenied(error) ? `Cannot write ${method.installDir}; reinstall hop somewhere writable (install.sh uses ~/.local/bin).` : `Failed to replace ${method.binaryPath}: ${messageOf(error)}`;
+var replaceStandalone = async (port, term, method, base) => {
+  const { assetName, binaryPath } = method;
+  const checksumAsset = `${assetName}.sha256`;
+  const writable = await attempt(() => port.assertWritableDir(method.installDir));
+  if (!writable.ok) {
+    return fail(EXIT_GENERAL_ERROR, replaceFailureMessage(method, writable.error));
+  }
+  term.logStderr(`Downloading ${assetName} v${base.latest}...`);
+  const checksum = await attempt(() => port.downloadReleaseText(base.latest, checksumAsset));
+  if (!checksum.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to download ${checksumAsset}: ${messageOf(checksum.error)}`);
+  }
+  const binary = await attempt(() => port.downloadReleaseAsset(base.latest, assetName));
+  if (!binary.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to download ${assetName}: ${messageOf(binary.error)}`);
+  }
+  const rejection = checksumRejection(port, assetName, checksum.value, binary.value);
+  if (rejection !== null) {
+    return rejection;
+  }
+  term.logStderr(`Checksum verified. Replacing ${binaryPath}...`);
+  const replaced = await attempt(() => port.replaceExecutable(binaryPath, binary.value));
+  if (!replaced.ok) {
+    return fail(EXIT_GENERAL_ERROR, replaceFailureMessage(method, replaced.error));
+  }
+  term.logStderr(`Updated hop ${base.current} -> ${base.latest}.`);
+  return ok({ data: { ...base, action: "replaced" } });
+};
+
+// src/commands/self-update.ts
+var fetchLatest = (port, method) => latestChannel(method) === "npm" ? port.latestNpmVersion() : port.latestGithubVersion();
+var checkCommand = (method) => method.kind === "standalone" ? null : [...upgradeCommand(method)];
+var describeCheck = (method, base) => {
+  const how = method.kind === "standalone" ? `replaces ${method.binaryPath}` : `runs: ${upgradeCommand(method).join(" ")}`;
+  return `Update available: ${base.current} -> ${base.latest}. "hop --update" ${how}.`;
+};
+var selfUpdate = async (port, term, options) => {
+  const facts = await attempt(() => port.installFacts());
+  if (!facts.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Cannot update hop: could not tell how it was installed (${messageOf(facts.error)}).`);
+  }
+  const method = detectInstallMethod(facts.value);
+  if (method.kind === "unsupported") {
+    return fail(EXIT_GENERAL_ERROR, `Cannot update hop: ${method.reason}.`);
+  }
+  term.logStderr("Checking for the latest release...");
+  const release = await attempt(async () => {
+    const latest = await fetchLatest(port, method);
+    return {
+      latest,
+      updateAvailable: compareVersions(latest, options.currentVersion) > 0
+    };
+  });
+  if (!release.ok) {
+    return fail(EXIT_GENERAL_ERROR, `Failed to check for the latest release: ${messageOf(release.error)}`);
+  }
+  const base = {
+    current: options.currentVersion,
+    latest: release.value.latest,
+    updateAvailable: release.value.updateAvailable,
+    method: method.kind,
+    action: "none",
+    command: null
+  };
+  if (!base.updateAvailable) {
+    term.logStderr(`hop ${base.current} is up to date (latest release: ${base.latest}).`);
+    return ok({ data: base });
+  }
+  if (options.check) {
+    term.logStderr(describeCheck(method, base));
+    return ok({ data: { ...base, command: checkCommand(method) } });
+  }
+  return method.kind === "standalone" ? replaceStandalone(port, term, method, base) : runDelegated(port, term, method, base);
+};
+
+// src/infra/install-facts.ts
+import { readFile, realpath } from "node:fs/promises";
+import { join } from "node:path";
+var MISE_BACKEND_TOML = ".mise.backend.toml";
+var MISE_BACKEND_LEGACY = ".mise.backend";
+var realpathOrNull = async (path) => {
+  try {
+    return await realpath(path);
+  } catch {
+    return null;
+  }
+};
+var realpathOrSelf = async (path) => await realpathOrNull(path) ?? path;
+var readTextOrNull = async (path) => {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+};
+var readMiseBackend = async (dir) => {
+  const toml = await readTextOrNull(join(dir, MISE_BACKEND_TOML));
+  const fromToml = toml === null ? null : parseMiseBackendToml(toml);
+  if (fromToml !== null) {
+    return fromToml;
+  }
+  const legacy = await readTextOrNull(join(dir, MISE_BACKEND_LEGACY));
+  return legacy === null ? null : parseLegacyMiseBackend(legacy);
+};
+var findMiseTool = async (path) => {
+  const dir = path === null ? null : miseToolDir(path);
+  return dir === null ? null : { dir, backend: await readMiseBackend(dir) };
+};
+var verifiedNpmPrefix = async (scriptPath) => {
+  const prefix = scriptPath === null ? null : npmGlobalPrefixOf(scriptPath);
+  if (prefix === null) {
+    return null;
+  }
+  return await realpathOrNull(join(prefix, "bin", "hop")) === scriptPath ? prefix : null;
+};
+var readInstallFacts = async (source) => {
+  const executablePath = source.compiled ? await realpathOrSelf(source.execPath) : null;
+  const scriptPath = source.compiled || source.argv1 === undefined ? null : await realpathOrSelf(source.argv1);
+  return {
+    compiled: source.compiled,
+    executablePath,
+    scriptPath,
+    mise: await findMiseTool(executablePath ?? scriptPath),
+    npmGlobalPrefix: await verifiedNpmPrefix(scriptPath),
+    platform: source.platform,
+    arch: source.arch
+  };
+};
+
+// src/infra/package-manager.ts
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { basename } from "node:path";
+var STDERR_FD = 2;
+var resolveExecutable = (name, pathEnv, preferredDir = null) => firstExecutable(pathExecutableCandidates(name, pathEnv, preferredDir));
+var runCommand = (argv) => new Promise((resolve, reject) => {
+  const [program, ...args] = argv;
+  const child = spawn(program, args, {
+    cwd: homedir(),
+    stdio: ["inherit", STDERR_FD, STDERR_FD]
+  });
+  child.once("error", reject);
+  child.once("close", (code, signal) => {
+    if (code === null) {
+      reject(new Error(`${basename(program)} was killed by signal ${signal ?? "unknown"}`));
+      return;
+    }
+    resolve(code);
+  });
+});
+
+// src/infra/release-binary.ts
+import { createHash, randomBytes } from "node:crypto";
+import { constants } from "node:fs";
+import { access, open, realpath as realpath2, rename, rm } from "node:fs/promises";
+import { basename as basename2, dirname, join as join2 } from "node:path";
+var EXECUTABLE_MODE = 493;
+var TEMP_SUFFIX_BYTES = 6;
+var sha256Hex = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var removeQuietly = async (path) => {
+  try {
+    await rm(path, { force: true });
+  } catch {}
+};
+var writeDurably = async (path, bytes) => {
+  const handle = await open(path, "wx", EXECUTABLE_MODE);
+  try {
+    await handle.writeFile(bytes);
+    await handle.chmod(EXECUTABLE_MODE);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+};
+var replaceExecutable = async (path, bytes) => {
+  const target = await realpath2(path);
+  const suffix = randomBytes(TEMP_SUFFIX_BYTES).toString("hex");
+  const temp = join2(dirname(target), `.${basename2(target)}.update-${suffix}`);
+  try {
+    await writeDurably(temp, bytes);
+    await rename(temp, target);
+  } catch (error) {
+    await removeQuietly(temp);
+    throw error;
+  }
+};
+var assertWritableDir = (dir) => access(dir, constants.W_OK | constants.X_OK);
+
+// node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: undefined,
+  message: undefined,
+  abortEarly: undefined,
+  abortPipeEarly: undefined
+};
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4)
+    return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string")
+    return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean")
+    return `${input}`;
+  if (type === "object" || type === "function")
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== undefined)
+    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema)
+    dataset.typed = false;
+  if (dataset.issues)
+    dataset.issues.push(issue);
+  else
+    dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap;
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed)
+              dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== undefined)
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: undefined,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly)
+              break;
+          }
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// src/infra/capped-body.ts
+var tooLarge = (maxBytes) => new Error(`the response is larger than ${maxBytes} bytes`);
+var concatenate = (chunks, total) => {
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+};
+var readCapped = async (response, maxBytes) => {
+  const declared = Math.trunc(Number(response.headers.get("content-length") ?? ""));
+  if (declared > maxBytes) {
+    await response.body?.cancel();
+    throw tooLarge(maxBytes);
+  }
+  const chunks = [];
+  let received = 0;
+  for await (const chunk of response.body ?? []) {
+    received += chunk.length;
+    if (received > maxBytes) {
+      throw tooLarge(maxBytes);
+    }
+    chunks.push(chunk);
+  }
+  return concatenate(chunks, received);
+};
+
+// src/infra/release-http.ts
+var METADATA_TIMEOUT_MS = 15000;
+var ASSET_TIMEOUT_MS = 300000;
+var METADATA_MAX_BYTES = 1048576;
+var CHECKSUM_MAX_BYTES = 4096;
+var BINARY_MAX_BYTES = 268435456;
+var GITHUB_API_ORIGIN = "https://api.github.com/";
+var HTTP_FORBIDDEN = 403;
+var HTTP_TOO_MANY_REQUESTS = 429;
+var GithubLatestSchema = object({ tag_name: string() });
+var NpmLatestSchema = object({ version: string() });
+var DECODER = new TextDecoder;
+var send = async (fetcher, url, { headers, timeoutMs }) => {
+  try {
+    return await fetcher(url, {
+      headers,
+      redirect: "follow",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    throw new Error(`GET ${url} failed: ${messageOf(error)}`, { cause: error });
+  }
+};
+var rateLimitHint = (url, response) => {
+  const refused = response.status === HTTP_FORBIDDEN || response.status === HTTP_TOO_MANY_REQUESTS;
+  const exhausted = refused && response.headers.get("x-ratelimit-remaining") === "0";
+  return exhausted && url.startsWith(GITHUB_API_ORIGIN) ? " (the unauthenticated GitHub API rate limit was hit; try again later)" : "";
+};
+var discardBody = async (response) => {
+  try {
+    await response.body?.cancel();
+  } catch {}
+};
+var get = async (fetcher, url, options) => {
+  const response = await send(fetcher, url, options);
+  if (!response.ok) {
+    await discardBody(response);
+    throw new Error(`GET ${url} failed: HTTP ${response.status}${rateLimitHint(url, response)}`);
+  }
+  if (response.url.startsWith("http://")) {
+    await discardBody(response);
+    throw new Error(`GET ${url} failed: redirected to ${response.url}, which is not HTTPS`);
+  }
+  return response;
+};
+var readBody = async (url, read) => {
+  try {
+    return await read();
+  } catch (error) {
+    throw new Error(`GET ${url} failed while reading the response: ${messageOf(error)}`, {
+      cause: error
+    });
+  }
+};
+var getBytes = async (fetcher, url, options) => {
+  const response = await get(fetcher, url, options);
+  return await readBody(url, () => readCapped(response, options.maxBytes));
+};
+var getJson = async (fetcher, url, schema, options) => {
+  const bytes = await getBytes(fetcher, url, options);
+  const body = await readBody(url, () => JSON.parse(DECODER.decode(bytes)));
+  const parsed = safeParse(schema, body);
+  if (!parsed.success) {
+    throw new Error(`GET ${url} returned an unexpected response`);
+  }
+  return parsed.output;
+};
+var createReleaseHttp = (userAgent, fetcher = fetch) => ({
+  async latestGithubVersion() {
+    const release = await getJson(fetcher, GITHUB_LATEST_RELEASE_URL, GithubLatestSchema, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "User-Agent": userAgent
+      },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: METADATA_MAX_BYTES
+    });
+    return versionFromTag(release.tag_name);
+  },
+  async latestNpmVersion() {
+    const latest = await getJson(fetcher, NPM_LATEST_URL, NpmLatestSchema, {
+      headers: { Accept: "application/json", "User-Agent": userAgent },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: METADATA_MAX_BYTES
+    });
+    return requireVersion(latest.version);
+  },
+  async downloadReleaseAsset(version, assetName) {
+    return await getBytes(fetcher, releaseAssetUrl(version, assetName), {
+      headers: { Accept: "application/octet-stream", "User-Agent": userAgent },
+      timeoutMs: ASSET_TIMEOUT_MS,
+      maxBytes: BINARY_MAX_BYTES
+    });
+  },
+  async downloadReleaseText(version, assetName) {
+    const bytes = await getBytes(fetcher, releaseAssetUrl(version, assetName), {
+      headers: { Accept: "text/plain", "User-Agent": userAgent },
+      timeoutMs: METADATA_TIMEOUT_MS,
+      maxBytes: CHECKSUM_MAX_BYTES
+    });
+    return DECODER.decode(bytes);
+  }
+});
+
+// src/infra/self-update.ts
+var createSelfUpdatePort = ({
+  compiled,
+  version
+}) => ({
+  installFacts: () => readInstallFacts({
+    compiled,
+    execPath: process.execPath,
+    argv1: process.argv[1],
+    platform: process.platform,
+    arch: process.arch
+  }),
+  ...createReleaseHttp(`hop/${version}`),
+  sha256Hex,
+  assertWritableDir,
+  replaceExecutable,
+  resolveExecutable: (name, preferredDir) => resolveExecutable(name, process.env.PATH, preferredDir),
+  runCommand
+});
+
+// src/cli-update.ts
+var CHECK_FLAG = "--check";
+var JSON_FLAG = "--json";
+var UPDATE_FLAGS = new Set([CHECK_FLAG, JSON_FLAG]);
+var parseUpdateArgs = (tokens) => {
+  const stray = tokens.filter((token) => !UPDATE_FLAGS.has(token));
+  if (stray.length > 0) {
+    return {
+      ok: false,
+      json: wantsJson(tokens),
+      message: `Unknown argument for --update: ${stray.join(" ")}. Usage: hop --update [--check] [--json]`
+    };
+  }
+  return { ok: true, check: tokens.includes(CHECK_FLAG), json: tokens.includes(JSON_FLAG) };
+};
+var runUpdate = async (rawArgs, term) => {
+  try {
+    const parsed = parseUpdateArgs(rawArgs.slice(1));
+    if (!parsed.ok) {
+      reportResult("update", fail(EXIT_USAGE_ERROR, parsed.message), parsed.json);
+      return;
+    }
+    const port = createSelfUpdatePort({
+      compiled: isRunningAsCompiledBinary(),
+      version: VERSION
+    });
+    const result = await selfUpdate(port, term, {
+      currentVersion: VERSION,
+      check: parsed.check
+    });
+    reportResult("update", result, parsed.json);
+  } catch (error) {
+    reportFatalError("update", wantsJson(rawArgs), error);
+  }
+};
+export {
+  runUpdate
+};