fix(app): prune stale file-explorer paths during hydration

When a subdirectory in expandedPathsByWorkspace no longer exists on disk
(e.g. removed externally while the app was closed), opening the file
explorer was fire-and-forgetting a directory listing for each persisted
path. A single ENOENT wrote to the shared lastError, so the whole panel
rendered as an error banner that only Retry could clear, and the stale
path stayed in the persisted state so the error returned on the next open.

Await the hydration listings, pass a new silent flag so a failed listing
does not overwrite lastError, and prune any failed paths from
expandedPathsByWorkspace so subsequent opens stay clean.

Fixes #1145.

Author: muzhi1991

packages/app/src/components/file-explorer-pane.tsx

@@ -45,8 +45,11 @@ import {
   DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
-import { useFileExplorerActions } from "@/hooks/use-file-explorer-actions";
-import { buildWorkspaceExplorerStateKey } from "@/hooks/use-file-explorer-actions";
+import {
+  buildWorkspaceExplorerStateKey,
+  dropFailedExpandedPaths,
+  useFileExplorerActions,
+} from "@/hooks/use-file-explorer-actions";
 import { usePanelStore, type SortOption } from "@/stores/panel-store";
 import { formatTimeAgo } from "@/utils/time";
 import { buildAbsoluteExplorerPath } from "@/utils/explorer-paths";
@@ -168,22 +171,45 @@ export function FileExplorerPane({
       return;
     }
     hasInitializedRef.current = true;
-    void requestDirectoryListing(".", {
-      recordHistory: false,
-      setCurrentPath: false,
-    });
-    const persistedPaths =
-      usePanelStore.getState().expandedPathsByWorkspace[workspaceStateKey ?? ""];
-    if (persistedPaths) {
-      for (const path of persistedPaths) {
-        if (path !== ".") {
-          void requestDirectoryListing(path, {
+    void (async () => {
+      await requestDirectoryListing(".", {
+        recordHistory: false,
+        setCurrentPath: false,
+      });
+      if (!workspaceStateKey) {
+        return;
+      }
+      const persistedPaths = usePanelStore.getState().expandedPathsByWorkspace[workspaceStateKey];
+      if (!persistedPaths || persistedPaths.length === 0) {
+        return;
+      }
+      const candidates = persistedPaths.filter((path) => path !== ".");
+      if (candidates.length === 0) {
+        return;
+      }
+      // Hydrate persisted expansions silently so that one missing subdirectory
+      // (e.g. deleted on disk while the app was closed) does not poison the
+      // whole panel with a panel-level error. Prune the failed entries from
+      // the persisted state so subsequent opens stay clean.
+      const results = await Promise.all(
+        candidates.map((path) =>
+          requestDirectoryListing(path, {
             recordHistory: false,
             setCurrentPath: false,
-          });
-        }
+            silent: true,
+          }).then((ok) => ({ path, ok })),
+        ),
+      );
+      const failed = new Set(results.filter((r) => !r.ok).map((r) => r.path));
+      if (failed.size === 0) {
+        return;
       }
-    }
+      const latest = usePanelStore.getState().expandedPathsByWorkspace[workspaceStateKey] ?? [];
+      const pruned = dropFailedExpandedPaths(latest, failed);
+      if (pruned.length !== latest.length) {
+        usePanelStore.getState().setExpandedPathsForWorkspace(workspaceStateKey, pruned);
+      }
+    })();
   }, [hasWorkspaceScope, requestDirectoryListing, workspaceStateKey]);
 
   // Expand ancestor directories when a file is selected (e.g., from an inline path click)

packages/app/src/hooks/use-file-explorer-actions.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { dropFailedExpandedPaths } from "./use-file-explorer-actions";
+
+describe("dropFailedExpandedPaths", () => {
+  it("returns a copy of the input when nothing failed", () => {
+    const input = [".", "src", "src/utils"];
+    const result = dropFailedExpandedPaths(input, new Set());
+    expect(result).toEqual([".", "src", "src/utils"]);
+    expect(result).not.toBe(input);
+  });
+
+  it("removes failed paths and keeps survivors plus '.'", () => {
+    expect(
+      dropFailedExpandedPaths([".", "vendor", "src", "src/utils"], new Set(["vendor"])),
+    ).toEqual([".", "src", "src/utils"]);
+  });
+
+  it("removes multiple failed paths in a nested tree", () => {
+    expect(
+      dropFailedExpandedPaths(
+        [".", "a/b", "vendor/foo", "vendor/bar", "src"],
+        new Set(["vendor/foo", "vendor/bar"]),
+      ),
+    ).toEqual([".", "a/b", "src"]);
+  });
+
+  it("ignores failures that are not in the current list", () => {
+    expect(dropFailedExpandedPaths([".", "src"], new Set(["does-not-exist"]))).toEqual([
+      ".",
+      "src",
+    ]);
+  });
+});

packages/app/src/hooks/use-file-explorer-actions.ts

@@ -49,6 +49,16 @@ export function buildWorkspaceExplorerStateKey(scope: FileExplorerWorkspaceScope
   return `root:${normalizedWorkspaceRoot}`;
 }
 
+export function dropFailedExpandedPaths(
+  current: readonly string[],
+  failed: ReadonlySet<string>,
+): string[] {
+  if (failed.size === 0) {
+    return [...current];
+  }
+  return current.filter((path) => !failed.has(path));
+}
+
 export function useFileExplorerActions(params: { serverId: string } & FileExplorerWorkspaceScope) {
   const { serverId, workspaceId, workspaceRoot } = params;
   const client = useSessionStore((state) => state.sessions[serverId]?.client ?? null);
@@ -82,18 +92,22 @@ export function useFileExplorerActions(params: { serverId: string } & FileExplor
   );
 
   const requestDirectoryListing = useCallback(
-    async (path: string, options?: { recordHistory?: boolean; setCurrentPath?: boolean }) => {
+    async (
+      path: string,
+      options?: { recordHistory?: boolean; setCurrentPath?: boolean; silent?: boolean },
+    ): Promise<boolean> => {
       if (!workspaceStateKey) {
-        return;
+        return false;
       }
       const normalizedPath = path && path.length > 0 ? path : ".";
       const shouldSetCurrentPath = options?.setCurrentPath ?? true;
       const shouldRecordHistory = options?.recordHistory ?? (shouldSetCurrentPath ? true : false);
+      const silent = options?.silent ?? false;
 
       updateExplorerState((state) => ({
         ...state,
         isLoading: true,
-        lastError: null,
+        lastError: silent ? state.lastError : null,
         pendingRequest: { path: normalizedPath, mode: "list" },
         ...(shouldSetCurrentPath
           ? {
@@ -110,20 +124,20 @@ export function useFileExplorerActions(params: { serverId: string } & FileExplor
         updateExplorerState((state) => ({
           ...state,
           isLoading: false,
-          lastError: "Workspace is unavailable",
+          lastError: silent ? state.lastError : "Workspace is unavailable",
           pendingRequest: null,
         }));
-        return;
+        return false;
       }
 
       if (!client) {
         updateExplorerState((state) => ({
           ...state,
           isLoading: false,
-          lastError: "Host is not connected",
+          lastError: silent ? state.lastError : "Host is not connected",
           pendingRequest: null,
         }));
-        return;
+        return false;
       }
 
       try {
@@ -132,31 +146,38 @@ export function useFileExplorerActions(params: { serverId: string } & FileExplor
           normalizedPath,
           "list",
         );
+        const succeeded = !payload.error && Boolean(payload.directory);
         updateExplorerState((state) => {
           const nextState: AgentFileExplorerState = {
             ...state,
             isLoading: false,
-            lastError: payload.error ?? null,
+            lastError: succeeded ? null : silent ? state.lastError : (payload.error ?? null),
             pendingRequest: null,
             directories: state.directories,
             files: state.files,
           };
 
-          if (!payload.error && payload.directory) {
+          if (succeeded && payload.directory) {
             const directories = new Map(state.directories);
             directories.set(payload.directory.path, payload.directory);
             nextState.directories = directories;
           }
 
           return nextState;
         });
+        return succeeded;
       } catch (error) {
         updateExplorerState((state) => ({
           ...state,
           isLoading: false,
-          lastError: error instanceof Error ? error.message : "Failed to list directory",
+          lastError: silent
+            ? state.lastError
+            : error instanceof Error
+              ? error.message
+              : "Failed to list directory",
           pendingRequest: null,
         }));
+        return false;
       }
     },
     [client, normalizedWorkspaceRoot, updateExplorerState, workspaceStateKey],