fix(doctor): case-insensitive safe-bin trusted dir matching on macOS/Windows

hkochar · web-flow · commit 2d10a2c76f30 · 2026-05-11T00:03:35.000-05:00
Summary:
- Compare trusted safe-bin directories with path-local case folding so Windows and default macOS paths match without weakening case-sensitive mounts.
- Keep the focused safe-bin regression coverage and current Unreleased changelog entry.

Verification:
- pnpm vitest run src/infra/exec-safe-bin-trust.test.ts src/auto-reply/reply/model-selection.test.ts
- pnpm check:test-types
- git diff --check
- GitHub CI passed, including Real behavior proof, auto-response, ClawSweeper dispatch, CodeQL, Critical Quality, and full CI checks.

Co-authored-by: Harman Kochar &lt;254796+hkochar@users.noreply.github.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -118,6 +118,7 @@ Docs: https://docs.openclaw.ai
 - Discord/voice: keep default agent-proxy realtime sessions from auto-speaking filler before the forced OpenClaw consult answer, finish Discord playback on realtime response completion, and queue later exact-speech answers until playback idles to avoid mid-sentence replacement.
 - Gateway: return deterministic `400 invalid_request_error` responses for malformed encoded session-kill HTTP paths instead of letting route-shaped requests fall through to later Gateway handlers. (#72439) Thanks @rubencu.
 - Control UI: serve root PWA and favicon assets from `/__openclaw__/` SPA routes so tab icons, install metadata, and the service worker do not 404 after internal navigation. Fixes #80072. Thanks @CodeNovice2017.
+- Exec/safe bins: compare trusted safe-bin dirs with path-specific case folding on case-insensitive filesystems so Windows and default macOS paths match without weakening case-sensitive mounts. (#42131) Thanks @hkochar.
 - OpenAI/realtime voice: honor disabled input-audio interruption locally so server VAD speech-start events do not clear Discord playback after operators set `interruptResponseOnInputAudio: false`.
 - Telegram: keep no-response DM turns quiet instead of rewriting them into visible silent-reply chatter. Fixes #78188. (#78228) Thanks @Beandon13.
 - Telegram: handle managed select button callbacks before the raw callback fallback while preserving delimiter-containing option values such as `env|prod`. (#79816) Thanks @moeedahmed.
diff --git a/src/infra/exec-safe-bin-trust.test.ts b/src/infra/exec-safe-bin-trust.test.ts
@@ -10,6 +10,13 @@ import {
   listWritableExplicitTrustedSafeBinDirs,
 } from "./exec-safe-bin-trust.js";
 
+function swapAsciiCase(value: string): string {
+  return value.replace(/[A-Za-z]/g, (char) => {
+    const lower = char.toLowerCase();
+    return char === lower ? char.toUpperCase() : lower;
+  });
+}
+
 describe("exec safe bin trust", () => {
   it("keeps default trusted dirs limited to immutable system paths", () => {
     const dirs = getTrustedSafeBinDirs({ refresh: true });
@@ -64,6 +71,62 @@ describe("exec safe bin trust", () => {
     ).toBe(false);
   });
 
+  it("matches trusted dirs through path-local case folding on case-insensitive filesystems", async () => {
+    await withTempDir({ prefix: "OpenClaw-Safe-Bin-" }, async (dir) => {
+      const swapped = swapAsciiCase(dir);
+      if (swapped === dir) {
+        return;
+      }
+      const originalStat = await fs.stat(dir);
+      let swappedStat: Awaited<ReturnType<typeof fs.stat>>;
+      try {
+        swappedStat = await fs.stat(swapped);
+      } catch {
+        return;
+      }
+      if (originalStat.dev !== swappedStat.dev || originalStat.ino !== swappedStat.ino) {
+        return;
+      }
+
+      const dirs = buildTrustedSafeBinDirs({
+        baseDirs: [],
+        extraDirs: [swapped],
+      });
+
+      expect(
+        isTrustedSafeBinPath({
+          resolvedPath: path.join(dir, "jq"),
+          trustedDirs: dirs,
+        }),
+      ).toBe(true);
+    });
+  });
+
+  it("keeps case-distinct trusted dirs separate on case-sensitive filesystems", async () => {
+    await withTempDir({ prefix: "openclaw-safe-bin-case-" }, async (parent) => {
+      const trustedDir = path.join(parent, "ToolBin");
+      const untrustedDir = path.join(parent, "toolbin");
+      await fs.mkdir(trustedDir);
+      try {
+        await fs.mkdir(untrustedDir);
+      } catch {
+        return;
+      }
+
+      const dirs = buildTrustedSafeBinDirs({
+        baseDirs: [],
+        extraDirs: [trustedDir],
+      });
+
+      expect(
+        isTrustedSafeBinPath({
+          resolvedPath: path.join(untrustedDir, "jq"),
+          trustedDirs: dirs,
+        }),
+      ).toBe(false);
+    });
+  });
+
   it("does not trust PATH entries by default", () => {
     const injected = `/tmp/openclaw-path-injected-${Date.now()}`;
 
diff --git a/src/infra/exec-safe-bin-trust.ts b/src/infra/exec-safe-bin-trust.ts
@@ -28,12 +28,54 @@ export type WritableTrustedSafeBinDir = {
 
 let trustedSafeBinCache: TrustedSafeBinCache | null = null;
 
-function normalizeTrustedDir(value: string): string | null {
+function swapAsciiCase(value: string): string {
+  return value.replace(/[A-Za-z]/g, (char) => {
+    const lower = char.toLowerCase();
+    return char === lower ? char.toUpperCase() : lower;
+  });
+}
+
+function sameFsObject(a: fs.Stats, b: fs.Stats): boolean {
+  return a.dev === b.dev && a.ino === b.ino;
+}
+
+function pathCaseInsensitive(value: string): boolean {
+  let candidate = value;
+  for (;;) {
+    const swapped = swapAsciiCase(candidate);
+    if (swapped !== candidate) {
+      try {
+        const original = fs.statSync(candidate);
+        try {
+          const alternate = fs.statSync(swapped);
+          return sameFsObject(original, alternate);
+        } catch {
+          return false;
+        }
+      } catch {
+        // The compared path may not exist yet; probe the closest existing parent.
+      }
+    }
+
+    const parent = path.dirname(candidate);
+    if (parent === candidate) {
+      return process.platform === "win32";
+    }
+    candidate = parent;
+  }
+}
+
+function normalizeTrustComparisonPath(value: string): string {
+  const resolved = path.resolve(value);
+  return pathCaseInsensitive(resolved) ? resolved.toLowerCase() : resolved;
+}
+
+function normalizeTrustedDir(value: string, forComparison = true): string | null {
   const trimmed = value.trim();
   if (!trimmed) {
     return null;
   }
-  return path.resolve(trimmed);
+  return forComparison ? normalizeTrustComparisonPath(trimmed) : path.resolve(trimmed);
 }
 
 export function normalizeTrustedSafeBinDirs(entries?: readonly string[] | null): string[] {
@@ -44,9 +86,9 @@ export function normalizeTrustedSafeBinDirs(entries?: readonly string[] | null):
   return Array.from(new Set(normalized));
 }
 
-function resolveTrustedSafeBinDirs(entries: readonly string[]): string[] {
+function resolveTrustedSafeBinDirs(entries: readonly string[], forComparison = true): string[] {
   const resolved = entries
-    .map((entry) => normalizeTrustedDir(entry))
+    .map((entry) => normalizeTrustedDir(entry, forComparison))
     .filter((entry): entry is string => Boolean(entry));
   return Array.from(new Set(resolved)).toSorted();
 }
@@ -92,7 +134,7 @@ export function getTrustedSafeBinDirs(
 
 export function isTrustedSafeBinPath(params: TrustedSafeBinPathParams): boolean {
   const trustedDirs = params.trustedDirs ?? getTrustedSafeBinDirs();
-  const resolvedDir = path.dirname(path.resolve(params.resolvedPath));
+  const resolvedDir = normalizeTrustComparisonPath(path.dirname(path.resolve(params.resolvedPath)));
   return trustedDirs.has(resolvedDir);
 }
 
@@ -102,7 +144,7 @@ export function listWritableExplicitTrustedSafeBinDirs(
   if (process.platform === "win32") {
     return [];
   }
-  const resolved = resolveTrustedSafeBinDirs(normalizeTrustedSafeBinDirs(entries));
+  const resolved = resolveTrustedSafeBinDirs(normalizeTrustedSafeBinDirs(entries), false);
   const hits: WritableTrustedSafeBinDir[] = [];
   for (const dir of resolved) {
     let stat: fs.Stats;
