fix(onnx): reject unversioned System32 runtime

Author: ualtinok

packages/aft-bridge/src/__tests__/onnx-version-filter.test.ts

@@ -224,6 +224,31 @@ describe("findSystemOnnxRuntime (Windows PATH)", () => {
     );
   });
 
+  test("rejects an unversioned ONNX Runtime from Windows System32", async () => {
+    const windowsDir = join(workDir, "Windows");
+    const systemDir = join(windowsDir, "System32");
+    mkdirSync(systemDir, { recursive: true });
+    writeFileSync(join(systemDir, "onnxruntime.dll"), "Windows component");
+
+    await withEnv(
+      {
+        PATH: systemDir,
+        Path: undefined,
+        path: undefined,
+        SystemRoot: windowsDir,
+        windir: undefined,
+        ProgramFiles: join(workDir, "program-files"),
+        "ProgramFiles(x86)": join(workDir, "program-files-x86"),
+        USERPROFILE: join(workDir, "profile-without-nuget"),
+      },
+      async () => {
+        const found = withPlatform("win32", () => findSystemOnnxRuntime("onnxruntime.dll"));
+
+        expect(found).toBeNull();
+      },
+    );
+  });
+
   test("ignores non-existent PATH directories without throwing", async () => {
     await withEnv(
       {

packages/aft-bridge/src/onnx-runtime.ts

@@ -470,6 +470,26 @@ function pathEntriesForPlatform(): string[] {
     });
 }
 
+function isWindowsSystem32Directory(dir: string): boolean {
+  if (process.platform !== "win32") return false;
+
+  const normalizedDir = win32
+    .resolve(dir)
+    .replace(/[\\/]+$/, "")
+    .toLowerCase();
+  const windowsRoots = [process.env.SystemRoot, process.env.windir, "C:\\Windows"];
+  return windowsRoots.some((root) => {
+    if (!root) return false;
+    return (
+      normalizedDir ===
+      win32
+        .resolve(root, "System32")
+        .replace(/[\\/]+$/, "")
+        .toLowerCase()
+    );
+  });
+}
+
 function directoryContainsLibrary(dir: string, libName: string): boolean {
   try {
     const entries = readdirSync(dir);
@@ -583,6 +603,15 @@ function findSystemOnnxRuntime(libName?: string): string | null {
     // it shadow a later candidate with a known compatible version.
     const version = detectOnnxVersion(dir, libName);
     if (!version) {
+      // Windows ships an unversioned ONNX Runtime in System32 on some releases.
+      // Rust can discover that DLL is too old only after startup, so never let
+      // an unverifiable OS copy prevent AFT from downloading its managed runtime.
+      if (isWindowsSystem32Directory(dir)) {
+        warn(
+          `Skipping unversioned Windows system ONNX Runtime at ${dir}; falling through to AFT-managed download.`,
+        );
+        continue;
+      }
       unknownVersionPaths.push(dir);
       continue;
     }

packages/aft-cli/src/__tests__/onnx-fix.test.ts

@@ -157,7 +157,26 @@ describe("findOnnxFixCandidates", () => {
     expect(candidates).toHaveLength(1);
     expect(candidates[0].reason).toContain("system ONNX Runtime");
     expect(candidates[0].reason).toContain("1.9.0");
-    expect(candidates[0].reason).toContain("v0.19.5+ skips incompatible system installs");
+    expect(candidates[0].reason).toContain("download v1.24");
+  });
+
+  test("flags a missing runtime after an unreadable Windows system copy is ignored", () => {
+    const report = makeReport([
+      makeHarness({
+        onnxRuntime: {
+          ...makeHarness().onnxRuntime,
+          ignoredSystemPath: "C:\\Windows\\System32",
+          ignoredSystemReason: "version unreadable (Windows system copy) — ignored",
+          platform: "win32-x64",
+        },
+      }),
+    ]);
+
+    const candidates = findOnnxFixCandidates(report);
+
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0].reason).toContain("version is unreadable");
+    expect(candidates[0].reason).toContain("download v1.24");
   });
 
   test("does NOT flag system install when a compatible cached install exists", () => {
@@ -247,10 +266,12 @@ describe("runOnnxFix", () => {
       rmFn: (path) => {
         removed.push(path);
       },
+      ensureFn: async () => join(storagePath, "onnxruntime", "1.24.4"),
     });
 
     expect(result).not.toBe(null);
     expect(result?.cleared).toBe(1);
+    expect(result?.installed).toBe(1);
     expect(result?.errors).toEqual([]);
     // Critical safety: the path deleted must be inside our test workDir,
     // never `/usr/lib/...`.
@@ -279,6 +300,7 @@ describe("runOnnxFix", () => {
     await runOnnxFix([], report, {
       confirmFn: async () => true,
       rmFn: (path) => removed.push(path),
+      ensureFn: async () => join(storagePath, "onnxruntime", "1.24.4"),
     });
 
     // The candidate's storage dir doesn't exist (we never downloaded
@@ -290,4 +312,32 @@ describe("runOnnxFix", () => {
       expect(path).toContain(workDir);
     }
   });
+
+  test("downloads a managed runtime immediately when none is installed", async () => {
+    const storagePath = join(workDir, "storage");
+    const report = makeReport([
+      makeHarness({
+        storageDir: { path: storagePath, exists: false, accessible: false, sizesByKey: {} },
+        onnxRuntime: {
+          ...makeHarness().onnxRuntime,
+          ignoredSystemPath: "C:\\Windows\\System32",
+          ignoredSystemReason: "version unreadable (Windows system copy) — ignored",
+          platform: "win32-x64",
+        },
+      }),
+    ]);
+    const ensured: string[] = [];
+
+    const result = await runOnnxFix([], report, {
+      yes: true,
+      ensureFn: async (storageDir) => {
+        ensured.push(storageDir);
+        return join(storageDir, "onnxruntime", "1.24.4");
+      },
+    });
+
+    expect(ensured).toEqual([storagePath]);
+    expect(result?.installed).toBe(1);
+    expect(result?.errors).toEqual([]);
+  });
 });

packages/aft-cli/src/__tests__/onnx.test.ts

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { __test__ as bridgeOnnxTest } from "../../../aft-bridge/src/onnx-runtime.js";
 import {
   findCachedOnnxRuntime,
+  findIgnoredWindowsSystemOnnxRuntime,
   findSystemOnnxRuntime,
   getOnnxLibraryName,
   ONNX_RUNTIME_VERSION,
@@ -26,6 +27,8 @@ beforeEach(() => {
     ["USERPROFILE", process.env.USERPROFILE],
     ["ProgramFiles", process.env.ProgramFiles],
     ["ProgramFiles(x86)", process.env["ProgramFiles(x86)"]],
+    ["SystemRoot", process.env.SystemRoot],
+    ["windir", process.env.windir],
   ]);
 });
 
@@ -64,6 +67,29 @@ describe("CLI ONNX system detection", () => {
     expect(found).toBe(runtimeDir);
   });
 
+  test("doctor rejects an unversioned ONNX Runtime from Windows System32", () => {
+    const windowsDir = join(workDir, "Windows");
+    const systemDir = join(windowsDir, "System32");
+    mkdirSync(systemDir, { recursive: true });
+    writeFileSync(join(systemDir, "onnxruntime.dll"), "Windows component");
+    process.env.PATH = systemDir;
+    process.env.SystemRoot = windowsDir;
+    process.env.ProgramFiles = join(workDir, "program-files");
+    process.env["ProgramFiles(x86)"] = join(workDir, "program-files-x86");
+    process.env.USERPROFILE = join(workDir, "profile-without-nuget");
+    delete process.env.Path;
+    delete process.env.path;
+    delete process.env.windir;
+
+    const result = withPlatform("win32", () => ({
+      found: findSystemOnnxRuntime(),
+      ignored: findIgnoredWindowsSystemOnnxRuntime(),
+    }));
+
+    expect(result.found).toBeNull();
+    expect(result.ignored).toBe(systemDir);
+  });
+
   test("doctor skips incompatible Windows PATH DLLs and selects a compatible candidate", () => {
     const oldRuntimeDir = join(workDir, "onnxruntime-1.9.0", "bin");
     const newRuntimeDir = join(workDir, "onnxruntime-1.24.4", "bin");

packages/aft-cli/src/commands/doctor.ts

@@ -194,6 +194,10 @@ export async function runDoctor(options: DoctorOptions): Promise<number> {
         parts.push(
           `system: ${h.onnxRuntime.systemVersion ?? "unknown"}${h.onnxRuntime.systemCompatible === false ? " (incompatible)" : ""}`,
         );
+      } else if (h.onnxRuntime.ignoredSystemPath) {
+        parts.push(
+          `system: ${h.onnxRuntime.ignoredSystemReason} at ${h.onnxRuntime.ignoredSystemPath}`,
+        );
       }
       if (!h.onnxRuntime.cachedPath && !h.onnxRuntime.systemPath) {
         parts.push(`not installed — ${h.onnxRuntime.installHint}`);
@@ -606,12 +610,12 @@ export function buildDoctorFixPlan(
     if (candidate.storageOnnxBytes > 0) {
       items.push({
         kind: "onnx",
-        message: `Will delete AFT-managed ONNX cache at ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)})`,
+        message: `Will replace AFT-managed ONNX cache at ${candidate.storageOnnxDir} (${formatBytes(candidate.storageOnnxBytes)}) and download a compatible runtime`,
       });
     } else {
       items.push({
         kind: "onnx",
-        message: `Will leave system ONNX untouched and refresh AFT-managed ONNX state for ${candidate.harness.displayName} on next start`,
+        message: `Will leave system ONNX untouched and download a compatible AFT-managed runtime for ${candidate.harness.displayName}`,
       });
     }
   }

packages/aft-cli/src/lib/diagnostics.ts

@@ -18,6 +18,7 @@ import { getLspCacheReport, type LspCacheReport } from "./lsp-cache.js";
 import {
   detectOrtVersion,
   findCachedOnnxRuntime,
+  findIgnoredWindowsSystemOnnxRuntime,
   findSystemOnnxRuntime,
   getManualInstallHint,
   isOrtVersionCompatible,
@@ -86,6 +87,8 @@ export interface HarnessDiagnostic {
     systemPath: string | null;
     systemVersion: string | null;
     systemCompatible: boolean | null;
+    ignoredSystemPath?: string | null;
+    ignoredSystemReason?: string | null;
     cachedPath: string | null;
     cachedVersion: string | null;
     cachedCompatible: boolean | null;
@@ -174,6 +177,7 @@ async function diagnoseHarness(adapter: HarnessAdapter): Promise<HarnessDiagnost
         true);
 
   const systemOrtDir = findSystemOnnxRuntime();
+  const ignoredSystemOrtDir = systemOrtDir ? null : findIgnoredWindowsSystemOnnxRuntime();
   const cachedOrtDir = findCachedOnnxRuntime(storage);
   const systemVersion = systemOrtDir ? detectOrtVersion(systemOrtDir) : null;
   const cachedVersion = cachedOrtDir ? detectOrtVersion(cachedOrtDir) : null;
@@ -205,6 +209,10 @@ async function diagnoseHarness(adapter: HarnessAdapter): Promise<HarnessDiagnost
       systemPath: systemOrtDir,
       systemVersion,
       systemCompatible: systemVersion ? isOrtVersionCompatible(systemVersion) : null,
+      ignoredSystemPath: ignoredSystemOrtDir,
+      ignoredSystemReason: ignoredSystemOrtDir
+        ? "version unreadable (Windows system copy) — ignored"
+        : null,
       cachedPath: cachedOrtDir,
       cachedVersion,
       cachedCompatible: cachedVersion ? isOrtVersionCompatible(cachedVersion) : null,
@@ -410,7 +418,9 @@ export function collectDiagnosticIssues(report: DiagnosticReport): DiagnosticIss
           code: "onnx_missing",
           severity: "medium",
           scope: h.displayName,
-          message: "ONNX Runtime is required for semantic search but was not detected.",
+          message: h.onnxRuntime.ignoredSystemPath
+            ? `ONNX Runtime at ${h.onnxRuntime.ignoredSystemPath} has a ${h.onnxRuntime.ignoredSystemReason}; no compatible runtime was detected.`
+            : "ONNX Runtime is required for semantic search but was not detected.",
           remediation: `Run \`aft doctor --fix\` or install ONNX Runtime manually (${h.onnxRuntime.installHint}).`,
         });
       }