git-workspace-bare 0.1.1 → 0.3.0

package/lib/rename-root.js

@@ -5,7 +5,7 @@ import { manifestDirectory, updateRegistry } from './registry.js'
 import repositoryPath from './repository-path.js'
 import removeEmptyParents from './remove-empty-parents.js'
 
-export default function renameRoot(from, to) {
+export default function renameRoot(from, to, { update = updateRegistry } = {}) {
   const source = repositoryPath(from)
   const destination = repositoryPath(to)
   if (from === to) throw new Error(`${to} is already the registered name`)
@@ -13,101 +13,100 @@ export default function renameRoot(from, to) {
   const moved = []
   let originalConfig
   try {
-    updateRegistry((worktrees) => {
-      if (!worktrees.includes(source)) throw new Error(`${from} is not registered`)
-      if (!exists(source)) throw new Error(`${from} is not checked out`)
-      const canonical = fs.realpathSync(source)
-      if (canonical === fs.realpathSync(manifestDirectory())) {
-        throw new Error('Cannot rename the active manifest repository')
-      }
-      const gitDirectory = path.join(canonical, '.git')
-      if (
-        fs.lstatSync(source).isSymbolicLink() ||
-        !fs.lstatSync(gitDirectory).isDirectory() ||
-        fs.realpathSync(git(source, 'rev-parse', '--show-toplevel')) !== canonical ||
-        fs.realpathSync(git(source, 'rev-parse', '--path-format=absolute', '--git-common-dir')) !==
-          gitDirectory
-      ) {
-        throw new Error('Source is not a standalone root repository')
-      }
-
-      const urls = configValues(source, 'remote.origin.url')
-      if (urls.length !== 1 || !matches(urls[0], from, to)) {
-        throw new Error(`Source origin does not match ${from} or ${to}`)
-      }
-      const pushurls = configValues(source, 'remote.origin.pushurl')
-      const entries = git(source, 'worktree', 'list', '--porcelain', '-z')
-        .split('\0\0')
-        .filter(Boolean)
-        .map((entry) => entry.split('\0'))
-      const moves = [[source, destination]]
-      for (const entry of entries.slice(1)) {
-        const directory = entry[0].slice('worktree '.length)
-        if (!exists(directory)) {
-          throw new Error(`Missing linked worktree: ${directory}; repair or prune it first`)
+    update(
+      (worktrees) => {
+        if (!worktrees.includes(source)) throw new Error(`${from} is not registered`)
+        if (!exists(source)) throw new Error(`${from} is not checked out`)
+        const canonical = fs.realpathSync(source)
+        if (canonical === fs.realpathSync(manifestDirectory())) {
+          throw new Error('Cannot rename the active manifest repository')
         }
+        const gitDirectory = path.join(canonical, '.git')
         if (
-          fs.realpathSync(git(directory, 'rev-parse', '--show-toplevel')) !==
-            fs.realpathSync(directory) ||
+          fs.lstatSync(source).isSymbolicLink() ||
+          !fs.lstatSync(gitDirectory).isDirectory() ||
+          fs.realpathSync(git(source, 'rev-parse', '--show-toplevel')) !== canonical ||
           fs.realpathSync(
-            git(directory, 'rev-parse', '--path-format=absolute', '--git-common-dir')
+            git(source, 'rev-parse', '--path-format=absolute', '--git-common-dir')
           ) !== gitDirectory
         ) {
-          throw new Error(`Linked worktree needs repair: ${directory}`)
+          throw new Error('Source is not a standalone root repository')
         }
-        // Worktree repair does not repair the separate Git links inside submodules.
-        if (
-          git(directory, 'ls-files', '--stage', '-z')
-            .split('\0')
-            .some((entry) => entry.startsWith('160000 '))
-        ) {
-          throw new Error(`Linked worktree contains submodules: ${directory}`)
-        }
-        if (!directory.startsWith(source + '@')) continue
-        if (entry.some((field) => field === 'locked' || field.startsWith('locked '))) {
-          throw new Error(`Linked worktree is locked: ${directory}`)
+
+        const urls = configValues(source, 'remote.origin.url')
+        if (urls.length !== 1 || !matches(urls[0], from, to)) {
+          throw new Error(`Source origin does not match ${from} or ${to}`)
         }
-        if (fs.lstatSync(directory).isSymbolicLink()) {
-          throw new Error(`Linked worktree is a symbolic link: ${directory}`)
+        const pushurls = configValues(source, 'remote.origin.pushurl')
+        const entries = git(source, 'worktree', 'list', '--porcelain', '-z')
+          .split('\0\0')
+          .filter(Boolean)
+          .map((entry) => entry.split('\0'))
+        const moves = [[source, destination]]
+        for (const entry of entries.slice(1)) {
+          const directory = entry[0].slice('worktree '.length)
+          if (!exists(directory)) {
+            throw new Error(`Missing linked worktree: ${directory}; repair or prune it first`)
+          }
+          if (
+            fs.realpathSync(git(directory, 'rev-parse', '--show-toplevel')) !==
+              fs.realpathSync(directory) ||
+            fs.realpathSync(
+              git(directory, 'rev-parse', '--path-format=absolute', '--git-common-dir')
+            ) !== gitDirectory
+          ) {
+            throw new Error(`Linked worktree needs repair: ${directory}`)
+          }
+          // Worktree repair does not repair the separate Git links inside submodules.
+          if (
+            git(directory, 'ls-files', '--stage', '-z')
+              .split('\0')
+              .some((entry) => entry.startsWith('160000 '))
+          ) {
+            throw new Error(`Linked worktree contains submodules: ${directory}`)
+          }
+          if (!directory.startsWith(source + '@')) continue
+          if (entry.some((field) => field === 'locked' || field.startsWith('locked '))) {
+            throw new Error(`Linked worktree is locked: ${directory}`)
+          }
+          if (fs.lstatSync(directory).isSymbolicLink()) {
+            throw new Error(`Linked worktree is a symbolic link: ${directory}`)
+          }
+          moves.push([directory, destination + directory.slice(source.length)])
         }
-        moves.push([directory, destination + directory.slice(source.length)])
-      }
-      const mapping = new Map(moves)
-      for (const directory of worktrees) {
-        if (directory.startsWith(source + '@') && !mapping.has(directory)) {
-          throw new Error(
-            `Registered worktree is missing or does not belong to ${from}: ${directory}`
-          )
+        const mapping = new Map(moves)
+        for (const directory of worktrees) {
+          if (directory.startsWith(source + '@') && !mapping.has(directory)) {
+            throw new Error(
+              `Registered worktree is missing or does not belong to ${from}: ${directory}`
+            )
+          }
+          if (directory === destination || directory.startsWith(destination + '@')) {
+            throw new Error(`${to} already has registered checkouts`)
+          }
         }
-        if (directory === destination || directory.startsWith(destination + '@')) {
-          throw new Error(`${to} already has registered checkouts`)
+        for (const [, target] of moves) {
+          if (exists(target)) throw new Error(`${target} already exists`)
+          // Resolve parents before any moves, including nested branch destinations.
+          fs.mkdirSync(path.dirname(target), { recursive: true })
         }
-      }
-      for (const [, target] of moves) {
-        if (exists(target)) throw new Error(`${target} already exists`)
-        // Resolve parents before any moves, including nested branch destinations.
-        fs.mkdirSync(path.dirname(target), { recursive: true })
-      }
 
-      originalConfig = fs.readFileSync(path.join(source, '.git', 'config'))
-      for (const [oldPath, newPath] of moves) {
-        fs.renameSync(oldPath, newPath)
-        moved.push([oldPath, newPath])
-      }
-      const linked = entries.slice(1).map((entry) => {
-        const directory = entry[0].slice('worktree '.length)
-        return mapping.get(directory) || directory
-      })
-      git(destination, 'worktree', 'repair', ...linked)
-      git(destination, 'config', 'remote.origin.url', replaceURL(urls[0], from, to))
-      if (pushurls.length) {
-        git(destination, 'config', '--unset-all', 'remote.origin.pushurl')
-        for (const url of pushurls) {
-          git(destination, 'config', '--add', 'remote.origin.pushurl', replaceURL(url, from, to))
+        originalConfig = fs.readFileSync(path.join(source, '.git', 'config'))
+        for (const [oldPath, newPath] of moves) {
+          fs.renameSync(oldPath, newPath)
+          moved.push([oldPath, newPath])
         }
-      }
-      return worktrees.map((directory) => mapping.get(directory) || directory)
-    })
+        const linked = entries.slice(1).map((entry) => {
+          const directory = entry[0].slice('worktree '.length)
+          return mapping.get(directory) || directory
+        })
+        git(destination, 'worktree', 'repair', ...linked)
+        git(destination, 'config', 'remote.origin.url', replaceURL(urls[0], from, to))
+        replacePushURLs(destination, pushurls, from, to)
+        return worktrees.map((directory) => mapping.get(directory) || directory)
+      },
+      { rename: { from, to } }
+    )
   } catch (err) {
     if (moved.length) {
       try {
@@ -126,6 +125,105 @@ export default function renameRoot(from, to) {
   )
 }
 
+// Finish a root move interrupted before Git links or origin were repaired.
+// Validate the on-disk Git pointers before moving or repairing any worktree.
+export function finishRootRename(from, to, registered) {
+  const source = repositoryPath(from)
+  const destination = repositoryPath(to)
+  if (exists(source)) throw new Error('Original root still exists; cannot finish its move')
+  if (fs.lstatSync(destination).isSymbolicLink()) throw new Error('Renamed root is a symbolic link')
+  const common = path.join(destination, '.git')
+  if (
+    !fs.lstatSync(common).isDirectory() ||
+    fs.realpathSync(git(destination, 'rev-parse', '--path-format=absolute', '--git-common-dir')) !==
+      fs.realpathSync(common) ||
+    fs.realpathSync(git(destination, 'rev-parse', '--show-toplevel')) !==
+      fs.realpathSync(destination)
+  ) {
+    throw new Error('Renamed destination is not a standalone root repository')
+  }
+  if (fs.realpathSync(destination) === fs.realpathSync(manifestDirectory())) {
+    throw new Error('Cannot rename the active manifest repository')
+  }
+  const urls = configValues(destination, 'remote.origin.url')
+  if (urls.length !== 1 || !matches(urls[0], from, to)) {
+    throw new Error('Renamed root has an unexpected origin')
+  }
+  const pushurls = configValues(destination, 'remote.origin.pushurl')
+  const entries = git(destination, 'worktree', 'list', '--porcelain', '-z')
+    .split('\0\0')
+    .filter(Boolean)
+    .slice(1)
+    .map((entry) => entry.split('\0'))
+  const moves = entries.map((entry) => {
+    const oldPath = entry[0].slice('worktree '.length)
+    const owned = oldPath.startsWith(source + '@') || oldPath.startsWith(destination + '@')
+    const target = oldPath.startsWith(source + '@')
+      ? destination + oldPath.slice(source.length)
+      : oldPath
+    if (owned && entry.some((field) => field === 'locked' || field.startsWith('locked '))) {
+      throw new Error(`Linked worktree is locked: ${oldPath}`)
+    }
+    if (oldPath !== target && exists(oldPath) && exists(target)) {
+      throw new Error(`Both worktree paths exist: ${oldPath} and ${target}`)
+    }
+    const actual = exists(target) ? target : oldPath
+    if (!exists(actual) || fs.lstatSync(actual).isSymbolicLink()) {
+      throw new Error(`Missing or symbolic linked worktree: ${actual}`)
+    }
+    const pointerFile = path.join(actual, '.git')
+    if (!fs.lstatSync(pointerFile).isFile()) throw new Error(`Invalid Git pointer: ${actual}`)
+    const pointer = /^gitdir: (.+)\r?\n?$/.exec(fs.readFileSync(pointerFile, 'utf8'))
+    if (!pointer) throw new Error(`Invalid Git pointer: ${actual}`)
+    let metadata = path.resolve(actual, pointer[1])
+    if (metadata.startsWith(path.join(source, '.git/worktrees') + path.sep)) {
+      metadata = common + metadata.slice(path.join(source, '.git').length)
+    }
+    if (path.dirname(metadata) !== path.join(common, 'worktrees')) {
+      throw new Error(`Worktree belongs to another repository: ${actual}`)
+    }
+    const backlink = fs.readFileSync(path.join(metadata, 'gitdir'), 'utf8').trim()
+    if (![path.join(oldPath, '.git'), path.join(target, '.git')].includes(backlink)) {
+      throw new Error(`Unexpected worktree backlink: ${actual}`)
+    }
+    return [actual, target]
+  })
+  for (const directory of registered.filter((name) => name.startsWith(source + '@'))) {
+    if (!moves.some(([, target]) => target === destination + directory.slice(source.length))) {
+      throw new Error(`Missing registered worktree: ${directory}`)
+    }
+  }
+  for (const [actual, target] of moves) {
+    if (actual === target) continue
+    fs.mkdirSync(path.dirname(target), { recursive: true })
+    fs.renameSync(actual, target)
+  }
+  git(destination, 'worktree', 'repair', ...moves.map(([, target]) => target))
+  git(destination, 'config', 'remote.origin.url', replaceURL(urls[0], from, to))
+  replacePushURLs(destination, pushurls, from, to)
+  for (const directory of registered.filter((name) => name.startsWith(source + '@'))) {
+    removeEmptyParents(directory, path.dirname(source))
+  }
+}
+
+// Set each push URL in place, so an interruption cannot lose the remaining URLs.
+function replacePushURLs(destination, pushurls, from, to) {
+  for (const url of pushurls) {
+    const replacement = replaceURL(url, from, to)
+    if (replacement !== url) {
+      git(
+        destination,
+        'config',
+        '--fixed-value',
+        '--replace-all',
+        'remote.origin.pushurl',
+        replacement,
+        url
+      )
+    }
+  }
+}
+
 function matches(url, from, to) {
   const match = parseURL(url)
   return match && [from.toLowerCase(), to.toLowerCase()].includes(match[2].toLowerCase())

package/lib/rename.js

@@ -1,18 +1,38 @@
 import fs from 'bare-fs'
 import path from 'bare-path'
 import { spawnSync } from 'bare-subprocess'
-import { updateRegistry } from './registry.js'
+import { manifestDirectory, updateRegistry } from './registry.js'
 import repositoryPath from './repository-path.js'
 import checkedOutBranch from './checked-out-branch.js'
 import removeEmptyParents from './remove-empty-parents.js'
 import renameRoot from './rename-root.js'
+import commitManifest from './commit-manifest.js'
+import { refreshCheckpoint } from './checkpoint.js'
+import { assertNoPendingPull } from './pull-state.js'
+import { withPostHooks } from './hook-context.js'
 
-export default function rename(from, to) {
+export default function rename(from, to, options = {}) {
+  assertNoPendingPull()
+  return withPostHooks('rename', { from, to }, options, () => {
+    renameCheckout(from, to)
+    try {
+      commitManifest(manifestDirectory(), `Rename ${from} to ${to}`)
+    } catch (err) {
+      err.message = `Renamed ${from} to ${to}, but could not commit the manifest: ${err.message}`
+      err.hint =
+        'the rename is already complete; resolve the Git error and commit only workspace.json in the manifest repository'
+      throw err
+    }
+    refreshCheckpoint()
+  })
+}
+
+export function renameCheckout(from, to, { update = updateRegistry } = {}) {
   const source = repositoryPath(from)
   const destination = repositoryPath(to)
   const [base, requested] = from.split('@')
   const [target, branch] = to.split('@')
-  if (!requested && !branch) return renameRoot(from, to)
+  if (!requested && !branch) return renameRoot(from, to, { update })
   if (!requested || !branch) {
     throw new Error('Use owner/repo on both sides, or owner/repo@branch on both sides')
   }
@@ -55,20 +75,76 @@ export default function rename(from, to) {
     throw new Error(`${destination} already exists`)
   }
 
-  updateRegistry((worktrees) => {
-    const registered = worktrees.includes(source) ? source : canonical
-    if (!worktrees.includes(registered)) {
-      throw new Error(`${from} is not registered`)
-    }
-    fs.mkdirSync(path.dirname(destination), { recursive: true })
-    git(['-C', root, 'worktree', 'move', canonical, destination])
-    if (current !== branch) {
-      git(['-C', root, 'branch', '-m', current, branch])
-      retargetUpstream(root, branch)
+  update(
+    (worktrees) => {
+      const registered = worktrees.includes(source) ? source : canonical
+      if (!worktrees.includes(registered)) {
+        throw new Error(`${from} is not registered`)
+      }
+      if (worktrees.includes(destination)) throw new Error(`${to} is already registered`)
+      fs.mkdirSync(path.dirname(destination), { recursive: true })
+      git(['-C', root, 'worktree', 'move', canonical, destination])
+      if (current !== branch) {
+        git(['-C', root, 'branch', '-m', current, branch])
+        retargetUpstream(root, branch)
+      }
+      removeEmptyParents(source, path.dirname(root))
+      return worktrees.map((worktree) => (worktree === registered ? destination : worktree))
+    },
+    { rename: { from, to } }
+  )
+}
+
+export function finishBranchRename(from, to) {
+  const [base, original] = from.split('@')
+  const [target, branch] = to.split('@')
+  if (!original || !branch || base !== target) throw new Error('Invalid interrupted branch rename')
+  const root = repositoryPath(base)
+  const destination = repositoryPath(to)
+  if (fs.lstatSync(destination).isSymbolicLink()) {
+    throw new Error('Renamed worktree is a symbolic link')
+  }
+  const common = (directory) =>
+    fs.realpathSync(
+      git(['-C', directory, 'rev-parse', '--path-format=absolute', '--git-common-dir'])
+    )
+  if (
+    fs.realpathSync(git(['-C', destination, 'rev-parse', '--show-toplevel'])) !==
+      fs.realpathSync(destination) ||
+    common(root) !== common(destination)
+  ) {
+    throw new Error('Renamed destination is not a worktree of the requested repository')
+  }
+  const current = checkedOutBranch(destination)
+  if (current === original) {
+    if (hasRef(root, `refs/heads/${branch}`)) throw new Error(`Branch ${branch} already exists`)
+    git(['-C', root, 'branch', '-m', original, branch])
+  } else if (current !== branch) {
+    throw new Error(`Renamed worktree is on an unexpected branch: ${current || 'detached HEAD'}`)
+  }
+  if (hasRef(root, `refs/heads/${original}`)) {
+    throw new Error(
+      `Original branch ${original} still exists after the rename; inspect it before retrying`
+    )
+  }
+  // Git can rename the ref before failing to rename the config section.
+  if (!hasRef(root, `refs/heads/${original}`)) {
+    const section = spawnSync('git', [
+      '-C',
+      root,
+      'config',
+      '--get-regexp',
+      `^branch\\.${original.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.`
+    ])
+    if (section.error) throw section.error
+    if (section.status === 0) {
+      git(['-C', root, 'config', '--rename-section', `branch.${original}`, `branch.${branch}`])
+    } else if (section.status !== 1) {
+      throw new Error(section.stderr.toString().trim() || 'Could not inspect branch config')
     }
-    removeEmptyParents(source, path.dirname(root))
-    return worktrees.map((worktree) => (worktree === registered ? destination : worktree))
-  })
+  }
+  retargetUpstream(root, branch)
+  removeEmptyParents(repositoryPath(from), path.dirname(root))
 }
 
 function retargetUpstream(root, branch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-workspace-bare",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Manage Git worktrees as development workspaces",
   "type": "module",
   "bin": {
@@ -13,6 +13,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
+    "bare-crypto": "^1.15.3",
+    "bare-env": "^3.0.1",
     "bare-fs": "^4.8.1",
     "bare-os": "^3.9.3",
     "bare-path": "^3.1.2",