@alchemy/cli 0.3.1 → 0.5.0

package/dist/chunk-56ZVYB4G.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
+
+// src/lib/colors.ts
+var forceColor = "FORCE_COLOR" in process.env && process.env.FORCE_COLOR !== "0";
+var noColor = !forceColor && ("NO_COLOR" in process.env || process.env.TERM === "dumb");
+function setNoColor(value) {
+  noColor = value;
+}
+var identity = (s) => s;
+var esc = (code) => (s) => noColor ? s : `\x1B[${code}m${s}\x1B[0m`;
+var rgb = (r, g, b) => (s) => noColor ? s : `\x1B[38;2;${r};${g};${b}m${s}\x1B[39m`;
+var bgRgb = (r, g, b) => (s) => noColor ? s : `\x1B[48;2;${r};${g};${b}m${s}\x1B[49m`;
+
+// src/lib/errors.ts
+var ErrorCode = {
+  AUTH_REQUIRED: "AUTH_REQUIRED",
+  INVALID_API_KEY: "INVALID_API_KEY",
+  NETWORK_NOT_ENABLED: "NETWORK_NOT_ENABLED",
+  INVALID_ACCESS_KEY: "INVALID_ACCESS_KEY",
+  ACCESS_KEY_REQUIRED: "ACCESS_KEY_REQUIRED",
+  APP_REQUIRED: "APP_REQUIRED",
+  ADMIN_API_ERROR: "ADMIN_API_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  RPC_ERROR: "RPC_ERROR",
+  INVALID_ARGS: "INVALID_ARGS",
+  NOT_FOUND: "NOT_FOUND",
+  RATE_LIMITED: "RATE_LIMITED",
+  PAYMENT_REQUIRED: "PAYMENT_REQUIRED",
+  SETUP_REQUIRED: "SETUP_REQUIRED",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  ErrorCode.RATE_LIMITED,
+  ErrorCode.NETWORK_ERROR
+]);
+var EXIT_CODES = {
+  AUTH_REQUIRED: 3,
+  INVALID_API_KEY: 3,
+  NETWORK_NOT_ENABLED: 3,
+  INVALID_ACCESS_KEY: 3,
+  ACCESS_KEY_REQUIRED: 3,
+  APP_REQUIRED: 3,
+  INVALID_ARGS: 2,
+  NOT_FOUND: 4,
+  RATE_LIMITED: 5,
+  NETWORK_ERROR: 6,
+  RPC_ERROR: 7,
+  ADMIN_API_ERROR: 8,
+  PAYMENT_REQUIRED: 9,
+  SETUP_REQUIRED: 3,
+  INTERNAL_ERROR: 1
+};
+var CLIError = class extends Error {
+  code;
+  hint;
+  details;
+  data;
+  constructor(code, message, hint, details, data) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+    this.hint = hint;
+    this.details = details;
+    this.data = data;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.hint && { hint: this.hint },
+        ...this.details && { details: this.details },
+        ...this.data !== void 0 && { data: this.data },
+        retryable: RETRYABLE_CODES.has(this.code)
+      }
+    };
+  }
+  format() {
+    let out = `${this.code}: ${this.message}`;
+    if (this.hint) out += `
+Hint: ${this.hint}`;
+    return out;
+  }
+};
+function errAuthRequired() {
+  return new CLIError(
+    ErrorCode.AUTH_REQUIRED,
+    "Not authenticated. Run 'alchemy auth' to log in, or set ALCHEMY_API_KEY.",
+    "alchemy auth"
+  );
+}
+function errAccessKeyRequired() {
+  return new CLIError(
+    ErrorCode.ACCESS_KEY_REQUIRED,
+    "Access key required. Set ALCHEMY_ACCESS_KEY or run 'alchemy config set access-key <key>'.",
+    "Get an access key: https://www.alchemy.com/docs/reference/admin-api/overview"
+  );
+}
+function errInvalidAPIKey(details) {
+  return new CLIError(
+    ErrorCode.INVALID_API_KEY,
+    "Invalid API key. Check your key and try again.",
+    "alchemy config set api-key <your-key>",
+    details
+  );
+}
+function errNetworkNotEnabled(network, details) {
+  const networkLabel = network.toLowerCase().replace(/_/g, "-");
+  return new CLIError(
+    ErrorCode.NETWORK_NOT_ENABLED,
+    `API key is valid, but ${networkLabel} is not enabled for this app.`,
+    void 0,
+    details
+  );
+}
+function errNetwork(detail) {
+  return new CLIError(
+    ErrorCode.NETWORK_ERROR,
+    `Network error: ${detail}`,
+    "Check your internet connection and try again."
+  );
+}
+var RPC_ERROR_HINTS = {
+  [-32700]: "Parse error. The request JSON is malformed.",
+  [-32600]: "Invalid request. Check the JSON-RPC request format.",
+  [-32601]: "Method not supported. Check the method name and ensure your plan supports it.",
+  [-32602]: "Invalid parameters. Check argument types and format.",
+  [-32603]: "Internal JSON-RPC error."
+};
+function errRPC(code, message) {
+  const hint = RPC_ERROR_HINTS[code];
+  return new CLIError(ErrorCode.RPC_ERROR, `RPC error ${code}: ${message}`, hint);
+}
+function errInvalidArgs(detail) {
+  return new CLIError(ErrorCode.INVALID_ARGS, detail);
+}
+function errNotFound(resource) {
+  return new CLIError(ErrorCode.NOT_FOUND, `Not found: ${resource}`);
+}
+function errRateLimited() {
+  return new CLIError(
+    ErrorCode.RATE_LIMITED,
+    "Rate limited. Please wait and try again.",
+    "Consider upgrading your Alchemy plan for higher rate limits."
+  );
+}
+function errInvalidAccessKey() {
+  return new CLIError(
+    ErrorCode.INVALID_ACCESS_KEY,
+    "Invalid access key. Check your key and try again.",
+    "Get an access key: https://www.alchemy.com/docs/reference/admin-api/overview"
+  );
+}
+function errAccessDenied(detail) {
+  const message = detail ? `Access denied: ${detail}` : "Access denied. Your access key may not have permission for this operation.";
+  return new CLIError(
+    ErrorCode.INVALID_ACCESS_KEY,
+    message,
+    "Check your account tier and feature access at https://dashboard.alchemy.com/"
+  );
+}
+function errAppRequired() {
+  return new CLIError(
+    ErrorCode.APP_REQUIRED,
+    "No app selected. Set an app to resolve the API key automatically.",
+    "alchemy config set app <app-id>"
+  );
+}
+function errWalletKeyRequired() {
+  return new CLIError(
+    ErrorCode.AUTH_REQUIRED,
+    "Wallet key required for x402. Set ALCHEMY_WALLET_KEY, run 'alchemy wallet generate', or use --wallet-key-file.",
+    "alchemy wallet generate"
+  );
+}
+function errAdminAPI(status, message) {
+  return new CLIError(
+    ErrorCode.ADMIN_API_ERROR,
+    `Admin API error (HTTP ${status}): ${message}`
+  );
+}
+function errSetupRequired(data) {
+  return new CLIError(
+    ErrorCode.SETUP_REQUIRED,
+    "Setup required before running in non-interactive mode.",
+    "Run 'alchemy' in a TTY for guided onboarding, or run 'alchemy setup status --json' for machine-readable remediation steps.",
+    void 0,
+    data
+  );
+}
+var replMode = false;
+function setReplMode(enabled) {
+  replMode = enabled;
+}
+function exitWithError(err) {
+  const cliErr = err instanceof CLIError ? err : new CLIError(
+    ErrorCode.INTERNAL_ERROR,
+    err instanceof Error ? err.message : String(err)
+  );
+  printError(cliErr);
+  if (replMode) {
+    throw cliErr;
+  }
+  process.exit(EXIT_CODES[cliErr.code]);
+}
+
+// src/lib/client-utils.ts
+var DEFAULT_BASE_DOMAIN = "alchemy.com";
+function getBaseDomain() {
+  if (process.env.ALCHEMY_UNSAFE_OVERRIDES === "1" && process.env.ALCHEMY_BASE_DOMAIN) {
+    return process.env.ALCHEMY_BASE_DOMAIN;
+  }
+  return DEFAULT_BASE_DOMAIN;
+}
+function isLocalhost(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+}
+function parseBaseURLOverride(envVarName) {
+  const raw = process.env[envVarName];
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw errInvalidArgs(`Invalid ${envVarName} value.`);
+  }
+  if (!isLocalhost(parsed.hostname)) {
+    throw errInvalidArgs(
+      `${envVarName} must target localhost or 127.0.0.1.`
+    );
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw errInvalidArgs(
+      `${envVarName} must use http:// or https://.`
+    );
+  }
+  if (parsed.protocol === "http:" && !isLocalhost(parsed.hostname)) {
+    throw errInvalidArgs(
+      `${envVarName} can only use non-HTTPS for localhost targets.`
+    );
+  }
+  return parsed;
+}
+var BREADCRUMB_HEADER = "alchemy-cli";
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function fetchWithTimeout(url, init) {
+  try {
+    return await fetch(url, {
+      ...init,
+      headers: {
+        ...init.headers,
+        "x-alchemy-client-breadcrumb": BREADCRUMB_HEADER
+      },
+      ...timeout && { signal: AbortSignal.timeout(timeout) }
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "TimeoutError") {
+      throw errNetwork(`Request timed out after ${timeout}ms`);
+    }
+    const message = err.message ?? String(err);
+    const causeMessage = err.cause?.message ?? "";
+    const causeCode = err.cause?.code ?? "";
+    const fullErrorText = `${message} ${causeMessage} ${causeCode}`;
+    if (/ENOTFOUND|EAI_AGAIN|getaddrinfo/i.test(fullErrorText)) {
+      try {
+        const hostname = new URL(url).hostname;
+        const networkSlug = hostname.replace(new RegExp(`\\.g\\.${escapeRegExp(getBaseDomain())}$`), "");
+        if (networkSlug !== hostname) {
+          throw errInvalidArgs(
+            `Unknown network '${networkSlug}'. Run 'alchemy network list' to see available networks.`
+          );
+        }
+      } catch (innerErr) {
+        if (innerErr instanceof CLIError) throw innerErr;
+      }
+    }
+    throw errNetwork(message);
+  }
+}
+
+// src/lib/redact.ts
+var SENSITIVE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "AUTH_REQUIRED",
+  "INVALID_API_KEY",
+  "INVALID_ACCESS_KEY",
+  "ACCESS_KEY_REQUIRED"
+]);
+function getAlchemyKeyPathMarkers() {
+  const domain = getBaseDomain();
+  return [`${domain}/v2/`, `${domain}/nft/v3/`];
+}
+function isSecretBoundaryChar(char) {
+  return char === "/" || char === "?" || char === " " || char === "	" || char === "\n" || char === "\r" || char === '"' || char === "'" || char === "`";
+}
+function redactAfterMarker(input, marker) {
+  const lower = input.toLowerCase();
+  let index = 0;
+  let cursor = 0;
+  let out = "";
+  while (index < input.length) {
+    const markerIndex = lower.indexOf(marker, index);
+    if (markerIndex === -1) break;
+    const secretStart = markerIndex + marker.length;
+    let secretEnd = secretStart;
+    while (secretEnd < input.length && !isSecretBoundaryChar(input[secretEnd])) {
+      secretEnd += 1;
+    }
+    out += input.slice(cursor, secretStart);
+    out += "[REDACTED]";
+    cursor = secretEnd;
+    index = secretEnd;
+  }
+  if (!out) return input;
+  return out + input.slice(cursor);
+}
+function redactSensitiveText(value) {
+  let redacted = value;
+  for (const marker of getAlchemyKeyPathMarkers()) {
+    redacted = redactAfterMarker(redacted, marker);
+  }
+  return redacted;
+}
+
+// src/lib/error-format.ts
+var ansi = {
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  boldRed: (s) => `\x1B[1;31m${s}\x1B[0m`,
+  dim: (s) => `\x1B[2m${s}\x1B[0m`
+};
+function toSafeErrorJSON(err) {
+  const payload = err.toJSON();
+  const error = payload.error ?? {};
+  const code = error.code ?? err.code;
+  const safeError = {
+    ...code && { code },
+    ...typeof error.message === "string" && { message: redactSensitiveText(error.message) },
+    ...typeof error.hint === "string" && { hint: redactSensitiveText(error.hint) },
+    ...typeof error.retryable === "boolean" && { retryable: error.retryable }
+  };
+  if (typeof error.details === "string" && !SENSITIVE_ERROR_CODES.has(code)) {
+    safeError.details = redactSensitiveText(error.details);
+  }
+  if (error.data !== void 0) {
+    safeError.data = error.data;
+  }
+  return {
+    error: safeError
+  };
+}
+function wrapWithPrefix(text, prefix, width) {
+  const safeWidth = Math.max(20, width - prefix.length);
+  const words = text.trim().split(/\s+/);
+  if (words.length === 0 || words.length === 1 && words[0] === "") return [prefix];
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current.length === 0) {
+      current = word;
+      continue;
+    }
+    if (current.length + 1 + word.length <= safeWidth) {
+      current += ` ${word}`;
+    } else {
+      lines.push(`${prefix}${current}`);
+      current = word;
+    }
+  }
+  if (current.length > 0) {
+    lines.push(`${prefix}${current}`);
+  }
+  return lines;
+}
+function supportsStderrStyling() {
+  return (process.stderr.isTTY || forceColor) && !noColor;
+}
+function printError(err) {
+  if (isJSONMode()) {
+    console.error(JSON.stringify(toSafeErrorJSON(err), null, 2));
+  } else {
+    const width = process.stderr.columns ?? 100;
+    const safeMessage = redactSensitiveText(err.message);
+    const safeHint = err.hint ? redactSensitiveText(err.hint) : void 0;
+    const safeDetails = err.details && !SENSITIVE_ERROR_CODES.has(err.code) ? redactSensitiveText(err.details) : void 0;
+    const detailLines = safeDetails ? safeDetails.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0) : [];
+    const lines = [`  \u2717 ${err.code}`, `  ${"\u2500".repeat(40)}`];
+    lines.push(...wrapWithPrefix(safeMessage, "  - ", width));
+    if (detailLines.length > 0) {
+      lines.push("");
+      lines.push("  - Provider:");
+      for (const line of detailLines) {
+        lines.push(...wrapWithPrefix(line, "    - ", width));
+      }
+    }
+    if (safeHint) {
+      lines.push("");
+      lines.push(...wrapWithPrefix(`Hint: ${safeHint}`, "  - ", width));
+    }
+    if (supportsStderrStyling()) {
+      const styled = [
+        `  ${ansi.red("\u2717")} ${ansi.boldRed(err.code)}`,
+        `  ${ansi.dim("\u2500".repeat(40))}`,
+        ...wrapWithPrefix(safeMessage, "  - ", width).map((line) => ansi.red(line))
+      ];
+      if (detailLines.length > 0) {
+        styled.push("");
+        styled.push(`  ${ansi.dim("- Provider:")}`);
+        for (const line of detailLines) {
+          styled.push(...wrapWithPrefix(line, "    - ", width).map((ln) => ansi.dim(ln)));
+        }
+      }
+      if (safeHint) {
+        styled.push("");
+        styled.push(
+          ...wrapWithPrefix(`Hint: ${safeHint}`, "  - ", width).map((line) => ansi.dim(line))
+        );
+      }
+      console.error(`
+${styled.join("\n")}
+`);
+      return;
+    }
+    console.error(`
+${lines.join("\n")}
+`);
+  }
+}
+function formatCommanderError(message) {
+  const jsonMode = !process.stdout.isTTY || process.argv.includes("--json");
+  const lines = message.trimEnd().split("\n").filter((line) => line.trim() !== "");
+  if (lines.length === 0) return message;
+  const [first, ...rest] = lines;
+  const detail = first.replace(/^error:\s*/i, "").trim();
+  if (jsonMode) {
+    const err = {
+      error: {
+        code: "INVALID_ARGS",
+        message: detail,
+        ...rest.length > 0 && { hint: rest.map((l) => l.trim()).join(" ") }
+      }
+    };
+    return JSON.stringify(err, null, 2) + "\n";
+  }
+  if (!supportsStderrStyling()) return message;
+  const styled = [
+    `  ${ansi.red("\u2717")} ${ansi.boldRed("Error")}`,
+    `  ${ansi.red(detail)}`,
+    ...rest.map((line) => `  ${ansi.dim(line)}`)
+  ];
+  return `
+${styled.join("\n")}
+`;
+}
+
+// src/lib/output.ts
+var forceJSON = false;
+var quiet = false;
+var verbose = false;
+var debugMode = false;
+var timeout;
+var reveal = false;
+function setFlags(opts) {
+  forceJSON = opts.json ?? false;
+  quiet = opts.quiet ?? false;
+  verbose = opts.verbose ?? false;
+  debugMode = opts.debug ?? false;
+  reveal = opts.reveal ?? false;
+  timeout = opts.timeout;
+}
+function isRevealMode() {
+  return reveal;
+}
+function isJSONMode() {
+  if (forceJSON) return true;
+  return !process.stdout.isTTY;
+}
+function printJSON(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function printHuman(humanText, jsonValue) {
+  if (isJSONMode()) {
+    printJSON(jsonValue);
+  } else {
+    process.stdout.write(humanText);
+  }
+}
+function debug(message, ...args) {
+  if (debugMode) {
+    console.error(`[debug] ${message}`, ...args);
+  }
+}
+
+export {
+  noColor,
+  setNoColor,
+  identity,
+  esc,
+  rgb,
+  bgRgb,
+  quiet,
+  verbose,
+  setFlags,
+  isRevealMode,
+  isJSONMode,
+  printJSON,
+  printHuman,
+  debug,
+  getBaseDomain,
+  isLocalhost,
+  parseBaseURLOverride,
+  fetchWithTimeout,
+  redactSensitiveText,
+  formatCommanderError,
+  ErrorCode,
+  EXIT_CODES,
+  CLIError,
+  errAuthRequired,
+  errAccessKeyRequired,
+  errInvalidAPIKey,
+  errNetworkNotEnabled,
+  errNetwork,
+  errRPC,
+  errInvalidArgs,
+  errNotFound,
+  errRateLimited,
+  errInvalidAccessKey,
+  errAccessDenied,
+  errAppRequired,
+  errWalletKeyRequired,
+  errAdminAPI,
+  errSetupRequired,
+  setReplMode,
+  exitWithError
+};

package/dist/{chunk-QDDJ3OYO.js → chunk-5X6YRTPU.js}

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
 import {
-  isInteractiveAllowed
-} from "./chunk-6XTLILDF.js";
+  isInteractiveAllowed,
+  resolveAuthToken
+} from "./chunk-T2XSNZE3.js";
+import {
+  getBaseDomain
+} from "./chunk-56ZVYB4G.js";
 
 // src/lib/networks.ts
 var TESTNET_TOKEN_RE = /(testnet|sepolia|holesky|hoodi|devnet|minato|amoy|fuji|saigon|cardona|aeneid|curtis|chiado|cassiopeia|blaze|ropsten|signet|mocha|fam|bepolia)$/i;
@@ -210,10 +214,11 @@ function toDisplayName(id) {
   return id.split("-").map((part) => tokenToName(part)).join(" ");
 }
 function toHttpsUrlTemplate(id) {
+  const domain = getBaseDomain();
   if (id === "starknet-mainnet" || id === "starknet-sepolia") {
-    return `https://${id}.g.alchemy.com/starknet/version/rpc/v0_10/{apiKey}`;
+    return `https://${id}.g.${domain}/starknet/version/rpc/v0_10/{apiKey}`;
   }
-  return `https://${id}.g.alchemy.com/v2/{apiKey}`;
+  return `https://${id}.g.${domain}/v2/{apiKey}`;
 }
 function getRPCNetworks() {
   return RPC_NETWORK_IDS.map((id) => ({
@@ -274,10 +279,14 @@ function hasAccessKeyAndApp(cfg) {
 function hasX402Wallet(cfg) {
   return cfg.x402 === true && Boolean(cfg.wallet_key_file?.trim());
 }
+function hasAuthToken(cfg) {
+  return resolveAuthToken(cfg) !== void 0;
+}
 function getSetupMethod(cfg) {
   if (hasAPIKey(cfg)) return "api_key";
   if (hasAccessKeyAndApp(cfg)) return "access_key_app";
   if (hasX402Wallet(cfg)) return "x402_wallet";
+  if (hasAuthToken(cfg)) return "auth_token";
   return null;
 }
 function isSetupComplete(cfg) {
@@ -296,8 +305,9 @@ function getSetupStatus(cfg) {
   return {
     complete: false,
     satisfiedBy: null,
-    missing: ["Provide one auth path: api-key OR access-key+app OR x402+wallet-key-file"],
+    missing: ["Provide one auth path: alchemy auth OR api-key OR access-key+app OR SIWx wallet"],
     nextCommands: [
+      "alchemy auth",
       "alchemy config set api-key <key>",
       "alchemy config set access-key <key> && alchemy config set app <app-id>",
       "alchemy wallet generate && alchemy config set x402 true"

package/dist/chunk-DUQFOLLZ.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
+import {
+  configPath
+} from "./chunk-T2XSNZE3.js";
+import {
+  esc
+} from "./chunk-56ZVYB4G.js";
+
+// src/lib/update-check.ts
+import { execFileSync } from "child_process";
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_INSTALL_COMMAND = "npm i -g @alchemy/cli";
+function cachePath() {
+  return configPath().replace(/config\.json$/, ".update-check");
+}
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(cachePath(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const p = cachePath();
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(cache), { mode: 384 });
+  } catch {
+  }
+}
+function fetchLatestVersion() {
+  try {
+    const result = execFileSync("npm", ["view", "@alchemy/cli", "version"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function semverLT(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return true;
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return false;
+  }
+  return false;
+}
+function currentVersion() {
+  return true ? "0.5.0" : "0.0.0";
+}
+function toUpdateStatus(latestVersion, checkedAt) {
+  const current = currentVersion();
+  return {
+    currentVersion: current,
+    latestVersion,
+    updateAvailable: latestVersion ? semverLT(current, latestVersion) : false,
+    installCommand: UPDATE_INSTALL_COMMAND,
+    checkedAt
+  };
+}
+function getUpdateStatus() {
+  const cache = readCache();
+  if (cache && Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+    return toUpdateStatus(cache.latest, cache.checkedAt);
+  }
+  const latest = fetchLatestVersion();
+  if (latest) {
+    const checkedAt = Date.now();
+    writeCache({ latest, checkedAt });
+    return toUpdateStatus(latest, checkedAt);
+  }
+  if (cache) {
+    return toUpdateStatus(cache.latest, cache.checkedAt);
+  }
+  return toUpdateStatus(null, null);
+}
+function getAvailableUpdate() {
+  const current = currentVersion();
+  const cache = readCache();
+  if (cache && Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+    return semverLT(current, cache.latest) ? cache.latest : null;
+  }
+  const latest = fetchLatestVersion();
+  if (latest) {
+    writeCache({ latest, checkedAt: Date.now() });
+    return semverLT(current, latest) ? latest : null;
+  }
+  return null;
+}
+function getUpdateNoticeLines(latest) {
+  const yellow = esc("33");
+  const bold = esc("1");
+  const dim = esc("2");
+  return [
+    `  ${yellow("Update available")} ${dim(currentVersion())} \u2192 ${bold(latest)}`,
+    `  Run ${bold(UPDATE_INSTALL_COMMAND)} to update`
+  ];
+}
+function printUpdateNotice(latest) {
+  process.stderr.write(`
+${getUpdateNoticeLines(latest).join("\n")}
+
+`);
+}
+
+export {
+  getUpdateStatus,
+  getAvailableUpdate,
+  getUpdateNoticeLines,
+  printUpdateNotice
+};