memtrace 0.8.0 → 0.8.2

package/install.js

@@ -239,6 +239,50 @@ function selfHealPlatformPackage() {
   return true;
 }
 
+// ── CUDA execution provider (win32 NVIDIA hosts) ─────────────────────────────
+//
+// v0.8.0 dropped `onnxruntime_providers_cuda.dll` from @memtrace/win32-x64
+// (400.9 MB tripped npm's E413 size ceiling); it ships as a GitHub release
+// asset instead. Without it, Windows NVIDIA users silently degrade to
+// DirectML. This step detects an NVIDIA GPU and fetches + sha256-verifies
+// the DLL into the platform package's bin dir. Package-internal
+// provisioning (never touches user config), so it runs pre-consent
+// alongside the optional-dep self-heal. Every failure mode is a warn +
+// continue; `memtrace gpu install-cuda` is the manual retry path.
+// Opt out with MEMTRACE_SKIP_CUDA_EP=1.
+async function maybeInstallCudaEp() {
+  const cudaEp = require("./lib/cuda-ep");
+  const pkg = platformPackageName(getPlatformKey());
+  const gate = cudaEp.shouldFetchCudaEp({ packageName: pkg, env: process.env });
+  if (!gate.fetch) return;
+
+  let binaryPath;
+  try {
+    binaryPath = getBinaryPath();
+  } catch (_) {
+    return; // no binary — self-heal already warned, nowhere to put the DLL
+  }
+  const version = getPinnedPlatformVersion(require("./package.json"), pkg);
+  try {
+    const result = await cudaEp.installCudaEp({ binaryPath, version, log: console.log });
+    if (result.status === "installed") {
+      console.log(`memtrace: CUDA execution provider installed at ${result.dllPath}`);
+    } else if (result.status === "skipped") {
+      console.log(
+        `memtrace: CUDA execution provider not installed (${result.reason}). ` +
+        `Run 'memtrace gpu install-cuda' to fetch it manually.`
+      );
+    } else if (result.status === "error") {
+      console.warn(
+        `memtrace: CUDA execution provider install failed: ${result.reason}. ` +
+        `GPU embedding falls back to DirectML; retry with 'memtrace gpu install-cuda'.`
+      );
+    }
+  } catch (e) {
+    console.warn(`memtrace: CUDA execution provider install skipped: ${e.message}`);
+  }
+}
+
 // ── Integration phases (post-consent) ───────────────────────────────────────
 //
 // Everything below this line mutates user configuration and therefore only
@@ -402,6 +446,9 @@ async function main() {
     } catch (e) {
       console.warn(`memtrace: ${e.message}`);
     }
+    // Still package-internal: drop the CUDA EP next to the binary on
+    // NVIDIA hosts (no-op everywhere else, idempotent on re-runs).
+    await maybeInstallCudaEp();
   }
 
   // Step 2 — consent gate (memtrace-public #25). Print the full mutation
@@ -459,6 +506,7 @@ module.exports = {
   getBinaryPath,
   ensureExecutableBits,
   runIntegrationPhases,
+  maybeInstallCudaEp,
   selfHealPlatformPackage,
   buildSelfHealEnv,
   buildSelfHealInstallArgs,

package/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtrace-skills",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Memtrace skills for AI coding agents — codebase exploration, temporal evolution, impact analysis, and more.",
   "type": "module",
   "bin": {

package/lib/cuda-ep.js

@@ -0,0 +1,355 @@
+"use strict";
+
+// On-demand CUDA execution provider fetch (Windows NVIDIA hosts).
+//
+// As of v0.8.0 the @memtrace/win32-x64 package no longer bundles
+// `onnxruntime_providers_cuda.dll` — at 400.9 MB it pushed the tarball
+// over npm's payload ceiling (E413, broke the v0.8.0 publish). The DLL
+// ships as a GitHub release asset instead (`memtrace-windows-x86_64-
+// cuda-ep.zip`, sha256 recorded in the release's `checksums.txt`), and
+// this module fetches it at install time for hosts that can actually
+// use it. The engine probes CUDA -> DirectML -> CPU at startup, so a
+// missing DLL is never fatal — NVIDIA users just silently land on
+// DirectML, which is what this fetch exists to avoid.
+//
+// Placement contract: the engine's dylib discovery looks next to the
+// running binary (`bridge_ort_dylib_env` in the Rust CLI), so the DLL
+// must land in the platform package's bin/ dir, beside memtrace.exe.
+// That directory is owned by the platform package: an npm upgrade
+// replaces it wholesale, which conveniently re-triggers this fetch on
+// the next postinstall. Everything here is package-internal
+// provisioning — it never touches user config, so install.js runs it
+// BEFORE the consent gate, same as the optional-dep self-heal.
+//
+// Failure policy: best-effort, always. Offline, missing release asset,
+// checksum mismatch, PowerShell missing — every failure path returns a
+// {status, reason} result instead of throwing, and the caller logs a
+// pointer to the manual escape hatch (`memtrace gpu install-cuda`).
+// A postinstall must never fail the package install over an optional
+// accelerator.
+//
+// All IO is dependency-injected (fetch, spawn, fs paths) so tests can
+// drive offline / mismatch / no-GPU modes deterministically — same
+// pattern as lib/update-check.js.
+
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+const { spawnSync } = require("child_process");
+
+const CUDA_EP_ASSET = "memtrace-windows-x86_64-cuda-ep.zip";
+const CUDA_EP_DLL = "onnxruntime_providers_cuda.dll";
+const RELEASE_BASE_URL = "https://github.com/syncable-dev/memtrace/releases/download";
+// Only the default AVX2 package. The noavx2 variant bundles a
+// from-source onnxruntime.dll; pairing it with Microsoft's prebuilt
+// CUDA EP is an untested ABI mix (and pre-Haswell CPU + modern NVIDIA
+// GPU is not a combination worth chasing).
+const CUDA_PACKAGE = "@memtrace/win32-x64";
+
+// Abort the zip download if the socket goes silent this long. The asset
+// is ~400 MB so there is deliberately NO total-time cap — slow links
+// are fine, dead links are not.
+const INACTIVITY_TIMEOUT_MS = 60_000;
+const CHECKSUMS_TIMEOUT_MS = 15_000;
+
+// ── Pure helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Release asset URLs for a memtrace version. Accepts "0.8.0" or
+ * "v0.8.0"; release tags are always v-prefixed.
+ */
+function releaseAssetUrls(version, baseUrl) {
+  const base = (baseUrl || RELEASE_BASE_URL).replace(/\/+$/, "");
+  const tag = version.startsWith("v") ? version : `v${version}`;
+  return {
+    zipUrl: `${base}/${tag}/${CUDA_EP_ASSET}`,
+    checksumsUrl: `${base}/${tag}/checksums.txt`,
+  };
+}
+
+/**
+ * Extract the sha256 for `assetName` from `sha256sum`-format text
+ * (`<64 hex>  <name>`, optional `*` binary marker). Returns lowercase
+ * hex or null when the asset has no line.
+ */
+function parseChecksums(text, assetName) {
+  if (typeof text !== "string") return null;
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^([0-9a-fA-F]{64})\s+\*?(.+)$/.exec(line.trim());
+    if (m && m[2].trim() === assetName) {
+      return m[1].toLowerCase();
+    }
+  }
+  return null;
+}
+
+/**
+ * Gate: is fetching the CUDA EP even applicable on this install?
+ * Returns {fetch, reason}. Pure — platform/package/env all injected.
+ */
+function shouldFetchCudaEp({ platform = os.platform(), packageName, env = process.env } = {}) {
+  if (env.MEMTRACE_SKIP_CUDA_EP === "1") {
+    return { fetch: false, reason: "MEMTRACE_SKIP_CUDA_EP=1" };
+  }
+  if (platform !== "win32") {
+    return { fetch: false, reason: `platform ${platform} (win32 only)` };
+  }
+  if (packageName !== CUDA_PACKAGE) {
+    return { fetch: false, reason: `platform package ${packageName} (only ${CUDA_PACKAGE})` };
+  }
+  return { fetch: true, reason: "win32 AVX2 package" };
+}
+
+/** True when `spawnSync`-shaped result output looks like an NVIDIA GPU list. */
+function nvidiaSmiSaysYes(result) {
+  return Boolean(result && result.status === 0 && /\bGPU \d+/.test(result.stdout || ""));
+}
+
+/** True when a Win32_VideoController name dump mentions an NVIDIA adapter. */
+function videoControllerSaysYes(result) {
+  return Boolean(result && result.status === 0 && /nvidia/i.test(result.stdout || ""));
+}
+
+// ── Host probes ──────────────────────────────────────────────────────────────
+
+/**
+ * Best-effort NVIDIA detection on win32. `nvidia-smi -L` first (present
+ * whenever the NVIDIA driver is installed — exactly the hosts where the
+ * CUDA EP can load), then a CIM adapter-name query for driver installs
+ * that didn't put nvidia-smi on PATH. Ambiguity/errors → false: the
+ * download is 400 MB, so we only fetch on a positive signal, and
+ * `memtrace gpu install-cuda --force` exists for detection misses.
+ */
+function detectNvidiaGpu({ spawn = spawnSync } = {}) {
+  try {
+    const smi = spawn("nvidia-smi", ["-L"], { encoding: "utf8", timeout: 5000, windowsHide: true });
+    if (nvidiaSmiSaysYes(smi)) return true;
+  } catch (_) {
+    /* not on PATH — fall through to CIM */
+  }
+  try {
+    const ps = spawn(
+      "powershell",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "(Get-CimInstance Win32_VideoController).Name",
+      ],
+      { encoding: "utf8", timeout: 10000, windowsHide: true }
+    );
+    return videoControllerSaysYes(ps);
+  } catch (_) {
+    return false;
+  }
+}
+
+// ── Network ──────────────────────────────────────────────────────────────────
+
+function requireFetch(fetchImpl) {
+  const f = fetchImpl || globalThis.fetch;
+  if (typeof f !== "function") {
+    throw new Error("global fetch unavailable (Node >= 18 required)");
+  }
+  return f;
+}
+
+async function fetchText(url, { fetchImpl, timeoutMs = CHECKSUMS_TIMEOUT_MS } = {}) {
+  const f = requireFetch(fetchImpl);
+  const res = await f(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: { "user-agent": "memtrace-install" },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+  return res.text();
+}
+
+/**
+ * Stream `url` to `destPath`, returning the sha256 hex of the bytes
+ * written. Aborts when the connection stalls for `inactivityTimeoutMs`
+ * (no total cap — see header comment).
+ */
+async function downloadToFile(url, destPath, { fetchImpl, inactivityTimeoutMs = INACTIVITY_TIMEOUT_MS } = {}) {
+  const f = requireFetch(fetchImpl);
+  const controller = new AbortController();
+  let watchdog = null;
+  const armWatchdog = () => {
+    clearTimeout(watchdog);
+    watchdog = setTimeout(
+      () => controller.abort(new Error(`download stalled for ${inactivityTimeoutMs}ms`)),
+      inactivityTimeoutMs
+    );
+    if (watchdog.unref) watchdog.unref();
+  };
+
+  armWatchdog();
+  try {
+    const res = await f(url, {
+      redirect: "follow",
+      signal: controller.signal,
+      headers: { "user-agent": "memtrace-install" },
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+    if (!res.body) throw new Error(`empty response body for ${url}`);
+
+    const hash = crypto.createHash("sha256");
+    const out = fs.createWriteStream(destPath);
+    try {
+      const reader = res.body.getReader();
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        armWatchdog();
+        hash.update(value);
+        if (!out.write(value)) {
+          await new Promise((resolve, reject) => {
+            out.once("drain", resolve);
+            out.once("error", reject);
+          });
+        }
+      }
+      await new Promise((resolve, reject) => out.end((err) => (err ? reject(err) : resolve())));
+    } catch (e) {
+      out.destroy();
+      throw e;
+    }
+    return hash.digest("hex");
+  } finally {
+    clearTimeout(watchdog);
+  }
+}
+
+// ── Extraction ───────────────────────────────────────────────────────────────
+
+/**
+ * Expand the single-DLL zip into `destDir` with PowerShell's
+ * Expand-Archive (built into every supported Windows; Node has no zip
+ * reader and this module takes no deps). Returns the extracted DLL
+ * path. Throws with stderr context on failure.
+ */
+function extractDll(zipPath, destDir, { spawn = spawnSync } = {}) {
+  const result = spawn(
+    "powershell",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      // -LiteralPath: both paths come from mkdtemp and can contain
+      // characters PowerShell would otherwise glob.
+      `Expand-Archive -LiteralPath '${zipPath}' -DestinationPath '${destDir}' -Force`,
+    ],
+    { encoding: "utf8", timeout: 120_000, windowsHide: true }
+  );
+  if (result.status !== 0) {
+    const detail = (result.stderr || result.error?.message || "").trim().slice(0, 300);
+    throw new Error(`Expand-Archive failed (exit ${result.status})${detail ? `: ${detail}` : ""}`);
+  }
+  const dllPath = path.join(destDir, CUDA_EP_DLL);
+  if (!fs.existsSync(dllPath)) {
+    throw new Error(`${CUDA_EP_DLL} not found in archive`);
+  }
+  return dllPath;
+}
+
+// ── Orchestrator ─────────────────────────────────────────────────────────────
+
+/**
+ * Fetch + verify + place the CUDA EP DLL next to `binaryPath`.
+ * Idempotent: an existing DLL short-circuits unless `force`.
+ *
+ * Never throws for expected conditions — resolves to:
+ *   {status: "installed",         dllPath}
+ *   {status: "already-installed", dllPath}
+ *   {status: "skipped",           reason}   (no GPU / offline / asset absent)
+ *   {status: "error",             reason}   (checksum mismatch, extract/place failure)
+ */
+async function installCudaEp({
+  binaryPath,
+  version,
+  env = process.env,
+  fetchImpl,
+  spawn = spawnSync,
+  detect, // injectable NVIDIA probe for tests
+  force = false,
+  log = () => {},
+} = {}) {
+  const binDir = path.dirname(binaryPath);
+  const dllPath = path.join(binDir, CUDA_EP_DLL);
+  if (!force && fs.existsSync(dllPath)) {
+    return { status: "already-installed", dllPath };
+  }
+
+  const hasNvidia = detect ? detect() : detectNvidiaGpu({ spawn });
+  if (!hasNvidia && !force) {
+    return { status: "skipped", reason: "no NVIDIA GPU detected" };
+  }
+
+  const urls = releaseAssetUrls(version, env.MEMTRACE_CUDA_EP_BASE_URL);
+
+  // checksums.txt first: a ~1 KB fetch that doubles as the offline
+  // probe, so we never start a 400 MB transfer we can't verify.
+  let checksumsText;
+  try {
+    checksumsText = await fetchText(urls.checksumsUrl, { fetchImpl });
+  } catch (e) {
+    return { status: "skipped", reason: `release checksums unreachable (${e.message})` };
+  }
+  const expected = parseChecksums(checksumsText, CUDA_EP_ASSET);
+  if (!expected) {
+    return { status: "skipped", reason: `release v${version} has no ${CUDA_EP_ASSET}` };
+  }
+
+  const workDir = fs.mkdtempSync(path.join(os.tmpdir(), "memtrace-cuda-ep-"));
+  try {
+    const zipPath = path.join(workDir, CUDA_EP_ASSET);
+    log(`memtrace: NVIDIA GPU detected — downloading CUDA execution provider (~400 MB, one-time)…`);
+    let actual;
+    try {
+      actual = await downloadToFile(urls.zipUrl, zipPath, { fetchImpl });
+    } catch (e) {
+      return { status: "skipped", reason: `download failed (${e.message})` };
+    }
+    if (actual !== expected) {
+      return { status: "error", reason: `sha256 mismatch for ${CUDA_EP_ASSET}: expected ${expected}, got ${actual}` };
+    }
+
+    let extracted;
+    try {
+      extracted = extractDll(zipPath, workDir, { spawn });
+    } catch (e) {
+      return { status: "error", reason: e.message };
+    }
+
+    // Copy into place via a temp name + rename so a crash mid-copy
+    // never leaves a truncated DLL where the engine's probe finds it.
+    const staging = path.join(binDir, `.${CUDA_EP_DLL}.download`);
+    try {
+      fs.copyFileSync(extracted, staging);
+      fs.renameSync(staging, dllPath);
+    } catch (e) {
+      try { fs.rmSync(staging, { force: true }); } catch (_) { /* best-effort */ }
+      return { status: "error", reason: `could not place DLL in ${binDir} (${e.message})` };
+    }
+    return { status: "installed", dllPath };
+  } finally {
+    try { fs.rmSync(workDir, { recursive: true, force: true }); } catch (_) { /* best-effort */ }
+  }
+}
+
+module.exports = {
+  CUDA_EP_ASSET,
+  CUDA_EP_DLL,
+  CUDA_PACKAGE,
+  RELEASE_BASE_URL,
+  releaseAssetUrls,
+  parseChecksums,
+  shouldFetchCudaEp,
+  nvidiaSmiSaysYes,
+  videoControllerSaysYes,
+  detectNvidiaGpu,
+  downloadToFile,
+  extractDll,
+  installCudaEp,
+};

package/package.json

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