@n-seiji/nuthatch 0.1.5 → 0.2.1

package/dist/cli-update-x0r4b4xk.js

@@ -0,0 +1,639 @@
+import {
+  isRunningAsCompiledBinary,
+  wantsJson,
+  reportFatalError,
+  VERSION
+} from "./cli-sre95k9x.js";
+import {
+  messageOf
+} from "./cli-ph0gp56k.js";
+import {
+  reportResult
+} from "./cli-dbzx9nzg.js";
+import {
+  EXIT_GENERAL_ERROR,
+  EXIT_USAGE_ERROR,
+  EXIT_SAFE_REJECTION,
+  ok,
+  fail
+} from "./cli-77yanq37.js";
+import {
+  parentDir
+} from "./cli-s5qcjcwk.js";
+
+// 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 MANAGED_TREES = [
+  "/Cellar/",
+  "/Caskroom/",
+  "/nix/store/",
+  "/aquaproj-aqua/",
+  "/aqua/pkgs/",
+  "/.proto/",
+  "/installs/"
+];
+var MISE_TREE = "/mise/installs/";
+var NODE_MODULES = "/node_modules/";
+var detectInstallMethod = (facts) => {
+  const path = facts.compiled ? facts.executablePath : facts.scriptPath;
+  if (path === null) {
+    return { kind: "other" };
+  }
+  if (path.includes(MISE_TREE)) {
+    return { kind: "mise" };
+  }
+  if (!facts.compiled) {
+    return { kind: path.includes(NODE_MODULES) ? "package-manager" : "other" };
+  }
+  const assetName = RELEASE_ASSETS.get(`${facts.platform}-${facts.arch}`);
+  if (assetName === undefined || MANAGED_TREES.some((tree) => path.includes(tree))) {
+    return { kind: "other" };
+  }
+  return {
+    kind: "standalone",
+    binaryPath: path,
+    installDir: parentDir(path),
+    assetName
+  };
+};
+var suggestedCommand = (kind) => {
+  if (kind === "mise") {
+    return ["mise", "upgrade"];
+  }
+  return kind === "package-manager" ? ["npm", "i", "-g", "@n-seiji/nuthatch@latest"] : null;
+};
+var updateHint = (kind) => {
+  const command = suggestedCommand(kind)?.join(" ");
+  if (kind === "mise") {
+    return `Update with mise: ${command}`;
+  }
+  return kind === "package-manager" ? `Update with your package manager, e.g. ${command}` : "Update hop with the tool you installed it with.";
+};
+
+// src/domain/self-update.ts
+var GITHUB_REPO = "n-seiji/nuthatch";
+var GITHUB_LATEST_RELEASE_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/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 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 isWriteDenied = (error) => error instanceof Error && ("code" in error) && (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS");
+
+// 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-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 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 !== "standalone" && !options.check) {
+    return fail(EXIT_GENERAL_ERROR, updateHint(method.kind));
+  }
+  term.logStderr("Checking for the latest release...");
+  const release = await attempt(async () => {
+    const latest = await port.latestGithubVersion();
+    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 });
+  }
+  const available = `Update available: ${base.current} -> ${base.latest}.`;
+  if (method.kind !== "standalone") {
+    term.logStderr(`${available} ${updateHint(method.kind)}`);
+    const command = suggestedCommand(method.kind);
+    return ok({
+      data: { ...base, command: command === null ? null : [...command] }
+    });
+  }
+  if (options.check) {
+    term.logStderr(`${available} "hop --update" replaces ${method.binaryPath}.`);
+    return ok({ data: base });
+  }
+  return replaceStandalone(port, term, method, base);
+};
+
+// src/infra/install-facts.ts
+import { realpath } from "node:fs/promises";
+var realpathOrSelf = async (path) => {
+  try {
+    return await realpath(path);
+  } catch {
+    return path;
+  }
+};
+var readInstallFacts = async (source) => ({
+  compiled: source.compiled,
+  executablePath: source.compiled ? await realpathOrSelf(source.execPath) : null,
+  scriptPath: source.compiled || source.argv1 === undefined ? null : await realpathOrSelf(source.argv1),
+  platform: source.platform,
+  arch: source.arch
+});
+
+// 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, dirname, join } 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 = join(dirname(target), `.${basename(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 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 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
+});
+
+// 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
+};