@ornncompute/cli 0.2.24 → 1.0.25

package/src/update.mjs

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, realpathSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, posix, win32 } from "node:path";
 import { CliApiError } from "./api-client.mjs";
@@ -8,6 +8,9 @@ import { getAuthConfigDir } from "./auth-store.mjs";
 import { forwardSignals } from "./signals.mjs";
 import { acquireFileLock } from "./update-lock.mjs";
 
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CACHE_FILE = "update-check.json";
+export const CLI_MIGRATION_GUIDE_URL = "https://docs.ornn.com/cli#migrating-to-vnext";
 export const UPDATE_CHECK_TIMEOUT_MS = 3000;
 const UPDATE_LOCK_PREFIX = "update-install";
 const PACKAGE_NAME = "@ornncompute/cli";
@@ -104,7 +107,9 @@ export function detectInstallContext(binPath, env = process.env) {
 
   if (
     has("_npx") ||
-    segments.some((segment) => segment === "dlx" || segment.startsWith("dlx-") || segment.startsWith("xfs-")) ||
+    segments.some(
+      (segment) => segment === "dlx" || segment.startsWith("dlx-") || segment.startsWith("xfs-")
+    ) ||
     lower.includes("/.bun/install/cache/") ||
     lower.includes("/.yarn/berry/cache/")
   ) {
@@ -159,7 +164,9 @@ function isUnderDir(lowerPath, dir) {
   if (!trimmed) {
     return false;
   }
-  return lowerPath.startsWith(`${trimmed.replaceAll("\\", "/").toLowerCase().replace(/\/+$/, "")}/`);
+  return lowerPath.startsWith(
+    `${trimmed.replaceAll("\\", "/").toLowerCase().replace(/\/+$/, "")}/`
+  );
 }
 
 function isBunGlobalInstall(lowerPath, env) {
@@ -170,11 +177,16 @@ function isBunGlobalInstall(lowerPath, env) {
 }
 
 function isPnpmGlobalInstall(lowerPath, env) {
-  return /\/pnpm\/global\/\d+\/node_modules\//.test(lowerPath) || isUnderDir(lowerPath, env.PNPM_HOME);
+  return (
+    /\/pnpm\/global\/\d+\/node_modules\//.test(lowerPath) || isUnderDir(lowerPath, env.PNPM_HOME)
+  );
 }
 
 function isYarnGlobalInstall(lowerPath) {
-  return lowerPath.includes("/yarn/global/node_modules/") || lowerPath.includes("/yarn/data/global/node_modules/");
+  return (
+    lowerPath.includes("/yarn/global/node_modules/") ||
+    lowerPath.includes("/yarn/data/global/node_modules/")
+  );
 }
 
 function isNpmGlobalInstall(lowerPath, env) {
@@ -185,7 +197,10 @@ function isNpmGlobalInstall(lowerPath, env) {
       resolvedPrefix = realpathSync(configuredPrefix);
     } catch {}
     const prefix = resolvedPrefix.replaceAll("\\", "/").toLowerCase().replace(/\/+$/, "");
-    if (lowerPath.startsWith(`${prefix}/node_modules/`) || lowerPath.startsWith(`${prefix}/lib/node_modules/`)) {
+    if (
+      lowerPath.startsWith(`${prefix}/node_modules/`) ||
+      lowerPath.startsWith(`${prefix}/lib/node_modules/`)
+    ) {
       return true;
     }
   }
@@ -289,8 +304,8 @@ export async function installVersion({
         new CliApiError(
           error?.code === "ENOENT"
             ? `${command} was not found on PATH. Install it or run: npm install -g ${PACKAGE_NAME}@latest`
-            : `Failed to run ${command}: ${error?.message ?? error}`,
-        ),
+            : `Failed to run ${command}: ${error?.message ?? error}`
+        )
       );
     });
     child.on("exit", (code, signal) => {
@@ -358,7 +373,9 @@ export async function resolveInstalledBin({
   let configuredRoot = output;
   if (context.kind === "bun") {
     // Bun lists the effective global directory before its dependency tree.
-    configuredRoot = /^(.+) node_modules \(\d+(?: installed)?\)$/.exec(output?.split(/\r?\n/)[0] ?? "")?.[1];
+    configuredRoot = /^(.+) node_modules \(\d+(?: installed)?\)$/.exec(
+      output?.split(/\r?\n/)[0] ?? ""
+    )?.[1];
   }
   if (!configuredRoot || !paths.isAbsolute(configuredRoot)) {
     return null;
@@ -405,6 +422,7 @@ export async function fetchLatestVersion({
 
 export async function updateCommand({
   binPath,
+  allowMajor = false,
   currentVersion,
   env = process.env,
   fetchImpl = fetch,
@@ -415,19 +433,21 @@ export async function updateCommand({
 }) {
   const context = detectInstallContext(binPath, env);
   if (context.kind === "ephemeral") {
-    throw new CliApiError("ornn is running via a package runner (npx/dlx); there is no installed copy to update.");
+    throw new CliApiError(
+      "ornn is running via a package runner (npx/dlx); there is no installed copy to update."
+    );
   }
   if (context.kind === "dev") {
     throw new CliApiError("ornn is running from a development checkout; update it with git pull.");
   }
   if (context.kind === "project") {
     throw new CliApiError(
-      "ornn is installed as a project dependency; update it there with: npm update @ornncompute/cli",
+      "ornn is installed as a project dependency; update it there with: npm update @ornncompute/cli"
     );
   }
   if (context.kind === "unknown") {
     throw new CliApiError(
-      "Could not determine how ornn was installed. Reinstall with: npm install -g @ornncompute/cli@latest",
+      "Could not determine how ornn was installed. Reinstall with: npm install -g @ornncompute/cli@latest"
     );
   }
 
@@ -439,7 +459,7 @@ export async function updateCommand({
         lockPath
           ? ` If no updater or package installer is running, remove the stale lock at ${lockPath} and retry.`
           : " Check the config directory permissions and retry."
-      }`,
+      }`
     );
   }
 
@@ -447,7 +467,7 @@ export async function updateCommand({
     const installedBin = await resolveInstalledBin({ context, spawnProcess, env, platform });
     if (!installedBin) {
       throw new CliApiError(
-        `Could not verify the ${context.kind} global installation root. No files were changed; reinstall with: npm install -g ${PACKAGE_NAME}@latest`,
+        `Could not verify the ${context.kind} global installation root. No files were changed; reinstall with: npm install -g ${PACKAGE_NAME}@latest`
       );
     }
 
@@ -456,14 +476,29 @@ export async function updateCommand({
       stdout.write(`ornn CLI is already up to date (${currentVersion}).\n`);
       return 0;
     }
+    const majorUpgrade = latest ? isMajorUpgrade(latest, currentVersion) : false;
+    if (majorUpgrade && !allowMajor) {
+      throw new CliApiError(
+        `ornn CLI ${latest} is a major update and was not installed. Review ${CLI_MIGRATION_GUIDE_URL}, then run \`ornn update --major\`.`
+      );
+    }
+    if (!latest && !allowMajor) {
+      throw new CliApiError(
+        `Could not determine the latest version, so no update was installed: \`@latest\` could cross a major version. Retry the registry check, or review ${CLI_MIGRATION_GUIDE_URL} and run \`ornn update --major\`.`
+      );
+    }
     if (!latest) {
-      stderr.write("Could not check the npm registry for the latest version; attempting the update anyway.\n");
+      stderr.write(
+        "Could not check the npm registry for the latest version; explicit --major allows an @latest update.\n"
+      );
     }
 
     const version = latest ?? "latest";
     const [command, commandArgs] = installInvocation(context, version);
     stderr.write(`Running: ${command} ${commandArgs.join(" ")}\n`);
-    const result = await lock.runInstall(() => installVersion({ context, version, spawnProcess, platform, env }));
+    const result = await lock.runInstall(() =>
+      installVersion({ context, version, spawnProcess, platform, env })
+    );
     if (result.exitCode !== 0) {
       throw new CliApiError(
         updateFailureMessage({
@@ -473,12 +508,14 @@ export async function updateCommand({
           exitCode: result.exitCode,
           kind: context.kind,
           platform,
-        }),
+        })
       );
     }
 
     if (platform === "win32") {
-      stderr.write("If this terminal reports an error after updating, it is safe to ignore; open a new terminal.\n");
+      stderr.write(
+        "If this terminal reports an error after updating, it is safe to ignore; open a new terminal.\n"
+      );
     }
 
     const installedVersion = await readInstalledVersion(installedBin);
@@ -486,14 +523,16 @@ export async function updateCommand({
       stdout.write("Update finished. Run `ornn --version` to confirm the installed version.\n");
     } else if (installedVersion === currentVersion && latest) {
       stderr.write(
-        `The installer exited successfully, but this ornn still runs ${currentVersion} from ${context.binPath}. Your registry mirror may be behind, or another install shadows this one; check your PATH.\n`,
+        `The installer exited successfully, but this ornn still runs ${currentVersion} from ${context.binPath}. Your registry mirror may be behind, or another install shadows this one; check your PATH.\n`
       );
       return 1;
     } else if (installedVersion === currentVersion) {
-      stdout.write(`ornn CLI is still ${currentVersion}; the registry may not have a newer version.\n`);
+      stdout.write(
+        `ornn CLI is still ${currentVersion}; the registry may not have a newer version.\n`
+      );
     } else if (compareVersions(installedVersion, currentVersion) < 0) {
       stderr.write(
-        `The installer replaced ornn CLI ${currentVersion} with the older ${installedVersion}; your registry mirror may be behind. Reinstall with: npm install -g ${PACKAGE_NAME}@${currentVersion}\n`,
+        `The installer replaced ornn CLI ${currentVersion} with the older ${installedVersion}; your registry mirror may be behind. Reinstall with: npm install -g ${PACKAGE_NAME}@${currentVersion}\n`
       );
       return 1;
     } else {
@@ -517,7 +556,9 @@ function updateFailureMessage({ binPath, command, commandArgs, exitCode, kind, p
     lines.push(`If the output above shows a permissions error, try: sudo ${manualCommand}`);
   }
   if (kind === "yarn") {
-    lines.push("If yarn global is unavailable (yarn 2+), use: npm install -g @ornncompute/cli@latest");
+    lines.push(
+      "If yarn global is unavailable (yarn 2+), use: npm install -g @ornncompute/cli@latest"
+    );
   }
   return lines.join("\n");
 }
@@ -528,9 +569,116 @@ async function readInstalledVersion(binPath) {
     try {
       resolved = realpathSync(binPath);
     } catch {}
-    const parsed = JSON.parse(await readFile(join(dirname(resolved), "..", "package.json"), "utf8"));
-    return parsed?.name === PACKAGE_NAME && typeof parsed.version === "string" ? parsed.version : null;
+    const parsed = JSON.parse(
+      await readFile(join(dirname(resolved), "..", "package.json"), "utf8")
+    );
+    return parsed?.name === PACKAGE_NAME && typeof parsed.version === "string"
+      ? parsed.version
+      : null;
   } catch {
     return null;
   }
 }
+
+function isMajorUpgrade(candidate, current) {
+  const candidateVersion = parseVersion(candidate);
+  const currentVersion = parseVersion(current);
+  return Boolean(
+    candidateVersion && currentVersion && candidateVersion.nums[0] > currentVersion.nums[0]
+  );
+}
+
+function updateCachePath(env) {
+  return join(getAuthConfigDir(env), UPDATE_CACHE_FILE);
+}
+
+async function readUpdateCache(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeUpdateCache(path, payload) {
+  // Atomic tmp+rename: survives concurrent runs and replaces a root-owned file left by a past sudo run.
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  try {
+    await mkdir(dirname(path), { mode: 0o700, recursive: true });
+    await writeFile(tmpPath, `${JSON.stringify(payload)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(tmpPath, path);
+    return true;
+  } catch {
+    await rm(tmpPath, { force: true }).catch(() => {});
+    return false;
+  }
+}
+
+export async function maybeNotifyUpdate({
+  binPath,
+  currentVersion,
+  env = process.env,
+  fetchImpl = fetch,
+  now = Date.now(),
+  stderr,
+  interactive = stderr?.isTTY === true,
+}) {
+  try {
+    if (env.CI && env.CI !== "false") {
+      return;
+    }
+    if (!interactive || !stderr?.isTTY) {
+      return;
+    }
+    if (!INSTALLED_KINDS.has(detectInstallContext(binPath, env).kind)) {
+      return;
+    }
+    const cachePath = updateCachePath(env);
+    if (!isAbsolute(cachePath)) {
+      return;
+    }
+
+    const cache = await readUpdateCache(cachePath);
+    let latestKnown =
+      typeof cache?.latestVersion === "string" && VERSION_PATTERN.test(cache.latestVersion)
+        ? cache.latestVersion
+        : null;
+    const checkedAt = Date.parse(cache?.lastCheckedAt ?? "");
+    const fresh =
+      Number.isFinite(checkedAt) && now - checkedAt >= 0 && now - checkedAt < UPDATE_CHECK_TTL_MS;
+
+    if (!fresh) {
+      // Reserve the TTL before fetching so an unwritable cache disables the check instead of taxing every command.
+      const reserved = await writeUpdateCache(cachePath, {
+        lastCheckedAt: new Date(now).toISOString(),
+        latestVersion: latestKnown,
+      });
+      if (!reserved) {
+        return;
+      }
+      const fetched = await fetchLatestVersion({ env, fetchImpl });
+      if (fetched) {
+        latestKnown = fetched;
+        await writeUpdateCache(cachePath, {
+          lastCheckedAt: new Date(now).toISOString(),
+          latestVersion: fetched,
+        });
+      }
+    }
+
+    if (latestKnown && compareVersions(latestKnown, currentVersion) > 0) {
+      if (isMajorUpgrade(latestKnown, currentVersion)) {
+        stderr.write(
+          `Major update available: ornn CLI ${currentVersion} -> ${latestKnown}. \`ornn update\` will not install it. Review ${CLI_MIGRATION_GUIDE_URL}, then run \`ornn update --major\`.\n`
+        );
+      } else {
+        stderr.write(
+          `Update available: ornn CLI ${currentVersion} -> ${latestKnown}. Run \`ornn update\`.\n`
+        );
+      }
+    }
+  } catch {
+    // Never break or slow the command the notifier rides on.
+  }
+}