fix(desktop): bound Windows app fallback scan

Author: hereswilson

packages/desktop/src/app-path-cache.test.ts

@@ -1,19 +1,19 @@
 import { describe, expect, test } from "bun:test"
-import { createAppPathCache, forgetAppPath, getAppPath, rememberAppPath } from "./app-path-cache"
+import { APP_PATH_CACHE_LIMIT, createAppPathCache, forgetAppPath, getAppPath, rememberAppPath } from "./app-path-cache"
 
 describe("app path cache", () => {
   test("bounds remembered app paths without retaining evicted entries", () => {
     const cache = createAppPathCache()
 
-    for (const index of Array.from({ length: 33 }, (_, index) => index)) {
+    for (const index of Array.from({ length: APP_PATH_CACHE_LIMIT + 1 }, (_, index) => index)) {
       rememberAppPath(cache, `app-${index}`, `C:\\Tools\\app-${index}.exe`)
     }
 
-    expect(cache.keys).toHaveLength(32)
-    expect(cache.values).toHaveLength(32)
+    expect(cache.keys).toHaveLength(APP_PATH_CACHE_LIMIT)
+    expect(cache.values).toHaveLength(APP_PATH_CACHE_LIMIT)
     expect(getAppPath(cache, "app-0")).toBeUndefined()
     expect(getAppPath(cache, "app-1")).toBe("C:\\Tools\\app-1.exe")
-    expect(getAppPath(cache, "app-32")).toBe("C:\\Tools\\app-32.exe")
+    expect(getAppPath(cache, `app-${APP_PATH_CACHE_LIMIT}`)).toBe(`C:\\Tools\\app-${APP_PATH_CACHE_LIMIT}.exe`)
   })
 
   test("forgets stale app paths", () => {

packages/desktop/src/app-path-cache.ts

@@ -1,4 +1,4 @@
-const APP_PATH_CACHE_LIMIT = 32
+export const APP_PATH_CACHE_LIMIT = 32
 
 // Keep storage flat under high churn; this cache is small enough that linear lookup is cheaper than Map retention.
 type AppPathCache = {

packages/desktop/src/main/apps.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test"
+import { dirname, join } from "node:path"
+import { APP_PATH_CACHE_LIMIT } from "../app-path-cache"
+import { getWindowsFallbackSearchDirs } from "./apps"
+
+describe("Windows app path resolution", () => {
+  test("deduplicates fallback search directories from stale resolver output", () => {
+    const paths = Array.from({ length: APP_PATH_CACHE_LIMIT }, (_, index) =>
+      join("root", "Tools", "bin", `Missing-${index}.exe`),
+    )
+    const dirs = getWindowsFallbackSearchDirs(paths)
+    const bin = dirname(paths[0])
+    const tools = dirname(bin)
+    const root = dirname(tools)
+
+    expect(dirs).toEqual([bin, tools, root])
+  })
+
+  test("bounds fallback search directories from scattered stale resolver output", () => {
+    const dirs = getWindowsFallbackSearchDirs(
+      Array.from({ length: APP_PATH_CACHE_LIMIT + 1 }, (_, index) =>
+        join("root", `Tools-${index}`, "bin", "Missing.exe"),
+      ),
+    )
+
+    expect(dirs).toHaveLength(APP_PATH_CACHE_LIMIT)
+    expect(new Set(dirs).size).toBe(APP_PATH_CACHE_LIMIT)
+  })
+})

packages/desktop/src/main/apps.ts

@@ -1,6 +1,6 @@
 import { access, readFile, readdir } from "node:fs/promises"
 import { dirname, extname, join } from "node:path"
-import { createAppPathCache, forgetAppPath, getAppPath, rememberAppPath } from "../app-path-cache"
+import { APP_PATH_CACHE_LIMIT, createAppPathCache, forgetAppPath, getAppPath, rememberAppPath } from "../app-path-cache"
 import { execFileHidden } from "./child-process"
 
 const exists = (path: string) =>
@@ -10,13 +10,24 @@ const exists = (path: string) =>
 
 const windowsAppPathCache = createAppPathCache()
 
+// This scan runs after direct executable and command shim resolution, so keep it at app path cache size.
+const WINDOWS_APP_FALLBACK_DIR_LIMIT = APP_PATH_CACHE_LIMIT
+
 const searchKey = (value: string) =>
   value
     .split("")
     .filter((value: string) => /[a-z0-9]/i.test(value))
     .map((value: string) => value.toLowerCase())
     .join("")
 
+export function getWindowsFallbackSearchDirs(paths: string[]) {
+  return Array.from(
+    new Set(paths.flatMap((path) => [dirname(path), dirname(dirname(path)), dirname(dirname(dirname(path)))])),
+  )
+    .filter((dir) => dir !== ".")
+    .slice(0, WINDOWS_APP_FALLBACK_DIR_LIMIT)
+}
+
 export function checkAppExists(appName: string) {
   if (process.platform === "win32") return true
   if (process.platform === "linux") return true
@@ -133,20 +144,17 @@ async function resolveWindowsAppPath(appName: string): Promise<string | null> {
   const key = searchKey(appName)
 
   if (key) {
-    for (const path of paths) {
-      const dirs = [dirname(path), dirname(dirname(path)), dirname(dirname(dirname(path)))]
-      for (const dir of dirs) {
-        try {
-          for (const entry of await readdir(dir)) {
-            const candidate = join(dir, entry)
-            if (!hasExt(candidate, "exe")) continue
-            const stem = entry.replace(/\.exe$/i, "")
-            const name = searchKey(stem)
-            if (name.includes(key) || key.includes(name)) return remember(candidate)
-          }
-        } catch {
-          continue
+    for (const dir of getWindowsFallbackSearchDirs(paths)) {
+      try {
+        for (const entry of await readdir(dir)) {
+          const candidate = join(dir, entry)
+          if (!hasExt(candidate, "exe")) continue
+          const stem = entry.replace(/\.exe$/i, "")
+          const name = searchKey(stem)
+          if (name.includes(key) || key.includes(name)) return remember(candidate)
         }
+      } catch {
+        continue
       }
     }
   }

packages/desktop/src/main/child-process.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
+import { APP_PATH_CACHE_LIMIT } from "../app-path-cache"
 
 type ExecFileOptions = {
   windowsHide?: boolean
@@ -330,7 +331,7 @@ describe("child process helpers", () => {
     const restore = platform("win32")
 
     try {
-      for (const index of Array.from({ length: 33 }, (_, index) => index)) {
+      for (const index of Array.from({ length: APP_PATH_CACHE_LIMIT + 1 }, (_, index) => index)) {
         const file = path.join(dir, `Code-${index}.exe`)
         await fs.writeFile(file, "")
         output = `${file}\r\n`

packages/desktop/src/renderer/open-path.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import { APP_PATH_CACHE_LIMIT } from "../app-path-cache"
 import { createOpenPath } from "./open-path"
 
 function api(opts?: {
@@ -129,7 +130,7 @@ describe("renderer openPath", () => {
     const current = api()
     const openPath = createOpenPath(current.api, "windows")
 
-    for (const index of Array.from({ length: 33 }, (_, index) => index)) {
+    for (const index of Array.from({ length: APP_PATH_CACHE_LIMIT + 1 }, (_, index) => index)) {
       await openPath("C:\\repo", `bounded-code-${index}`)
     }
     await openPath("C:\\repo", "bounded-code-0")