@verentis/cli 0.2.3 → 0.2.4

package/README.md

@@ -10,6 +10,21 @@ The Verentis CLI is three tools in one:
 npm install -g @verentis/cli
 ```
 
+## Staying up to date
+
+The CLI checks the npm registry for a newer release at most once a day (in the background, so it never
+slows a command down) and prints a one-line notice when one is available. Update in place with:
+
+```bash
+verentis update            # install the latest published version
+verentis update --check    # just report whether a newer version exists
+verentis update --to 0.3.0 # install a specific version
+```
+
+`update` detects your global package manager (npm/pnpm/yarn/bun). Silence the notice with
+`VERENTIS_NO_UPDATE_CHECK=1` (it is also skipped in CI, on non-interactive output, and with `--json`).
+Point `VERENTIS_UPDATE_REGISTRY` at a mirror if you install from a private registry.
+
 ## Sign in
 
 ```bash

package/dist/index.js

@@ -3,13 +3,14 @@ import { Command } from 'commander';
 import { mkdir, stat, writeFile, readFile, readdir, mkdtemp, rm, glob } from 'fs/promises';
 import { tmpdir, homedir } from 'os';
 import { resolve, basename, dirname, posix, join, sep, relative } from 'path';
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { generateKeyPairSync, createHash, randomUUID, randomBytes, createCipheriv, createPublicKey, verify, diffieHellman, hkdfSync, sign, createPrivateKey } from 'crypto';
 import { parse } from 'yaml';
-import { createWriteStream, createReadStream } from 'fs';
+import { createWriteStream, readFileSync, createReadStream } from 'fs';
 import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
 import * as tar from 'tar';
+import { fileURLToPath } from 'url';
 
 var configDir = () => process.env.VERENTIS_CONFIG_DIR ?? join(homedir(), ".verentis");
 var configPath = () => join(configDir(), "config.json");
@@ -192,8 +193,8 @@ async function createApiClient(overrides) {
   }
   async function credentialFor(scopes, workspaceId) {
     const cacheKey = `${workspaceId ?? ""}:${[...scopes].sort().join(" ")}`;
-    const cached = tokenCache.get(cacheKey);
-    if (cached && !isExpired(cached)) return cached;
+    const cached2 = tokenCache.get(cacheKey);
+    if (cached2 && !isExpired(cached2)) return cached2;
     const token = await mintAccessToken({ scopes, workspaceId });
     tokenCache.set(cacheKey, token);
     return token;
@@ -2482,6 +2483,271 @@ function registerSettings(program2) {
     console.log(`Setting ${key} deleted.`);
   });
 }
+var PACKAGE_NAME = "@verentis/cli";
+var cached;
+function getCliVersion() {
+  if (cached) return cached;
+  cached = readVersion() ?? "0.0.0";
+  return cached;
+}
+function readVersion() {
+  const candidates = ["../package.json", "../../package.json"];
+  for (const relative2 of candidates) {
+    try {
+      const raw = readFileSync(fileURLToPath(new URL(relative2, import.meta.url)), "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.version && (relative2 === "../package.json" || pkg.name === PACKAGE_NAME)) return pkg.version;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/update/registry.ts
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+function registryUrl() {
+  const configured = process.env.VERENTIS_UPDATE_REGISTRY ?? process.env.npm_config_registry ?? DEFAULT_REGISTRY;
+  return configured.replace(/\/+$/, "");
+}
+async function fetchLatestVersion(options = {}) {
+  const url = `${registryUrl()}/${PACKAGE_NAME.replace("/", "%2F")}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 3e3);
+  try {
+    const res = await fetch(url, {
+      // The abbreviated packument is far smaller than the full manifest but still carries dist-tags.
+      headers: { Accept: "application/vnd.npm.install-v1+json" },
+      signal: controller.signal
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return body["dist-tags"]?.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/update/semver.ts
+function isNewerVersion(candidate, base) {
+  return compareVersions(candidate, base) > 0;
+}
+function compareVersions(a, b) {
+  const pa = parse4(a);
+  const pb = parse4(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa.main[i] !== pb.main[i]) return pa.main[i] < pb.main[i] ? -1 : 1;
+  }
+  if (pa.pre.length === 0 && pb.pre.length === 0) return 0;
+  if (pa.pre.length === 0) return 1;
+  if (pb.pre.length === 0) return -1;
+  const len = Math.max(pa.pre.length, pb.pre.length);
+  for (let i = 0; i < len; i++) {
+    if (i >= pa.pre.length) return -1;
+    if (i >= pb.pre.length) return 1;
+    const x = pa.pre[i];
+    const y = pb.pre[i];
+    const xNum = /^\d+$/.test(x);
+    const yNum = /^\d+$/.test(y);
+    if (xNum && yNum) {
+      const nx = Number(x);
+      const ny = Number(y);
+      if (nx !== ny) return nx < ny ? -1 : 1;
+    } else if (xNum !== yNum) {
+      return xNum ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function parse4(version) {
+  const cleaned = version.trim().replace(/^v/i, "").split("+", 1)[0];
+  const dash = cleaned.indexOf("-");
+  const core = dash === -1 ? cleaned : cleaned.slice(0, dash);
+  const pre = dash === -1 ? "" : cleaned.slice(dash + 1);
+  const parts = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  return { main: [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0], pre: pre ? pre.split(".") : [] };
+}
+var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var statePath = () => join(configDir(), "update-check.json");
+async function readUpdateState() {
+  try {
+    return JSON.parse(await readFile(statePath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeUpdateState(state) {
+  await mkdir(configDir(), { recursive: true, mode: 448 });
+  await writeFile(statePath(), JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+}
+function isStale(state, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+  if (!state?.lastCheckAt) return true;
+  const checkedAt = Date.parse(state.lastCheckAt);
+  return !Number.isFinite(checkedAt) || Date.now() - checkedAt > maxAgeMs;
+}
+
+// src/update/notifier.ts
+var SUPPRESSED_COMMANDS = /* @__PURE__ */ new Set(["update", "__update-check", "help"]);
+async function notifyOnExit(argv) {
+  if (isUpdateCheckSuppressed(argv)) return;
+  try {
+    const current = getCliVersion();
+    const state = await readUpdateState();
+    if (state?.latestVersion && isNewerVersion(state.latestVersion, current)) {
+      printUpdateNotice(current, state.latestVersion);
+    }
+    if (isStale(state)) spawnBackgroundRefresh();
+  } catch {
+  }
+}
+async function runUpdateCheckRefresh() {
+  const latest = await fetchLatestVersion({ timeoutMs: 4e3 }).catch(() => null);
+  await writeUpdateState({ lastCheckAt: (/* @__PURE__ */ new Date()).toISOString(), latestVersion: latest ?? void 0 }).catch(() => {
+  });
+}
+function isUpdateCheckSuppressed(argv) {
+  if (isEnvDisabled()) return true;
+  if (process.env.CI) return true;
+  if (!process.stderr.isTTY) return true;
+  const args = argv.slice(2);
+  if (args.length === 0) return true;
+  if (args.some((a) => a === "--json" || a === "-h" || a === "--help" || a === "-V" || a === "--version")) return true;
+  const command = args.find((a) => !a.startsWith("-"));
+  return command !== void 0 && SUPPRESSED_COMMANDS.has(command);
+}
+function isEnvDisabled() {
+  const off = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+  const noCheck = process.env.VERENTIS_NO_UPDATE_CHECK;
+  if (noCheck !== void 0 && noCheck !== "" && !off.has(noCheck.toLowerCase())) return true;
+  const explicit = process.env.VERENTIS_UPDATE_CHECK;
+  return explicit !== void 0 && off.has(explicit.toLowerCase());
+}
+function printUpdateNotice(current, latest) {
+  const message = [
+    `Update available ${current} \u2192 ${latest}`,
+    "Run `verentis update` to install the latest version."
+  ];
+  const width = Math.max(...message.map((line) => line.length));
+  const border = "\u2500".repeat(width + 2);
+  const lines = ["", `\u256D${border}\u256E`, ...message.map((line) => `\u2502 ${line.padEnd(width)} \u2502`), `\u2570${border}\u256F`, ""];
+  process.stderr.write(lines.join("\n") + "\n");
+}
+function spawnBackgroundRefresh() {
+  try {
+    const entry = process.argv[1];
+    if (!entry) return;
+    const child = spawn(process.execPath, [entry, "__update-check"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/commands/update.ts
+function registerUpdate(program2) {
+  program2.command("update").description("Update the Verentis CLI to the latest published version").option("--check", "report whether a newer version is available without installing").option("--to <version>", "install a specific version instead of the latest").action(async (options) => {
+    const current = getCliVersion();
+    const target = await resolveTarget(options.to);
+    if (options.check) {
+      reportCheck(current, target, Boolean(options.to));
+      return;
+    }
+    if (!options.to && !isNewerVersion(target, current)) {
+      console.log(`Already on the latest version (${current}).`);
+      return;
+    }
+    const install = resolveInstallCommand(`${PACKAGE_NAME}@${target}`);
+    if (!install) {
+      throw new Error(
+        `Automatic update is only supported for a global install of ${PACKAGE_NAME}.
+Update manually, for example:
+  npm install -g ${PACKAGE_NAME}@${target}`
+      );
+    }
+    console.log(`Updating ${PACKAGE_NAME}: ${current} \u2192 ${target}`);
+    console.log(`$ ${install.command} ${install.args.join(" ")}`);
+    const result = spawnSync(install.command, install.args, { stdio: "inherit" });
+    if (result.error) {
+      const code = result.error.code;
+      const hint = code === "ENOENT" ? ` ('${install.command}' was not found on PATH).` : `: ${result.error.message}`;
+      throw new Error(`Could not run the update${hint}
+Update manually:
+  ${install.command} ${install.args.join(" ")}`);
+    }
+    if (typeof result.status === "number" && result.status !== 0) {
+      throw new Error(
+        `Update failed (${install.command} exited with code ${result.status}).
+You can retry manually:
+  ${install.command} ${install.args.join(" ")}`
+      );
+    }
+    console.log(`Updated to ${target}. Run \`verentis --version\` to confirm.`);
+  });
+  program2.command("__update-check", { hidden: true }).description("(internal) refresh the cached latest-version marker").action(async () => {
+    await runUpdateCheckRefresh();
+  });
+}
+async function resolveTarget(requested) {
+  if (requested) return requested.replace(/^v/i, "");
+  const latest = await fetchLatestVersion({ timeoutMs: 8e3 });
+  if (!latest) {
+    throw new Error(
+      "Could not reach the package registry to determine the latest version. Check your connection, or point VERENTIS_UPDATE_REGISTRY at a reachable registry."
+    );
+  }
+  await writeUpdateState({ lastCheckAt: (/* @__PURE__ */ new Date()).toISOString(), latestVersion: latest }).catch(() => {
+  });
+  return latest;
+}
+function reportCheck(current, target, pinned) {
+  if (pinned) {
+    console.log(`Current version:   ${current}`);
+    console.log(`Requested version: ${target}`);
+    return;
+  }
+  if (isNewerVersion(target, current)) {
+    console.log(`A new version is available: ${current} \u2192 ${target}`);
+    console.log("Run `verentis update` to install it.");
+  } else {
+    console.log(`You are on the latest version (${current}).`);
+  }
+}
+function resolveInstallCommand(spec) {
+  const location = packageLocation();
+  if (!location || !location.replace(/\\/g, "/").includes("/node_modules/")) return null;
+  switch (detectPackageManager(location)) {
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-g", spec] };
+    case "yarn":
+      return { command: "yarn", args: ["global", "add", spec] };
+    case "bun":
+      return { command: "bun", args: ["add", "-g", spec] };
+    default:
+      return { command: "npm", args: ["install", "-g", spec] };
+  }
+}
+function packageLocation() {
+  try {
+    return fileURLToPath(import.meta.url);
+  } catch {
+    return process.argv[1];
+  }
+}
+function detectPackageManager(location) {
+  const path = location.replace(/\\/g, "/");
+  if (/\/(\.pnpm|pnpm)\//.test(path)) return "pnpm";
+  if (/\/(\.yarn|yarn)\//.test(path)) return "yarn";
+  if (/\/\.bun\//.test(path)) return "bun";
+  return "npm";
+}
 
 // src/commands/use.ts
 function registerUse(program2) {
@@ -2678,7 +2944,7 @@ function registerWorkspace(program2) {
 }
 
 // src/index.ts
-var program = new Command().name("verentis").description("Verentis CLI \u2014 admin, marketplace publishing, and the engine/app developer loop").version("0.2.0");
+var program = new Command().name("verentis").description("Verentis CLI \u2014 admin, marketplace publishing, and the engine/app developer loop").version(getCliVersion());
 registerLogin(program);
 registerUse(program);
 registerAccount(program);
@@ -2697,13 +2963,20 @@ registerPack(program);
 registerRegistry(program);
 registerPackage(program);
 registerApi(program);
-program.parseAsync().catch((error) => {
-  if (error instanceof ApiError || error instanceof Error) {
-    console.error(`Error: ${error.message}`);
-  } else {
-    console.error(error);
+registerUpdate(program);
+async function main() {
+  try {
+    await program.parseAsync();
+  } catch (error) {
+    if (error instanceof ApiError || error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error(error);
+    }
+    process.exitCode = 1;
   }
-  process.exitCode = 1;
-});
+  await notifyOnExit(process.argv);
+}
+void main();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map