@ornncompute/cli 0.1.2 → 0.1.4

package/src/update.mjs

@@ -0,0 +1,388 @@
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { CliApiError } from "./api-client.mjs";
+import { getAuthConfigDir } from "./auth-store.mjs";
+
+export const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+export const UPDATE_CHECK_TIMEOUT_MS = 3000;
+const UPDATE_CACHE_FILE = "update-check.json";
+const PACKAGE_NAME = "@ornncompute/cli";
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const INSTALLED_KINDS = new Set(["bun", "npm", "pnpm", "yarn"]);
+
+const INSTALL_COMMANDS = {
+  bun: (spec) => ["bun", ["add", "-g", spec]],
+  npm: (spec) => ["npm", ["install", "-g", spec]],
+  pnpm: (spec) => ["pnpm", ["add", "-g", spec]],
+  yarn: (spec) => ["yarn", ["global", "add", spec]],
+};
+
+function parseVersion(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(value.trim().split("+")[0]);
+  if (!match) {
+    return null;
+  }
+  return {
+    nums: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ? match[4].split(".") : null,
+  };
+}
+
+export function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) {
+    return 0;
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if (left.nums[index] !== right.nums[index]) {
+      return left.nums[index] < right.nums[index] ? -1 : 1;
+    }
+  }
+  if (!left.pre && !right.pre) {
+    return 0;
+  }
+  if (!left.pre) {
+    return 1;
+  }
+  if (!right.pre) {
+    return -1;
+  }
+  for (let index = 0; index < Math.max(left.pre.length, right.pre.length); index += 1) {
+    const x = left.pre[index];
+    const y = right.pre[index];
+    if (x === undefined) {
+      return -1;
+    }
+    if (y === undefined) {
+      return 1;
+    }
+    const xNumeric = /^\d+$/.test(x);
+    const yNumeric = /^\d+$/.test(y);
+    if (xNumeric && yNumeric) {
+      if (Number(x) !== Number(y)) {
+        return Number(x) < Number(y) ? -1 : 1;
+      }
+    } else if (xNumeric !== yNumeric) {
+      return xNumeric ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+export function detectInstallContext(binPath, env = process.env) {
+  if (!binPath) {
+    return { kind: "unknown", binPath: null };
+  }
+  let resolved = binPath;
+  try {
+    resolved = realpathSync(binPath);
+  } catch {}
+  const lower = resolved.replaceAll("\\", "/").toLowerCase();
+  const segments = lower.split("/").filter(Boolean);
+  const has = (segment) => segments.includes(segment);
+
+  if (
+    has("_npx") ||
+    segments.some((segment) => segment === "dlx" || segment.startsWith("dlx-") || segment.startsWith("xfs-")) ||
+    lower.includes("/.bun/install/cache/") ||
+    lower.includes("/.yarn/berry/cache/")
+  ) {
+    return { kind: "ephemeral", binPath: resolved };
+  }
+  if (!has("node_modules")) {
+    return { kind: "dev", binPath: resolved };
+  }
+  if (has(".bun") || isUnderDir(lower, env.BUN_INSTALL)) {
+    return { kind: "bun", binPath: resolved };
+  }
+  if (has(".pnpm") || has("pnpm") || isUnderDir(lower, env.PNPM_HOME)) {
+    return { kind: "pnpm", binPath: resolved };
+  }
+  if (has("yarn") || has(".yarn")) {
+    return { kind: "yarn", binPath: resolved };
+  }
+  if (isProjectInstall(resolved, lower)) {
+    return { kind: "project", binPath: resolved };
+  }
+  return { kind: "npm", binPath: resolved };
+}
+
+function isProjectInstall(resolvedPath, lower) {
+  // Global npm layouts: <prefix>/lib/node_modules (POSIX) or <prefix>/npm/node_modules (Windows default).
+  if (lower.includes("/lib/node_modules/") || lower.includes("/npm/node_modules/")) {
+    return false;
+  }
+  // Other global layouts (nvm-windows, Scoop) have no package.json above node_modules; projects do.
+  const index = lower.indexOf("/node_modules/");
+  if (index < 0) {
+    return false;
+  }
+  try {
+    return existsSync(join(resolvedPath.slice(0, index), "package.json"));
+  } catch {
+    return false;
+  }
+}
+
+function isUnderDir(lowerPath, dir) {
+  const trimmed = dir?.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return lowerPath.startsWith(`${trimmed.replaceAll("\\", "/").toLowerCase().replace(/\/+$/, "")}/`);
+}
+
+export function resolveUpdateRegistry(env = process.env) {
+  const registry = env.npm_config_registry?.trim() || "https://registry.npmjs.org";
+  return registry.replace(/\/+$/, "");
+}
+
+export async function fetchLatestVersion({
+  env = process.env,
+  fetchImpl = fetch,
+  timeoutMs = UPDATE_CHECK_TIMEOUT_MS,
+} = {}) {
+  try {
+    const response = await fetchImpl(`${resolveUpdateRegistry(env)}/${PACKAGE_NAME}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    const version = payload?.version;
+    return typeof version === "string" && VERSION_PATTERN.test(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+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,
+}) {
+  try {
+    if (env.CI && env.CI !== "false") {
+      return;
+    }
+    if (!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) {
+      stderr.write(`Update available: ornn CLI ${currentVersion} -> ${latestKnown}. Run \`ornn update\`.\n`);
+    }
+  } catch {
+    // Never break or slow the command the notifier rides on.
+  }
+}
+
+export async function updateCommand({
+  binPath,
+  currentVersion,
+  env = process.env,
+  fetchImpl = fetch,
+  platform = process.platform,
+  spawnProcess,
+  stderr,
+  stdout,
+}) {
+  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.");
+  }
+  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");
+  }
+  if (context.kind === "unknown") {
+    throw new CliApiError("Could not determine how ornn was installed. Reinstall with: npm install -g @ornncompute/cli@latest");
+  }
+
+  const latest = await fetchLatestVersion({ env, fetchImpl });
+  if (latest && compareVersions(latest, currentVersion) <= 0) {
+    await writeUpdateCache(updateCachePath(env), {
+      lastCheckedAt: new Date().toISOString(),
+      latestVersion: latest,
+    });
+    stdout.write(`ornn CLI is already up to date (${currentVersion}).\n`);
+    return 0;
+  }
+  if (!latest) {
+    stderr.write("Could not check the npm registry for the latest version; attempting the update anyway.\n");
+  }
+
+  const spec = `${PACKAGE_NAME}@${latest ?? "latest"}`;
+  const [command, commandArgs] = INSTALL_COMMANDS[context.kind](spec);
+  stderr.write(`Running: ${command} ${commandArgs.join(" ")}\n`);
+  const exitCode = await new Promise((resolve, reject) => {
+    const child = spawnProcess(command, commandArgs, {
+      shell: platform === "win32",
+      stdio: "inherit",
+    });
+    child.on("error", (error) =>
+      reject(
+        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}`,
+        ),
+      ),
+    );
+    child.on("exit", (code, signal) => resolve(signal ? 1 : code ?? 0));
+  });
+  if (exitCode !== 0) {
+    throw new CliApiError(
+      updateFailureMessage({ binPath: context.binPath, command, commandArgs, 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");
+  }
+
+  if (context.kind === "pnpm") {
+    // pnpm shims pin a versioned store path, so re-reads never see the new version; trust pnpm's exit status.
+    if (latest) {
+      stdout.write(`Updated ornn CLI ${currentVersion} -> ${latest}. Run \`ornn --version\` in a new shell to confirm.\n`);
+    } else {
+      stdout.write("Update finished. Run `ornn --version` in a new shell to confirm the installed version.\n");
+    }
+    await writeUpdateCache(updateCachePath(env), {
+      lastCheckedAt: new Date().toISOString(),
+      latestVersion: latest ?? null,
+    });
+    return 0;
+  }
+
+  // Re-resolve the original bin path so the read sees the freshly installed package.
+  const installedVersion = await readInstalledVersion(binPath ?? context.binPath);
+  if (!installedVersion) {
+    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`,
+    );
+    return 1;
+  } else if (installedVersion === currentVersion) {
+    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`,
+    );
+    return 1;
+  } else {
+    stdout.write(`Updated ornn CLI ${currentVersion} -> ${installedVersion}.\n`);
+    if (latest && compareVersions(installedVersion, latest) < 0) {
+      stderr.write(`Note: ${latest} is the latest on the registry; your mirror may be behind.\n`);
+    }
+  }
+  await writeUpdateCache(updateCachePath(env), {
+    lastCheckedAt: new Date().toISOString(),
+    latestVersion: latest ?? installedVersion ?? null,
+  });
+  return 0;
+}
+
+function updateFailureMessage({ binPath, command, commandArgs, exitCode, kind, platform }) {
+  const manualCommand = `${command} ${commandArgs.join(" ")}`;
+  const lines = [`Update failed (exit ${exitCode}). Retry manually: ${manualCommand}`];
+  if (platform === "win32") {
+    lines.push("If the output above shows a permissions error, retry from an elevated terminal.");
+  } else if (binPath && !binPath.startsWith(homedir())) {
+    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");
+  }
+  return lines.join("\n");
+}
+
+async function readInstalledVersion(binPath) {
+  try {
+    let resolved = 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;
+  } catch {
+    return null;
+  }
+}