🤖 fix: prevent workspace create selection race (#1239)

ammar-agent · web-flow · commit c9b5ffa81619 · 2025-12-20T13:38:18.000-06:00
Fixes a race where the server-mode launch-project auto-selection could
win over an in-progress workspace creation, leaving the UI in the wrong
workspace state.

Changes:
- Cancel in-flight launch-project selection when creation starts
- Centralize WorkspaceSelection construction via toWorkspaceSelection()
- Remove redundant selection reset in useStartWorkspaceCreation
- Add regression test for launch-project vs pending creation

Test:
- make static-check

---
_Generated with `mux` • Model: `openai:gpt-5.2` • Thinking: `xhigh`_
diff --git a/src/browser/App.tsx b/src/browser/App.tsx
@@ -1,6 +1,6 @@
 import { useEffect, useCallback, useRef } from "react";
 import "./styles/globals.css";
-import { useWorkspaceContext } from "./contexts/WorkspaceContext";
+import { useWorkspaceContext, toWorkspaceSelection } from "./contexts/WorkspaceContext";
 import { useProjectContext } from "./contexts/ProjectContext";
 import type { WorkspaceSelection } from "./components/ProjectSidebar";
 import { LeftSidebar } from "./components/LeftSidebar";
@@ -114,7 +114,6 @@ function AppInner() {
   const startWorkspaceCreation = useStartWorkspaceCreation({
     projects,
     beginWorkspaceCreation,
-    setSelectedWorkspace,
   });
 
   useEffect(() => {
@@ -203,12 +202,7 @@ function AppInner() {
       } else if (!selectedWorkspace.namedWorkspacePath && metadata.namedWorkspacePath) {
         // Old localStorage entry missing namedWorkspacePath - update it once
         console.log(`Updating workspace ${selectedWorkspace.workspaceId} with missing fields`);
-        setSelectedWorkspace({
-          workspaceId: metadata.id,
-          projectPath: metadata.projectPath,
-          projectName: metadata.projectName,
-          namedWorkspacePath: metadata.namedWorkspacePath,
-        });
+        setSelectedWorkspace(toWorkspaceSelection(metadata));
       }
     }
   }, [selectedWorkspace, workspaceMetadata, setSelectedWorkspace]);
@@ -274,12 +268,7 @@ function AppInner() {
       const targetMetadata = sortedWorkspaces[targetIndex];
       if (!targetMetadata) return;
 
-      setSelectedWorkspace({
-        projectPath: selectedWorkspace.projectPath,
-        projectName: selectedWorkspace.projectName,
-        namedWorkspacePath: targetMetadata.namedWorkspacePath,
-        workspaceId: targetMetadata.id,
-      });
+      setSelectedWorkspace(toWorkspaceSelection(targetMetadata));
     },
     [selectedWorkspace, sortedWorkspacesByProject, setSelectedWorkspace]
   );
@@ -587,12 +576,7 @@ function AppInner() {
       });
 
       // Switch to the new workspace
-      setSelectedWorkspace({
-        workspaceId: workspaceInfo.id,
-        projectPath: workspaceInfo.projectPath,
-        projectName: workspaceInfo.projectName,
-        namedWorkspacePath: workspaceInfo.namedWorkspacePath,
-      });
+      setSelectedWorkspace(toWorkspaceSelection(workspaceInfo));
     };
 
     window.addEventListener(CUSTOM_EVENTS.WORKSPACE_FORK_SWITCH, handleForkSwitch as EventListener);
@@ -706,12 +690,7 @@ function AppInner() {
                                 // User has already selected another workspace - don't override
                                 return current;
                               }
-                              return {
-                                workspaceId: metadata.id,
-                                projectPath: metadata.projectPath,
-                                projectName: metadata.projectName,
-                                namedWorkspacePath: metadata.namedWorkspacePath,
-                              };
+                              return toWorkspaceSelection(metadata);
                             });
 
                             // Track telemetry
diff --git a/src/browser/contexts/WorkspaceContext.test.tsx b/src/browser/contexts/WorkspaceContext.test.tsx
@@ -506,6 +506,59 @@ describe("WorkspaceContext", () => {
     expect(ctx().selectedWorkspace?.projectPath).toBe("/existing");
   });
 
+  test("launch project does not override pending workspace creation", async () => {
+    // Race condition test: if user starts creating a workspace while
+    // getLaunchProject is in flight, the launch project should not override
+
+    let resolveLaunchProject: (value: string | null) => void;
+    const launchProjectPromise = new Promise<string | null>((resolve) => {
+      resolveLaunchProject = resolve;
+    });
+
+    const initialWorkspaces = [
+      createWorkspaceMetadata({
+        id: "ws-launch",
+        projectPath: "/launch-project",
+        projectName: "launch-project",
+        name: "main",
+        namedWorkspacePath: "/launch-project-main",
+      }),
+    ];
+
+    createMockAPI({
+      workspace: {
+        list: () => Promise.resolve(initialWorkspaces),
+      },
+      server: {
+        getLaunchProject: () => launchProjectPromise,
+      },
+    });
+
+    const ctx = await setup();
+
+    await waitFor(() => expect(ctx().loading).toBe(false));
+
+    // User starts workspace creation (this sets pendingNewWorkspaceProject)
+    act(() => {
+      ctx().beginWorkspaceCreation("/new-project");
+    });
+
+    // Verify pending state is set
+    expect(ctx().pendingNewWorkspaceProject).toBe("/new-project");
+    expect(ctx().selectedWorkspace).toBeNull();
+
+    // Now the launch project response arrives
+    await act(async () => {
+      resolveLaunchProject!("/launch-project");
+      // Give effect time to process
+      await new Promise((r) => setTimeout(r, 50));
+    });
+
+    // Should NOT have selected the launch project workspace because creation is pending
+    expect(ctx().selectedWorkspace).toBeNull();
+    expect(ctx().pendingNewWorkspaceProject).toBe("/new-project");
+  });
+
   test("WorkspaceProvider calls ProjectContext.refreshProjects after loading", async () => {
     // Verify that projects.list is called during workspace metadata loading
     const projectsListMock = mock(() => Promise.resolve([]));
diff --git a/src/browser/contexts/WorkspaceContext.tsx b/src/browser/contexts/WorkspaceContext.tsx
@@ -59,6 +59,15 @@ function seedWorkspaceLocalStorageFromBackend(metadata: FrontendWorkspaceMetadat
   }
 }
 
+export function toWorkspaceSelection(metadata: FrontendWorkspaceMetadata): WorkspaceSelection {
+  return {
+    workspaceId: metadata.id,
+    projectPath: metadata.projectPath,
+    projectName: metadata.projectName,
+    namedWorkspacePath: metadata.namedWorkspacePath,
+  };
+}
+
 /**
  * Ensure workspace metadata has createdAt timestamp.
  * DEFENSIVE: Backend guarantees createdAt, but default to 2025-01-01 if missing.
@@ -209,12 +218,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
 
       if (metadata) {
         // Restore from hash (overrides localStorage)
-        setSelectedWorkspace({
-          workspaceId: metadata.id,
-          projectPath: metadata.projectPath,
-          projectName: metadata.projectName,
-          namedWorkspacePath: metadata.namedWorkspacePath,
-        });
+        setSelectedWorkspace(toWorkspaceSelection(metadata));
       }
     } else if (hash.length > 1) {
       // Try to interpret hash as project path (for direct deep linking)
@@ -228,12 +232,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
 
       if (projectWorkspaces.length > 0) {
         const metadata = projectWorkspaces[0];
-        setSelectedWorkspace({
-          workspaceId: metadata.id,
-          projectPath: metadata.projectPath,
-          projectName: metadata.projectName,
-          namedWorkspacePath: metadata.namedWorkspacePath,
-        });
+        setSelectedWorkspace(toWorkspaceSelection(metadata));
       }
     }
     // Only run once when loading finishes
@@ -248,40 +247,53 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
     // Skip if we already have a selected workspace (from localStorage or URL hash)
     if (selectedWorkspace) return;
 
+    // Skip if user is in the middle of creating a workspace
+    if (pendingNewWorkspaceProject) return;
+
+    let cancelled = false;
+
     const checkLaunchProject = async () => {
       // Only available in server mode (checked via platform/capabilities in future)
       // For now, try the call - it will return null if not applicable
       try {
         const launchProjectPath = await api.server.getLaunchProject(undefined);
-        if (!launchProjectPath) return;
+        if (cancelled || !launchProjectPath) return;
 
         // Find first workspace in this project
         const projectWorkspaces = Array.from(workspaceMetadata.values()).filter(
           (meta) => meta.projectPath === launchProjectPath
         );
 
-        if (projectWorkspaces.length > 0) {
-          // Select the first workspace in the project
-          const metadata = projectWorkspaces[0];
-          setSelectedWorkspace({
-            workspaceId: metadata.id,
-            projectPath: metadata.projectPath,
-            projectName: metadata.projectName,
-            namedWorkspacePath: metadata.namedWorkspacePath,
-          });
-        }
+        if (cancelled || projectWorkspaces.length === 0) return;
+
+        // Select the first workspace in the project.
+        // Use functional update to avoid race: user may have clicked a workspace
+        // while this async call was in flight.
+        const metadata = projectWorkspaces[0];
+        setSelectedWorkspace((current) => current ?? toWorkspaceSelection(metadata));
       } catch (error) {
-        // Ignore errors (e.g. method not found if running against old backend)
-        console.debug("Failed to check launch project:", error);
+        if (!cancelled) {
+          // Ignore errors (e.g. method not found if running against old backend)
+          console.debug("Failed to check launch project:", error);
+        }
       }
       // If no workspaces exist yet, just leave the project in the sidebar
       // The user will need to create a workspace
     };
 
     void checkLaunchProject();
-    // Only run once when loading finishes or selectedWorkspace changes
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [loading, selectedWorkspace]);
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    api,
+    loading,
+    selectedWorkspace,
+    pendingNewWorkspaceProject,
+    workspaceMetadata,
+    setSelectedWorkspace,
+  ]);
 
   // Subscribe to metadata updates (for create/rename/delete operations)
   useEffect(() => {
diff --git a/src/browser/hooks/useStartWorkspaceCreation.ts b/src/browser/hooks/useStartWorkspaceCreation.ts
@@ -1,6 +1,5 @@
 import { useCallback, useEffect } from "react";
 import type { ProjectConfig } from "@/node/config";
-import type { WorkspaceSelection } from "@/browser/components/ProjectSidebar";
 import { CUSTOM_EVENTS, type CustomEventPayloads } from "@/common/constants/events";
 import { updatePersistedState } from "@/browser/hooks/usePersistedState";
 import {
@@ -53,7 +52,6 @@ export function persistWorkspaceCreationPrefill(
 interface UseStartWorkspaceCreationOptions {
   projects: Map<string, ProjectConfig>;
   beginWorkspaceCreation: (projectPath: string) => void;
-  setSelectedWorkspace: (selection: WorkspaceSelection | null) => void;
 }
 
 function resolveProjectPath(
@@ -70,7 +68,6 @@ function resolveProjectPath(
 export function useStartWorkspaceCreation({
   projects,
   beginWorkspaceCreation,
-  setSelectedWorkspace,
 }: UseStartWorkspaceCreationOptions) {
   const startWorkspaceCreation = useCallback(
     (projectPath: string, detail?: StartWorkspaceCreationDetail) => {
@@ -83,9 +80,8 @@ export function useStartWorkspaceCreation({
 
       persistWorkspaceCreationPrefill(resolvedProjectPath, detail);
       beginWorkspaceCreation(resolvedProjectPath);
-      setSelectedWorkspace(null);
     },
-    [projects, beginWorkspaceCreation, setSelectedWorkspace]
+    [projects, beginWorkspaceCreation]
   );
 
   useEffect(() => {
