test(server): reproduce shared daemon lock loss across PID namespaces

Retain acquisition and stop regressions for #4307. These tests intentionally fail on main; they do not choose a namespace ownership or crash-recovery policy.

Co-authored-by: Cong Xu <3174585+xu-c@users.noreply.github.com>

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-O8sNh6oXFIddUljYiC6RbVZF5/7a7A7W9UWrOd0tIV4=
+sha256-tSE4nb4E06GFZ8I9UEbo93nlPiAKtW00nkywgKQmMhI=

packages/app/e2e/browser/sidebar-project-grouping.spec.ts

@@ -9,6 +9,8 @@ import {
   expectProjectWorkspaceCountForHost,
   expectSeparateProjects,
   openGroupedProjectSettings,
+  openGroupedProjectWorkspace,
+  expectWorkspaceHost,
   openProjectsForSettingsHost,
   openProjectDirectory,
   openProjectDirectoryWithHosts,
@@ -418,4 +420,29 @@ test.describe("Sidebar project grouping", () => {
       count: 2,
     });
   });
+  test("creates grouped project workspaces on the active workspace host", async ({
+    page,
+    crossHostProject,
+  }) => {
+    await openScenario(page, crossHostProject);
+    await openGroupedProjectWorkspace(page, GROUPED_PROJECT_NAME, "Secondary workspace");
+    await beginWorkspaceFromProject(page, GROUPED_PROJECT_NAME);
+    await expectWorkspaceHost(page, SECONDARY_HOST_LABEL);
+    await createWorkspaceWithoutAgent(page);
+    await expectProjectWorkspaceCountForHost(page, {
+      projectName: GROUPED_PROJECT_NAME,
+      hostName: SECONDARY_HOST_LABEL,
+      count: 2,
+    });
+
+    await openGroupedProjectWorkspace(page, GROUPED_PROJECT_NAME, "Primary workspace");
+    await beginWorkspaceFromProject(page, GROUPED_PROJECT_NAME);
+    await expectWorkspaceHost(page, PRIMARY_HOST_LABEL);
+    await createWorkspaceWithoutAgent(page);
+    await expectProjectWorkspaceCountForHost(page, {
+      projectName: GROUPED_PROJECT_NAME,
+      hostName: PRIMARY_HOST_LABEL,
+      count: 2,
+    });
+  });
 });

packages/app/e2e/support/helpers/project-grouping.ts

@@ -134,3 +134,19 @@ export async function expectProjectSettingsName(page: Page, projectName: string)
     timeout: PROJECT_VISIBILITY_TIMEOUT,
   });
 }
+
+export async function openGroupedProjectWorkspace(
+  page: Page,
+  projectName: string,
+  workspaceName: string,
+): Promise<void> {
+  await projectGroup(page, projectName)
+    .getByRole("button")
+    .filter({ hasText: workspaceName })
+    .click();
+  await expect(page).toHaveURL(/\/workspace\//);
+}
+
+export async function expectWorkspaceHost(page: Page, hostName: string): Promise<void> {
+  await expect(page.getByRole("button", { name: "Host", exact: true })).toContainText(hostName);
+}

packages/app/src/components/sidebar-workspace-list.tsx

@@ -41,7 +41,11 @@ import { ExternalLink, Settings, MoreVertical, Plus, Trash2 } from "lucide-react
 import { NestableScrollContainer } from "react-native-draggable-flatlist";
 import { DraggableList, type DraggableRenderItemInfo } from "./draggable-list";
 import type { DraggableListDragHandleProps } from "./draggable-list.types";
-import { getHostRuntimeStore, useHosts } from "@/runtime/host-runtime";
+import {
+  getHostRuntimeStore,
+  useHosts,
+  useHostRuntimeConnectionStatus,
+} from "@/runtime/host-runtime";
 import type { PinnedSidebarGroups } from "@/hooks/use-sidebar-pins";
 import {
   useSidebarWorkspacePinController,
@@ -1596,14 +1600,18 @@ function ProjectBlock({
     canToggle: canToggleWorkspaces,
     toggleExpanded: toggleWorkspacesExpanded,
   } = useLimitedSidebarGroup(project.workspaces);
+  const activeServerId = activeWorkspaceSelection?.serverId ?? null;
+  const activeHostStatus = useHostRuntimeConnectionStatus(activeServerId ?? "");
+  const preferredServerId = activeHostStatus === "online" ? activeServerId : null;
   const rowModel = useMemo(
     () =>
       buildSidebarProjectRowModel({
         project,
         collapsed,
         supportsMultiplicityByServerId,
+        preferredServerId,
       }),
-    [collapsed, project, supportsMultiplicityByServerId],
+    [collapsed, preferredServerId, project, supportsMultiplicityByServerId],
   );
 
   // Collapsed rows hide their workspace rows, so the project row carries the most urgent
@@ -1848,6 +1856,7 @@ function areProjectBlockPropsEqual(previous: ProjectBlockProps, next: ProjectBlo
     previous.useNestable === next.useNestable &&
     previous.dragGestureHostActive === next.dragGestureHostActive &&
     previous.creatingWorkspaceIds === next.creatingWorkspaceIds &&
+    previous.activeWorkspaceSelection?.serverId === next.activeWorkspaceSelection?.serverId &&
     areProjectBlockSelectionsEqual(previous, next)
   );
 }

packages/app/src/utils/sidebar-project-row-model.test.ts

@@ -65,6 +65,45 @@ function project(overrides: ProjectOverrides = {}): SidebarProjectEntry {
 }
 
 describe("buildSidebarProjectRowModel", () => {
+  it("prefers the active host when the grouped project can create there", () => {
+    const result = buildSidebarProjectRowModel({
+      project: project({
+        hosts: [
+          { serverId: "host-a", iconWorkingDir: "/repo/a", worktreeSupport: "supported" },
+          { serverId: "host-b", iconWorkingDir: "/repo/b", worktreeSupport: "supported" },
+        ],
+      }),
+      collapsed: false,
+      preferredServerId: "host-b",
+    });
+
+    expect(result.trailingAction).toEqual({
+      kind: "new_workspace",
+      target: { serverId: "host-b", projectId: "project-host-b", iconWorkingDir: "/repo/b" },
+    });
+  });
+
+  it.each(["host-b", "another-host"])(
+    "keeps the first eligible placement when preferred host %s cannot create here",
+    (preferredServerId) => {
+      const result = buildSidebarProjectRowModel({
+        project: project({
+          hosts: [
+            { serverId: "host-a", iconWorkingDir: "/repo/a", worktreeSupport: "supported" },
+            { serverId: "host-b", iconWorkingDir: "/repo/b", worktreeSupport: "unsupported" },
+          ],
+        }),
+        collapsed: false,
+        preferredServerId,
+      });
+
+      expect(result.trailingAction).toEqual({
+        kind: "new_workspace",
+        target: { serverId: "host-a", projectId: "project-host-a", iconWorkingDir: "/repo/a" },
+      });
+    },
+  );
+
   it("renders a non-git single-workspace project as an expandable section", () => {
     const result = buildSidebarProjectRowModel({
       project: project({

packages/app/src/utils/sidebar-project-row-model.ts

@@ -85,7 +85,9 @@ export function resolveSidebarProjectLocalPath(
 function resolveNewWorkspaceTarget(
   project: SidebarProjectEntry,
   supportsMultiplicityByServerId: ReadonlyMap<string, boolean>,
+  preferredServerId: string | null | undefined,
 ): SidebarProjectHostTarget | null {
+  let fallbackTarget: SidebarProjectHostTarget | null = null;
   for (const host of project.hosts) {
     if (
       host.worktreeSupport === "unsupported" &&
@@ -94,22 +96,30 @@ function resolveNewWorkspaceTarget(
       continue;
     }
     const target = hostTarget(host);
-    if (target) return target;
+    if (!target) continue;
+    if (host.serverId === preferredServerId) return target;
+    fallbackTarget ??= target;
   }
-  return null;
+  return fallbackTarget;
 }
 
 function projectTrailingAction(
   project: SidebarProjectEntry,
   supportsMultiplicityByServerId: ReadonlyMap<string, boolean>,
+  preferredServerId: string | null | undefined,
 ): SidebarProjectTrailingAction {
-  const target = resolveNewWorkspaceTarget(project, supportsMultiplicityByServerId);
+  const target = resolveNewWorkspaceTarget(
+    project,
+    supportsMultiplicityByServerId,
+    preferredServerId,
+  );
   return target ? { kind: "new_workspace", target } : { kind: "none" };
 }
 
 export function buildSidebarProjectRowModel(input: {
   project: SidebarProjectEntry;
   collapsed: boolean;
+  preferredServerId?: string | null;
   supportsMultiplicityByServerId?: ReadonlyMap<string, boolean>;
 }): SidebarProjectRowModel {
   return {
@@ -118,6 +128,7 @@ export function buildSidebarProjectRowModel(input: {
     trailingAction: projectTrailingAction(
       input.project,
       input.supportsMultiplicityByServerId ?? EMPTY_MULTIPLICITY_MAP,
+      input.preferredServerId,
     ),
   };
 }

packages/server/src/server/pid-lock-namespace.test.ts

@@ -0,0 +1,43 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { stopDaemonInstance } from "./daemon-instance.js";
+import { acquirePidLock } from "./pid-lock.js";
+
+// A shared home exposes a live supervisor's lock to a PID namespace in which its PID
+// does not exist. The Docker reproduction in #4307 establishes that condition; these
+// filesystem tests retain it without requiring a container runtime in the unit suite.
+async function withUnseenOwner(run: (home: string, contents: string) => Promise<void>) {
+  const home = await mkdtemp(join(tmpdir(), "paseo-unseen-owner-"));
+  const contents = JSON.stringify({
+    pid: 2_147_483_647,
+    startedAt: new Date().toISOString(),
+    hostname: "shared-host",
+    uid: process.getuid?.() ?? 0,
+    listen: null,
+    heartbeat: true,
+  });
+  try {
+    await writeFile(join(home, "paseo.pid"), contents);
+    await run(home, contents);
+  } finally {
+    await rm(home, { recursive: true, force: true });
+  }
+}
+
+test("acquiring a lock preserves a fresh heartbeat from an unseen owner", async () => {
+  await withUnseenOwner(async (home, contents) => {
+    await expect(acquirePidLock(home, null)).rejects.toThrow();
+    expect(await readFile(join(home, "paseo.pid"), "utf8")).toBe(contents);
+  });
+});
+
+test("stopping an unseen owner preserves its fresh shared lock", async () => {
+  await withUnseenOwner(async (home, contents) => {
+    // Either refusing the operation or returning without modifying the foreign lock is safe.
+    // The failure being locked down is deleting the live supervisor's lock.
+    await stopDaemonInstance(home).catch(() => undefined);
+    expect(await readFile(join(home, "paseo.pid"), "utf8")).toBe(contents);
+  });
+});