Return to main worktree if the selected worktree is deleted outside the app

Closes #158

Author: pol-rivero

app/src/lib/git/worktree.ts

@@ -1,7 +1,9 @@
 import * as Path from 'path'
+import { readFile } from 'fs/promises'
 import type { Repository } from '../../models/repository'
 import type { WorktreeEntry, WorktreeType } from '../../models/worktree'
 import { git } from './core'
+import { directoryExists } from '../directory-exists'
 
 export function parseWorktreePorcelainOutput(
   stdout: string
@@ -64,6 +66,45 @@ export async function listWorktrees(
   return parseWorktreePorcelainOutput(result.stdout)
 }
 
+/**
+ * Path to the main worktree's working directory for a repository pointing at a
+ * linked worktree, derived purely from on-disk Git metadata so it still works
+ * when the linked worktree's working directory is gone.
+ *
+ * Returns null when it can't be determined (unknown `gitDir`) or doesn't exist.
+ */
+export async function getMainWorktreePath(
+  repository: Repository
+): Promise<string | null> {
+  const { gitDir } = repository
+  if (gitDir === undefined) {
+    return null
+  }
+
+  const commonDir = await resolveCommonGitDir(gitDir)
+  const mainWorktreePath = Path.dirname(commonDir)
+
+  if (!(await directoryExists(mainWorktreePath))) {
+    return null
+  }
+  return mainWorktreePath
+}
+
+async function resolveCommonGitDir(gitDir: string): Promise<string> {
+  if (Path.basename(Path.dirname(gitDir)) !== 'worktrees') {
+    return gitDir
+  }
+
+  // Prefer the `commondir` file, but fall back to the conventional layout (two
+  // levels up) when it's unreadable, e.g. `git worktree remove` deleted the
+  // worktree's admin files too.
+  const conventionalCommonDir = Path.dirname(Path.dirname(gitDir))
+  return readFile(Path.join(gitDir, 'commondir'), 'utf8')
+    .then(content => content.replace(/\r?\n$/, ''))
+    .then(p => (p ? Path.resolve(gitDir, p) : conventionalCommonDir))
+    .catch(() => conventionalCommonDir)
+}
+
 export async function addWorktree(
   repository: Repository,
   path: string,

app/src/lib/stores/app-store.ts

@@ -240,6 +240,7 @@ import {
   getRepositoryType,
   RepositoryType,
   listWorktrees,
+  getMainWorktreePath,
   removeWorktree,
   getCommitRangeDiff,
   getCommitRangeChangedFiles,
@@ -2573,6 +2574,16 @@ export class AppStore extends TypedBaseStore<IAppState> {
 
     // if repository might be marked missing, try checking if it has been restored
     const refreshedRepository = await this.recoverMissingRepository(repository)
+
+    // A removed linked worktree falls back to its main worktree instead of the
+    // missing-repository view.
+    const mainWorktreeRepository = await this.switchToMainWorktreeIfMissing(
+      refreshedRepository
+    )
+    if (mainWorktreeRepository !== null) {
+      return this._selectRepository(mainWorktreeRepository)
+    }
+
     if (refreshedRepository.missing) {
       // as the repository is no longer found on disk, cleaning this up
       // ensures we don't accidentally run any Git operations against the
@@ -4434,6 +4445,32 @@ export class AppStore extends TypedBaseStore<IAppState> {
     }
   }
 
+  /**
+   * If the repository points at a linked worktree that's gone from disk, switch
+   * it back to its main worktree so we don't needlessly show it as missing.
+   *
+   * Returns the repository pointing at the main worktree, or null if no switch
+   * happened (path still exists, not a linked worktree, or main worktree gone
+   * too). Validating the switched-to worktree is left to the following refresh.
+   */
+  private async switchToMainWorktreeIfMissing(
+    repository: Repository
+  ): Promise<Repository | null> {
+    if (await pathExists(repository.path)) {
+      return null
+    }
+
+    const mainWorktreePath = await getMainWorktreePath(repository)
+    if (mainWorktreePath === null) {
+      return null
+    }
+
+    const { repository: updatedRepository } =
+      await this.repositoriesStore.switchWorktree(repository, mainWorktreePath)
+
+    return updatedRepository
+  }
+
   private async recoverMissingRepository(
     repository: Repository
   ): Promise<Repository> {
@@ -4469,6 +4506,22 @@ export class AppStore extends TypedBaseStore<IAppState> {
     // set the flag and don't try anything Git-related
     const exists = await pathExists(repository.path)
     if (!exists) {
+      // Only for the selected repo, so a background refresh of another repo
+      // can't hijack the current selection by switching it to its main worktree.
+      const isSelected =
+        this.selectedRepository instanceof Repository &&
+        this.selectedRepository.id === repository.id
+
+      if (isSelected) {
+        const mainWorktreeRepository = await this.switchToMainWorktreeIfMissing(
+          repository
+        )
+        if (mainWorktreeRepository !== null) {
+          await this._selectRepository(mainWorktreeRepository)
+          return
+        }
+      }
+
       this._updateRepositoryMissing(repository, true)
       return
     }

app/test/unit/git/worktree-test.ts

@@ -1,13 +1,17 @@
 import assert from 'node:assert'
 import * as Path from 'path'
 import { describe, it } from 'node:test'
+import { rm } from 'fs/promises'
 import { exec } from 'dugite'
 import { setupEmptyRepository } from '../../helpers/repositories'
 import { makeCommit } from '../../helpers/repository-scaffolding'
 import {
   parseWorktreePorcelainOutput,
   listWorktrees,
+  getMainWorktreePath,
+  getRepositoryType,
 } from '../../../src/lib/git'
+import { Repository } from '../../../src/models/repository'
 
 describe('git/worktree', () => {
   describe('parseWorktreePorcelainOutput', () => {
@@ -293,4 +297,109 @@ describe('git/worktree', () => {
       assert(branches.has('refs/heads/main'))
     })
   })
+
+  describe('getMainWorktreePath', () => {
+    /** Build a Repository pointing at `path`, populating its real `gitDir`. */
+    async function repositoryAt(path: string): Promise<Repository> {
+      const type = await getRepositoryType(path)
+      const gitDir = type.kind === 'regular' ? type.gitDir : undefined
+      return new Repository(
+        path,
+        -1,
+        null,
+        false,
+        null,
+        null,
+        null,
+        {},
+        null,
+        false,
+        null,
+        gitDir
+      )
+    }
+
+    it('returns the main worktree path for a removed linked worktree', async t => {
+      const repo = await setupEmptyRepository(t, 'main')
+      await makeCommit(repo, {
+        entries: [{ path: 'README', contents: 'hello' }],
+      })
+      await exec(['branch', 'feature-a'], repo.path)
+
+      const worktreePath = repo.path + '-wt-a'
+      await exec(['worktree', 'add', worktreePath, 'feature-a'], repo.path)
+
+      const linkedRepo = await repositoryAt(worktreePath)
+
+      // rm leaves the worktree's admin files (and `commondir`) intact.
+      await rm(worktreePath, { recursive: true, force: true })
+
+      assert.strictEqual(
+        await getMainWorktreePath(linkedRepo),
+        Path.normalize(repo.path)
+      )
+    })
+
+    it('returns the main worktree path when the linked worktree was fully removed with `git worktree remove`', async t => {
+      const repo = await setupEmptyRepository(t, 'main')
+      await makeCommit(repo, {
+        entries: [{ path: 'README', contents: 'hello' }],
+      })
+      await exec(['branch', 'feature-a'], repo.path)
+      await exec(['branch', 'feature-b'], repo.path)
+
+      const worktreeA = repo.path + '-wt-a'
+      const worktreeB = repo.path + '-wt-b'
+      await exec(['worktree', 'add', worktreeA, 'feature-a'], repo.path)
+      await exec(['worktree', 'add', worktreeB, 'feature-b'], repo.path)
+
+      const linkedRepo = await repositoryAt(worktreeA)
+
+      // `git worktree remove` also deletes the admin files (so `commondir` is
+      // unreadable); worktree B keeps `.git/worktrees` itself on disk.
+      await exec(['worktree', 'remove', '--force', worktreeA], repo.path)
+
+      assert.strictEqual(
+        await getMainWorktreePath(linkedRepo),
+        Path.normalize(repo.path)
+      )
+    })
+
+    it('returns its own path when called on the main worktree', async t => {
+      const repo = await setupEmptyRepository(t, 'main')
+      await makeCommit(repo, {
+        entries: [{ path: 'README', contents: 'hello' }],
+      })
+
+      const mainRepo = await repositoryAt(repo.path)
+      assert.strictEqual(
+        await getMainWorktreePath(mainRepo),
+        Path.normalize(repo.path)
+      )
+    })
+
+    it('returns null when the repository gitDir is unknown', async t => {
+      const repo = await setupEmptyRepository(t, 'main')
+      assert.strictEqual(await getMainWorktreePath(repo), null)
+    })
+
+    it('returns null when the main worktree no longer exists on disk', async () => {
+      const missingRepo = new Repository(
+        Path.normalize('/this/path/does/not/exist'),
+        -1,
+        null,
+        false,
+        null,
+        null,
+        null,
+        {},
+        null,
+        false,
+        null,
+        Path.normalize('/this/path/does/not/exist/.git/worktrees/foo')
+      )
+
+      assert.strictEqual(await getMainWorktreePath(missingRepo), null)
+    })
+  })
 })