fix(worktree): collapse duplicate "Local Mac" run targets in the host picker (#10472)

* fix(worktree): collapse duplicate "Local Mac" run targets in the host picker A linked worktree added as its own project projects a second ready host setup on the same project+host, so the run-target picker rendered N identical "Local Mac" rows differing only by path. Only the first was reachable — resolveWorkspaceCreationTarget takes the first project+host match — so the extras pointed at paths that may no longer exist. - Dedupe ready setup options by host in the picker (display fix for profiles that already hold duplicates). - Canonicalize a stale draft's setup id to the setup the picker shows, so the displayed path is the path the workspace is created in. - Reject a linked worktree at repos:add when its main checkout is already tracked, preventing new duplicates. * fix(worktree): only dedupe a linked worktree against a git main checkout Review follow-up: the repos:add guard matched any tracked repo on the main checkout path, including a folder-kind record. A folder repo does not project onto the same project as the git worktree, so matching it would suppress a legitimate add without deduping anything.
2026-10-20 08:03:28 +00:00 · 2026-07-25 15:38:35 -07:00
parent 56d3e2cb2e
commit eb545aaa59
8 changed files with 457 additions and 4 deletions
@@ -0,0 +1,193 @@
+/**
+ * Regression tests for repos:add + git worktrees.
+ *
+ * A linked worktree reports itself as its own `--show-toplevel`, so the path-based dedupe in
+ * addLocalRepoFromPath cannot see that it belongs to an already-tracked repo. Adding it anyway
+ * produced a second ready ProjectHostSetup on the same project and host — a duplicate "Local Mac"
+ * run-target row pointing at a transient worktree path.
+ */
+
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+import type { Repo } from '../../shared/types'
+
+const {
+  handleMock,
+  removeHandlerMock,
+  mockStore,
+  isGitRepoMock,
+  getGitRepoRootMock,
+  getLinkedWorktreeMainRepoRootMock,
+  invalidateAuthorizedRootsCacheMock,
+  prepareLocalWorktreeRootForRepoMock,
+  detectRepoIconAndUpstreamMock
+} = vi.hoisted(() => ({
+  handleMock: vi.fn(),
+  removeHandlerMock: vi.fn(),
+  mockStore: {
+    getRepos: vi.fn().mockReturnValue([]),
+    addRepo: vi.fn(),
+    removeProject: vi.fn(),
+    getRepo: vi.fn(),
+    updateRepo: vi.fn()
+  },
+  isGitRepoMock: vi.fn().mockReturnValue(true),
+  getGitRepoRootMock: vi.fn(),
+  getLinkedWorktreeMainRepoRootMock: vi.fn(),
+  invalidateAuthorizedRootsCacheMock: vi.fn(),
+  prepareLocalWorktreeRootForRepoMock: vi.fn(),
+  detectRepoIconAndUpstreamMock: vi.fn()
+}))
+
+vi.mock('electron', () => ({
+  dialog: { showOpenDialog: vi.fn() },
+  ipcMain: { handle: handleMock, removeHandler: removeHandlerMock }
+}))
+
+vi.mock('../git/repo', () => ({
+  isGitRepo: isGitRepoMock,
+  getGitRepoRoot: getGitRepoRootMock,
+  getLinkedWorktreeMainRepoRoot: getLinkedWorktreeMainRepoRootMock,
+  getRepoName: vi.fn().mockImplementation((path: string) => path.split('/').pop()),
+  getBaseRefDefault: vi.fn().mockResolvedValue('origin/main'),
+  searchBaseRefs: vi.fn().mockResolvedValue([])
+}))
+
+vi.mock('../repo-detection', () => ({
+  detectRepoIconAndUpstream: detectRepoIconAndUpstreamMock
+}))
+
+vi.mock('./filesystem-auth', () => ({
+  invalidateAuthorizedRootsCache: invalidateAuthorizedRootsCacheMock
+}))
+
+vi.mock('../worktree-root-preparation', () => ({
+  prepareLocalWorktreeRootForRepo: prepareLocalWorktreeRootForRepoMock
+}))
+
+vi.mock('../providers/ssh-git-dispatch', () => ({ getSshGitProvider: vi.fn() }))
+vi.mock('./ssh', () => ({ getActiveMultiplexer: vi.fn() }))
+
+import { registerRepoHandlers } from './repos'
+
+const MAIN_CHECKOUT = '/Users/dev/projects/orca'
+const LINKED_WORKTREE = '/Users/dev/orca/workspaces/orca/pr-3235'
+
+type AddResult = { repo: Repo } | { error: string }
+
+describe('repos:add with git worktrees', () => {
+  const handlers = new Map<string, (event: unknown, args: unknown) => unknown>()
+  const mockWindow = { isDestroyed: () => false, webContents: { send: vi.fn() } }
+
+  const trackedMainRepo = (): Repo =>
+    ({
+      id: 'main-repo-id',
+      path: MAIN_CHECKOUT,
+      displayName: 'orca',
+      badgeColor: '#ef4444',
+      addedAt: 1,
+      kind: 'git'
+    }) as Repo
+
+  const callAdd = (args: { path: string; kind?: 'git' | 'folder' }): Promise<AddResult> => {
+    const handler = handlers.get('repos:add')
+    if (!handler) {
+      throw new Error('repos:add handler was never registered')
+    }
+    return handler(null, args) as Promise<AddResult>
+  }
+
+  beforeEach(() => {
+    handlers.clear()
+    handleMock.mockReset()
+    handleMock.mockImplementation((channel: string, handler: (...a: unknown[]) => unknown) => {
+      handlers.set(channel, handler as (event: unknown, args: unknown) => unknown)
+    })
+    removeHandlerMock.mockReset()
+    mockStore.getRepos.mockReset().mockReturnValue([])
+    mockStore.addRepo.mockReset()
+    isGitRepoMock.mockReset().mockReturnValue(true)
+    // A linked worktree is its own toplevel — this is exactly why path dedupe alone misses it.
+    getGitRepoRootMock.mockReset().mockImplementation((path: string) => path)
+    getLinkedWorktreeMainRepoRootMock.mockReset().mockReturnValue(null)
+    detectRepoIconAndUpstreamMock.mockReset().mockResolvedValue({})
+    invalidateAuthorizedRootsCacheMock.mockReset()
+    prepareLocalWorktreeRootForRepoMock.mockReset().mockResolvedValue(undefined)
+
+    registerRepoHandlers(mockWindow as never, mockStore as never)
+  })
+
+  it('returns the tracked main checkout instead of adding its linked worktree', async () => {
+    mockStore.getRepos.mockReturnValue([trackedMainRepo()])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue(MAIN_CHECKOUT)
+
+    const result = await callAdd({ path: LINKED_WORKTREE })
+
+    expect(result).toEqual({ repo: expect.objectContaining({ id: 'main-repo-id' }) })
+    expect(mockStore.addRepo).not.toHaveBeenCalled()
+  })
+
+  it('still adds a linked worktree whose main checkout is not tracked', async () => {
+    mockStore.getRepos.mockReturnValue([])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue(MAIN_CHECKOUT)
+
+    const result = await callAdd({ path: LINKED_WORKTREE })
+
+    expect(mockStore.addRepo).toHaveBeenCalledTimes(1)
+    expect(result).toEqual({ repo: expect.objectContaining({ path: LINKED_WORKTREE }) })
+  })
+
+  it('adds a normal repo when git reports it is not a linked worktree', async () => {
+    mockStore.getRepos.mockReturnValue([trackedMainRepo()])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue(null)
+
+    const result = await callAdd({ path: '/Users/dev/projects/other' })
+
+    expect(mockStore.addRepo).toHaveBeenCalledTimes(1)
+    expect(result).toEqual({ repo: expect.objectContaining({ path: '/Users/dev/projects/other' }) })
+  })
+
+  it('does not consult worktree detection for folder projects', async () => {
+    mockStore.getRepos.mockReturnValue([trackedMainRepo()])
+
+    await callAdd({ path: '/Users/dev/notes', kind: 'folder' })
+
+    expect(getLinkedWorktreeMainRepoRootMock).not.toHaveBeenCalled()
+    expect(mockStore.addRepo).toHaveBeenCalledTimes(1)
+  })
+
+  it('matches the tracked main checkout across path separator differences', async () => {
+    mockStore.getRepos.mockReturnValue([
+      { ...trackedMainRepo(), path: 'C:\\Users\\dev\\projects\\orca' } as Repo
+    ])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue('C:/Users/dev/projects/orca')
+
+    const result = await callAdd({ path: 'C:/Users/dev/worktrees/pr-3235' })
+
+    expect(result).toEqual({ repo: expect.objectContaining({ id: 'main-repo-id' }) })
+    expect(mockStore.addRepo).not.toHaveBeenCalled()
+  })
+
+  it('does not match a folder record sitting on the main-checkout path', async () => {
+    mockStore.getRepos.mockReturnValue([
+      { ...trackedMainRepo(), id: 'folder-repo-id', kind: 'folder' } as Repo
+    ])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue(MAIN_CHECKOUT)
+
+    const result = await callAdd({ path: LINKED_WORKTREE })
+
+    expect(mockStore.addRepo).toHaveBeenCalledTimes(1)
+    expect(result).toEqual({ repo: expect.objectContaining({ path: LINKED_WORKTREE }) })
+  })
+
+  it('does not match a tracked SSH repo that shares the local main-checkout path', async () => {
+    mockStore.getRepos.mockReturnValue([
+      { ...trackedMainRepo(), id: 'ssh-repo-id', connectionId: 'builder' } as Repo
+    ])
+    getLinkedWorktreeMainRepoRootMock.mockReturnValue(MAIN_CHECKOUT)
+
+    const result = await callAdd({ path: LINKED_WORKTREE })
+
+    expect(mockStore.addRepo).toHaveBeenCalledTimes(1)
+    expect(result).toEqual({ repo: expect.objectContaining({ path: LINKED_WORKTREE }) })
+  })
+})
@@ -59,6 +59,7 @@ import { createNestedRepoImportTargetResolver } from '../project-groups/nested-r
 import {
  isGitRepo,
  getGitRepoRoot,
+  getLinkedWorktreeMainRepoRoot,
  getRepoName,
  getBaseRefDefault,
  getRemoteCount,
@@ -195,6 +196,29 @@ async function addLocalRepoFromPath(
    }
  }

+  // Why: a linked worktree reports itself as its own toplevel, so the path checks above can't see that
+  // it belongs to an already-tracked repo. Adding it anyway yields a second "ready" host setup on the
+  // same project and host — a duplicate run-target row that resolves to a transient worktree path.
+  if (repoKind === 'git') {
+    const mainRepoRoot = getLinkedWorktreeMainRepoRoot(resolvedPath)
+    if (mainRepoRoot) {
+      const mainRepoKey = normalizeRuntimePathForComparison(mainRepoRoot)
+      // Why !isFolderRepo: only a git-kind main checkout projects onto the same project as its
+      // worktree, so matching a folder record would suppress the add without deduping anything.
+      const trackedMainRepo = store
+        .getRepos()
+        .find(
+          (repo) =>
+            !repo.connectionId &&
+            !isFolderRepo(repo) &&
+            normalizeRuntimePathForComparison(repo.path) === mainRepoKey
+        )
+      if (trackedMainRepo) {
+        return { repo: trackedMainRepo, alreadyExisted: true }
+      }
+    }
+  }
+
  const detected = await detectRepoIconAndUpstream({ repoPath: resolvedPath, kind: repoKind })
  const repo: Repo = {
    id: randomUUID(),