memtrace 0.3.38 → 0.3.39

package/bin/memtrace.js

@@ -9,6 +9,7 @@ const readline = require("readline");
 const { getBinaryPath } = require("../install.js");
 const { platformBinary, spawnOptionsForPlatform } = require("../lib/spawn-helper");
 const { shouldPromptForUpgrade, isPromptDisabled } = require("../lib/update-prompt");
+const { fetchLatestVersion, readCachedVersion } = require("../lib/update-check");
 
 // ── Handle `memtrace uninstall` before delegating to the Rust binary ────────
 // npm v7+ does NOT fire preuninstall hooks for global packages (npm/cli#3042).
@@ -129,58 +130,27 @@ try {
 }
 
 // ── Update checker ────────────────────────────────────────────────────────────
-// Checks registry.npmjs.org at most once every 24 h (cached in ~/.memtrace/).
-// Completely non-blocking: errors are silently swallowed.
-
-const CACHE_FILE    = path.join(os.homedir(), ".memtrace", "update-check.json");
-const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 h in ms
-
-function readUpdateCache() {
-  try {
-    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
+//
+// Policy (v0.3.39+): always TRY a fresh HTTP fetch first (1.5s timeout —
+// invisible to humans). On any failure (timeout, network, 5xx, parse
+// error), fall back to the on-disk cache. The cache also serves as the
+// Node ↔ Rust IPC handoff for the MCP banner: the Rust binary reads
+// `~/.memtrace/update-check.json` to decide whether to surface an
+// "update available" line in serverInfo.instructions for agents.
+//
+// We dropped the previous 24h TTL because it directly contradicted the
+// visibility goal: a user installing v0.3.36 the hour we shipped v0.3.37
+// would have waited 23 hours before their banner reflected reality.
+//
+// Implementation lives in lib/update-check.js and is unit + property
+// tested with injectable httpGet / cache path.
 
-function writeUpdateCache(data) {
-  try {
-    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(data), "utf-8");
-  } catch {
-    // non-fatal
-  }
-}
+const CACHE_FILE = path.join(os.homedir(), ".memtrace", "update-check.json");
 
 function checkForUpdate(currentVersion) {
-  return new Promise((resolve) => {
-    // Return cached result if it's fresh enough
-    const cache = readUpdateCache();
-    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL) {
-      resolve(cache.latestVersion !== currentVersion ? cache.latestVersion : null);
-      return;
-    }
-
-    const https = require("https");
-    const req = https.get(
-      "https://registry.npmjs.org/memtrace/latest",
-      { headers: { Accept: "application/json" }, timeout: 3000 },
-      (res) => {
-        let body = "";
-        res.on("data", (chunk) => (body += chunk));
-        res.on("end", () => {
-          try {
-            const latest = JSON.parse(body).version;
-            writeUpdateCache({ checkedAt: Date.now(), latestVersion: latest });
-            resolve(latest !== currentVersion ? latest : null);
-          } catch {
-            resolve(null);
-          }
-        });
-      }
-    );
-    req.on("error",   () => resolve(null));
-    req.on("timeout", () => { req.destroy(); resolve(null); });
+  return fetchLatestVersion({ cachePath: CACHE_FILE }).then((latest) => {
+    if (!latest) return null;
+    return latest !== currentVersion ? latest : null;
   });
 }
 
@@ -218,8 +188,10 @@ async function maybePromptForUpgrade(command) {
     new Promise((r) => setTimeout(r, 1500)),
   ]);
 
-  const cache = readUpdateCache();
-  const cachedLatest = cache && cache.latestVersion ? cache.latestVersion : null;
+  // After awaiting the in-flight check, the cache file holds whatever
+  // the fresh fetch produced (or last-known-good if it failed). Use
+  // readCachedVersion as the single source of truth here.
+  const cachedLatest = readCachedVersion(CACHE_FILE);
 
   const decision = shouldPromptForUpgrade({
     command,

package/lib/update-check.js

@@ -0,0 +1,161 @@
+"use strict";
+
+// Update-check with cache-as-fallback semantics.
+//
+// Pre-v0.3.39 we cached the npm-registry result for 24h to avoid
+// hammering the registry. The downside: a user installing v0.3.36 the
+// hour we shipped v0.3.37 wouldn't see the upgrade banner for 23 more
+// hours. That defeats the entire visibility goal.
+//
+// New policy:
+//   1. Always TRY a fresh HTTP fetch (1.5s timeout — invisible to humans).
+//   2. On success, overwrite the cache and return fresh value.
+//   3. On any failure (timeout, network error, non-2xx, parse error),
+//      fall back to whatever the cache last contained.
+//   4. The cache still serves as the Node ↔ Rust IPC handoff: the Rust
+//      MCP banner reads `~/.memtrace/update-check.json` to decide
+//      whether to surface "update available" in `serverInfo.instructions`.
+//
+// All IO is dependency-injected so tests can drive arbitrary network
+// failure modes deterministically.
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+
+const NPM_LATEST_URL = "https://registry.npmjs.org/memtrace/latest";
+const DEFAULT_TIMEOUT_MS = 1500;
+
+/**
+ * Read the JSON cache file. Returns the parsed object, or null on any
+ * IO/parse error. Pure (only file IO at the path you give it).
+ */
+function readUpdateCache(cachePath) {
+    try {
+        return JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Write the cache atomically-ish (mkdir + writeFile). Errors are
+ * swallowed — the cache is opportunistic; failing to write must not
+ * break the user's command. Returns true if write succeeded, false on
+ * any error.
+ */
+function writeUpdateCache(cachePath, data) {
+    try {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+        fs.writeFileSync(cachePath, JSON.stringify(data), "utf-8");
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Resolve the latest memtrace version on npm with cache fallback.
+ *
+ * @param {object} opts
+ * @param {string} opts.cachePath              absolute path to cache file
+ * @param {function(string): Promise<{body: string}>} [opts.httpGet]  injectable for tests
+ * @param {number} [opts.timeoutMs]            fetch timeout (default 1500)
+ * @param {function(): number} [opts.now]      time source (default Date.now)
+ * @returns {Promise<string|null>}             latest version string, or null when
+ *                                              fresh failed AND cache is empty/missing
+ */
+function fetchLatestVersion(opts = {}) {
+    if (!opts.cachePath) {
+        return Promise.reject(new Error("fetchLatestVersion: opts.cachePath is required"));
+    }
+    const httpGet = opts.httpGet || defaultHttpGet;
+    const timeoutMs = opts.timeoutMs || DEFAULT_TIMEOUT_MS;
+    const now = opts.now || Date.now;
+    const cachePath = opts.cachePath;
+
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const fallback = () => finish(readCachedVersion(cachePath));
+
+        const timer = setTimeout(fallback, timeoutMs);
+
+        Promise.resolve()
+            .then(() => httpGet(NPM_LATEST_URL))
+            .then((result) => {
+                if (!result || typeof result.body !== "string") {
+                    fallback();
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(result.body);
+                } catch {
+                    fallback();
+                    return;
+                }
+                if (!parsed || typeof parsed.version !== "string" || !parsed.version) {
+                    fallback();
+                    return;
+                }
+                writeUpdateCache(cachePath, {
+                    checkedAt: now(),
+                    latestVersion: parsed.version,
+                });
+                finish(parsed.version);
+            })
+            .catch(fallback);
+    });
+}
+
+/**
+ * Read the cached version string only (returns null if cache absent
+ * or shape is wrong). Useful when callers want to read the IPC handoff
+ * without triggering a network fetch.
+ */
+function readCachedVersion(cachePath) {
+    const cache = readUpdateCache(cachePath);
+    if (!cache || typeof cache.latestVersion !== "string" || !cache.latestVersion) {
+        return null;
+    }
+    return cache.latestVersion;
+}
+
+/**
+ * Default HTTP fetcher used in production. Resolves with `{body}` on
+ * 2xx, rejects on any other status, network error, or socket close.
+ */
+function defaultHttpGet(url) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(
+            url,
+            { headers: { Accept: "application/json" } },
+            (res) => {
+                if (res.statusCode < 200 || res.statusCode >= 300) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                let body = "";
+                res.on("data", (chunk) => (body += chunk));
+                res.on("end", () => resolve({ body }));
+            },
+        );
+        req.on("error", reject);
+    });
+}
+
+module.exports = {
+    NPM_LATEST_URL,
+    DEFAULT_TIMEOUT_MS,
+    fetchLatestVersion,
+    readUpdateCache,
+    writeUpdateCache,
+    readCachedVersion,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace",
-  "version": "0.3.38",
+  "version": "0.3.39",
   "description": "Code intelligence graph — MCP server + AI agent skills + visualization UI",
   "keywords": [
     "mcp",
@@ -39,9 +39,9 @@
     "fs-extra": "^11.0.0"
   },
   "optionalDependencies": {
-    "@memtrace/darwin-arm64": "0.3.38",
-    "@memtrace/linux-x64": "0.3.38",
-    "@memtrace/win32-x64": "0.3.38"
+    "@memtrace/darwin-arm64": "0.3.39",
+    "@memtrace/linux-x64": "0.3.39",
+    "@memtrace/win32-x64": "0.3.39"
   },
   "engines": {
     "node": ">=18"