mateooo93-cortex 0.25.42 → 0.25.43

package/lib/download.js

@@ -81,4 +81,4 @@ async function downloadBinary({ releaseBase, version, asset, destPath }) {
   }
 }
 
-module.exports = { downloadBinary, parseSha256Sums };
+module.exports = { downloadBinary, fetchText, parseSha256Sums };

package/lib/install.js

@@ -1,14 +1,60 @@
 "use strict";
 
 const fs = require("fs");
-const path = require("path");
 
-const { downloadBinary } = require("./download");
+const { downloadBinary, fetchText } = require("./download");
 const { warnIfShadowed } = require("./path-check");
 const { resolveAsset } = require("./platform");
-const { cacheDir, readPackageVersion, releaseBase } = require("./paths");
+const {
+  cacheDir,
+  currentBinaryPath,
+  readPackageVersion,
+  releaseBase,
+  releaseRepo,
+} = require("./paths");
 const { updateCurrentSymlink } = require("./symlink");
-const { readBinaryVersion, versionsMatch } = require("./version");
+const {
+  isNewerVersion,
+  normalizeVersion,
+  readBinaryVersion,
+  versionsMatch,
+} = require("./version");
+
+async function findNewerCurrentBinary(binaryName, pkgVersion) {
+  const currentPath = currentBinaryPath(binaryName);
+  if (!fs.existsSync(currentPath)) {
+    return null;
+  }
+  const currentVersion = await readBinaryVersion(currentPath);
+  if (isNewerVersion(currentVersion, pkgVersion)) {
+    return currentPath;
+  }
+  return null;
+}
+
+async function fetchLatestReleaseVersion(fetchTextFn = fetchText) {
+  const data = JSON.parse(
+    await fetchTextFn(`https://api.github.com/repos/${releaseRepo()}/releases/latest`)
+  );
+  const version = normalizeVersion(data.tag_name);
+  return version || null;
+}
+
+async function resolveInstallVersion(pkgVersion, fetchTextFn = fetchText) {
+  if (process.env.CORTEX_NPM_PIN_PACKAGE === "1") {
+    return pkgVersion;
+  }
+  try {
+    const latestVersion = await fetchLatestReleaseVersion(fetchTextFn);
+    if (isNewerVersion(latestVersion, pkgVersion)) {
+      return latestVersion;
+    }
+  } catch {
+    // GitHub Releases is the native-binary source of truth, but launch should
+    // still work offline or when the API is temporarily unavailable.
+  }
+  return pkgVersion;
+}
 
 async function ensureBinary() {
   if (process.env.CORTEX_SKIP_POSTINSTALL === "1") {
@@ -16,18 +62,27 @@ async function ensureBinary() {
   }
 
   const pkgVersion = readPackageVersion();
-  const version = `v${pkgVersion}`;
   const { asset, binaryName } = resolveAsset();
-  const destPath = cacheDir(pkgVersion, asset);
+
+  if (process.env.CORTEX_FORCE_REINSTALL !== "1") {
+    const selfUpdatedPath = await findNewerCurrentBinary(binaryName, pkgVersion);
+    if (selfUpdatedPath) {
+      return selfUpdatedPath;
+    }
+  }
+
+  const installVersion = await resolveInstallVersion(pkgVersion);
+  const version = `v${installVersion}`;
+  const destPath = cacheDir(installVersion, asset);
 
   let needsDownload =
     process.env.CORTEX_FORCE_REINSTALL === "1" || !fs.existsSync(destPath);
 
   if (!needsDownload) {
     const binaryVersion = await readBinaryVersion(destPath);
-    if (!versionsMatch(binaryVersion, pkgVersion)) {
+    if (!versionsMatch(binaryVersion, installVersion)) {
       console.warn(
-        `cortex-cli: cached binary is ${binaryVersion || "unknown"}, package requires ${pkgVersion}; re-downloading…`
+        `cortex-cli: cached binary is ${binaryVersion || "unknown"}, expected ${installVersion}; re-downloading…`
       );
       needsDownload = true;
     }
@@ -71,4 +126,9 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { ensureBinary };
+module.exports = {
+  ensureBinary,
+  fetchLatestReleaseVersion,
+  findNewerCurrentBinary,
+  resolveInstallVersion,
+};

package/lib/paths.js

@@ -29,10 +29,15 @@ function cacheDir(version, asset) {
   return path.join(os.homedir(), ".cortex", "npm", version, asset);
 }
 
+function currentBinaryPath(binaryName) {
+  return path.join(os.homedir(), ".cortex", "npm", "current", binaryName);
+}
+
 module.exports = {
   packageRoot,
   readPackageVersion,
   releaseRepo,
   releaseBase,
   cacheDir,
-};
+  currentBinaryPath,
+};

package/lib/symlink.js

@@ -3,10 +3,12 @@
 const fs = require("fs");
 const path = require("path");
 
+const { currentBinaryPath } = require("./paths");
+
 async function updateCurrentSymlink(destPath, binaryName) {
-  const currentDir = path.join(path.dirname(path.dirname(destPath)), "current");
+  const linkPath = currentBinaryPath(binaryName);
+  const currentDir = path.dirname(linkPath);
   await fs.promises.mkdir(currentDir, { recursive: true });
-  const linkPath = path.join(currentDir, binaryName);
   try {
     await fs.promises.unlink(linkPath);
   } catch (err) {
@@ -19,4 +21,4 @@ async function updateCurrentSymlink(destPath, binaryName) {
   }
 }
 
-module.exports = { updateCurrentSymlink };
+module.exports = { updateCurrentSymlink };

package/lib/version.js

@@ -14,6 +14,55 @@ function versionsMatch(binaryVersion, packageVersion) {
   return normalizeVersion(binaryVersion) === normalizeVersion(packageVersion);
 }
 
+function splitVersion(v) {
+  const normalized = normalizeVersion(v).split("+", 1)[0];
+  const [core, prerelease = ""] = normalized.split("-", 2);
+  const nums = core.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+  while (nums.length < 3) nums.push(0);
+  return { nums, prerelease };
+}
+
+function comparePrerelease(a, b) {
+  if (a === b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+
+  const left = a.split(".");
+  const right = b.split(".");
+  const len = Math.max(left.length, right.length);
+  for (let i = 0; i < len; i += 1) {
+    if (left[i] === undefined) return -1;
+    if (right[i] === undefined) return 1;
+    if (left[i] === right[i]) continue;
+
+    const ln = /^\d+$/.test(left[i]) ? Number.parseInt(left[i], 10) : null;
+    const rn = /^\d+$/.test(right[i]) ? Number.parseInt(right[i], 10) : null;
+    if (ln !== null && rn !== null) return Math.sign(ln - rn);
+    if (ln !== null) return -1;
+    if (rn !== null) return 1;
+    return left[i] < right[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+function compareVersions(a, b) {
+  const left = splitVersion(a);
+  const right = splitVersion(b);
+  for (let i = 0; i < Math.max(left.nums.length, right.nums.length); i += 1) {
+    const diff = (left.nums[i] || 0) - (right.nums[i] || 0);
+    if (diff !== 0) return Math.sign(diff);
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+
+function isNewerVersion(candidateVersion, baseVersion) {
+  if (!candidateVersion || !baseVersion) return false;
+  return compareVersions(candidateVersion, baseVersion) > 0;
+}
+
 async function readBinaryVersion(binaryPath) {
   try {
     const { stdout } = await execFileAsync(binaryPath, ["--version"], {
@@ -28,4 +77,10 @@ async function readBinaryVersion(binaryPath) {
   }
 }
 
-module.exports = { normalizeVersion, versionsMatch, readBinaryVersion };
+module.exports = {
+  normalizeVersion,
+  versionsMatch,
+  compareVersions,
+  isNewerVersion,
+  readBinaryVersion,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mateooo93-cortex",
-  "version": "0.25.42",
+  "version": "0.25.43",
   "description": "Fast AI coding agent with a polished terminal UI (npm wrapper — downloads the native binary for your OS)",
   "license": "AGPL-3.0-or-later",
   "repository": {