git-workspace-bare 0.1.1 → 0.3.0

package/lib/plan-pull.js

@@ -0,0 +1,332 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import { spawnSync } from 'bare-subprocess'
+import { validateManifest } from './manifest.js'
+import { verifyCheckouts } from './checkpoint.js'
+import repositoryPath from './repository-path.js'
+
+// Plan dependencies before consulting the filesystem: remove children first,
+// rename roots before their branches, and add parents before children.
+export function changes(previous, desired) {
+  validateManifest(previous)
+  validateManifest(desired)
+  const before = entries(previous)
+  const after = entries(desired)
+  const actions = []
+  const blockers = []
+  for (const entry of before.values()) {
+    const next = after.get(entry.id)
+    if (next && (next.kind !== entry.kind || next.root !== entry.root)) {
+      blockers.push(`Identity ${entry.id} changes entry type or parent repository`)
+      continue
+    }
+    if (!next) actions.push({ type: 'remove', ...entry, from: entry.name })
+    else if (entry.kind === 'repository' && entry.name !== next.name) {
+      actions.push({ type: 'rename', ...entry, from: entry.name, to: next.name })
+    } else if (entry.kind === 'worktree' && entry.branch !== next.branch) {
+      const root = after.get(entry.root)
+      actions.push({
+        type: 'rename',
+        ...entry,
+        source: entry.name,
+        from: `${root.name}@${entry.branch}`,
+        to: next.name
+      })
+    }
+  }
+  for (const entry of after.values()) {
+    if (!before.has(entry.id)) actions.push({ type: 'add', ...entry, to: entry.name })
+  }
+  const order = (action) => {
+    const child = action.kind === 'worktree'
+    if (action.type === 'remove') return child ? 0 : 1
+    if (action.type === 'rename') return child ? 3 : 2
+    return child ? 5 : 4
+  }
+  actions.sort((a, b) => order(a) - order(b) || a.name.localeCompare(b.name))
+  return { actions, blockers }
+}
+
+export default function planPull(previous, desired, manifestDirectory) {
+  const plan = changes(previous, desired)
+  if (plan.blockers.length) return plan
+  const before = entries(previous)
+  const removals = new Set(plan.actions.filter((a) => a.type === 'remove').map((a) => a.name))
+  const removedPaths = new Set([...removals].map(repositoryPath))
+  const roots = new Map()
+  const rootRenames = new Map(
+    plan.actions.filter((a) => a.type === 'rename' && a.kind === 'repository').map((a) => [a.id, a])
+  )
+  const attempt = (label, fn) => {
+    try {
+      fn()
+    } catch (err) {
+      plan.blockers.push(`${label}: ${err.message}`)
+    }
+  }
+  const verify = (repository, worktrees = [], retired = new Set()) =>
+    verifyCheckouts({ repositories: [{ ...repository, worktrees }] }, retired, rootRenames)
+
+  for (const repository of desired.repositories) {
+    for (const worktree of repository.worktrees) {
+      attempt(`${repository.name}@${worktree.branch}`, () => {
+        git(manifestDirectory, ['check-ref-format', '--branch', worktree.branch])
+        if (repository.worktrees.some((other) => worktree.branch.startsWith(other.branch + '/'))) {
+          throw new Error('Branch name conflicts with another desired branch prefix')
+        }
+      })
+    }
+  }
+
+  for (const repository of previous.repositories) {
+    const directory = repositoryPath(repository.name)
+    if (!exists(directory) && removals.has(repository.name)) {
+      roots.set(repository.id, { name: repository.name, directory, listed: [] })
+      continue
+    }
+    attempt(repository.name, () => {
+      verify(repository)
+      const listed = worktrees(directory)
+      roots.set(repository.id, { name: repository.name, directory, listed })
+    })
+    for (const worktree of repository.worktrees) {
+      const name = `${repository.name}@${worktree.branch}`
+      if (!exists(repositoryPath(name)) && removals.has(name)) continue
+      attempt(name, () => verify(repository, [worktree]))
+    }
+  }
+
+  // Existing untracked destinations may be adopted only on initial/add setup.
+  // A reused path with an old ID is removed and recreated, never silently adopted.
+  for (const repository of desired.repositories) {
+    if (before.has(repository.id)) continue
+    const directory = repositoryPath(repository.name)
+    if (!exists(directory) || removals.has(repository.name)) continue
+    attempt(repository.name, () => {
+      verify(repository)
+      roots.set(repository.id, { name: repository.name, directory, listed: worktrees(directory) })
+    })
+  }
+
+  for (const action of plan.actions) {
+    attempt(`${action.type} ${action.from || action.to}`, () => {
+      const root = roots.get(action.kind === 'repository' ? action.id : action.root)
+      const physicalSource = action.source || action.from
+      if (action.type === 'remove') {
+        const directory = repositoryPath(action.from)
+        if (exists(directory)) {
+          protectedManifest(directory, manifestDirectory)
+          if (fs.lstatSync(directory).isSymbolicLink()) {
+            throw new Error('Checkout is a symbolic link')
+          }
+          if (
+            git(directory, [
+              'status',
+              '--porcelain',
+              '--untracked-files=all',
+              '--ignore-submodules=none'
+            ])
+          ) {
+            throw new Error('Local changes or untracked files would be removed')
+          }
+        }
+        if (root) {
+          if (action.kind === 'repository') {
+            for (const entry of root.listed.slice(1)) {
+              const name = [...before.values()].find(
+                (item) => repositoryPath(item.name) === entry.directory
+              )?.name
+              if (!name || !removals.has(name)) {
+                throw new Error(`Linked worktree would remain: ${entry.directory}`)
+              }
+            }
+          } else {
+            const entry = root.listed.find((entry) => entry.directory === directory)
+            if (entry?.locked) throw new Error('Worktree is locked')
+            if (entry && !exists(directory)) {
+              throw new Error('Missing worktree still has a Git record; repair or prune it first')
+            }
+          }
+        }
+        return
+      }
+
+      if (action.type === 'rename') {
+        const source = repositoryPath(physicalSource)
+        if (!exists(source)) throw new Error(`Missing checkout: ${physicalSource}`)
+        protectedManifest(source, manifestDirectory)
+        if (action.kind === 'repository' && root) {
+          for (const entry of root.listed.slice(1)) {
+            if (removedPaths.has(entry.directory)) continue
+            if (!exists(entry.directory)) {
+              throw new Error(`Missing linked worktree: ${entry.directory}`)
+            }
+            if (
+              fs.realpathSync(
+                git(entry.directory, ['rev-parse', '--path-format=absolute', '--git-common-dir'])
+              ) !== path.join(fs.realpathSync(root.directory), '.git')
+            ) {
+              throw new Error(`Linked worktree needs repair: ${entry.directory}`)
+            }
+            if (entry.directory.startsWith(root.directory + '@')) {
+              if (entry.locked) throw new Error(`Worktree is locked: ${entry.directory}`)
+              if (fs.lstatSync(entry.directory).isSymbolicLink()) {
+                throw new Error(`Worktree is a symbolic link: ${entry.directory}`)
+              }
+              vacant(repositoryPath(action.to) + entry.directory.slice(root.directory.length))
+            }
+            if (
+              git(entry.directory, ['ls-files', '--stage', '-z'])
+                .split('\0')
+                .some((item) => item.startsWith('160000 '))
+            ) {
+              throw new Error(`Linked worktree contains submodules: ${entry.directory}`)
+            }
+          }
+        } else if (root) {
+          const entry = root.listed.find((entry) => entry.directory === source)
+          if (entry?.locked) throw new Error('Worktree is locked')
+          const branch = action.to.split('@')[1]
+          branchTarget(root, branch, action.branch)
+          outsideWorktrees(repositoryPath(`${root.name}@${branch}`))
+        }
+        vacant(repositoryPath(action.to))
+        return
+      }
+
+      const destination = repositoryPath(action.to)
+      // A root rename changes the base path before a branch can be added.
+      const physical =
+        action.kind === 'worktree' && rootRenames.has(action.root)
+          ? repositoryPath(`${rootRenames.get(action.root).from}@${action.branch}`)
+          : destination
+      checkParents(destination)
+      if (exists(destination) && destination !== physical) vacant(destination)
+      if (exists(physical) && !removedPaths.has(physical)) {
+        const repository = desired.repositories.find(
+          (repo) => repo.id === (action.root || action.id)
+        )
+        const localRepository = root ? { ...repository, name: root.name } : repository
+        verify(localRepository, action.kind === 'worktree' ? [{ branch: action.branch }] : [])
+        action.present = true
+      } else if (action.kind === 'worktree' && root) {
+        branchTarget(root, action.branch)
+        const checkedOut = root.listed.find((entry) => entry.branch === action.branch)
+        if (checkedOut) {
+          const name = `${root.name}@${action.branch}`
+          if (!removals.has(name) || checkedOut.directory !== repositoryPath(name)) {
+            throw new Error(
+              `Branch ${action.branch} is already checked out at ${checkedOut.directory}`
+            )
+          }
+        }
+      }
+      outsideWorktrees(physical)
+    })
+  }
+  return { actions: plan.actions, blockers: [...new Set(plan.blockers)] }
+
+  function vacant(directory) {
+    if (exists(directory)) {
+      if (!removedPaths.has(directory)) throw new Error(`Destination already exists: ${directory}`)
+    }
+    checkParents(directory)
+  }
+
+  function checkParents(directory) {
+    // Catch files and dangling symlinks in parent components without creating them.
+    let parent = path.dirname(directory)
+    while (!exists(parent)) parent = path.dirname(parent)
+    if (!fs.statSync(parent).isDirectory()) {
+      throw new Error(`Destination parent is not a directory: ${parent}`)
+    }
+  }
+
+  function outsideWorktrees(directory) {
+    // An absent nested destination can still sit inside another worktree.
+    for (const entry of roots.values()) {
+      for (const worktree of entry.listed.slice(1)) {
+        if (
+          directory.startsWith(worktree.directory + path.sep) &&
+          !removedPaths.has(worktree.directory)
+        ) {
+          throw new Error(`Destination is inside another worktree: ${worktree.directory}`)
+        }
+      }
+    }
+  }
+
+  function branchTarget(root, target, source = null) {
+    const refs = git(root.directory, [
+      'for-each-ref',
+      '--format=%(refname:strip=2)',
+      'refs/heads/'
+    ]).split('\n')
+    for (const branch of refs) {
+      if (!branch || branch === source || removals.has(`${root.name}@${branch}`)) continue
+      if (source && branch === target) throw new Error(`Branch ${target} already exists`)
+      if (target.startsWith(branch + '/') || branch.startsWith(target + '/')) {
+        throw new Error(`Branch ${target} conflicts with existing branch ${branch}`)
+      }
+    }
+  }
+}
+
+function entries(manifest) {
+  return new Map(
+    manifest.repositories.flatMap((repository) => [
+      [repository.id, { id: repository.id, kind: 'repository', root: null, name: repository.name }],
+      ...repository.worktrees.map((worktree) => [
+        worktree.id,
+        {
+          id: worktree.id,
+          kind: 'worktree',
+          root: repository.id,
+          branch: worktree.branch,
+          name: `${repository.name}@${worktree.branch}`
+        }
+      ])
+    ])
+  )
+}
+
+function protectedManifest(directory, manifestDirectory) {
+  if (fs.realpathSync(directory) === fs.realpathSync(manifestDirectory)) {
+    throw new Error('Cannot remove or rename the active manifest repository')
+  }
+}
+
+function worktrees(directory) {
+  return git(directory, ['worktree', 'list', '--porcelain', '-z'])
+    .split('\0\0')
+    .filter(Boolean)
+    .map((record) => {
+      const fields = record.split('\0')
+      return {
+        directory: fields[0].slice('worktree '.length),
+        branch: fields
+          .find((field) => field.startsWith('branch refs/heads/'))
+          ?.slice('branch refs/heads/'.length),
+        locked: fields.some((field) => field === 'locked' || field.startsWith('locked '))
+      }
+    })
+}
+
+function exists(directory) {
+  try {
+    fs.lstatSync(directory)
+    return true
+  } catch (err) {
+    if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+    return false
+  }
+}
+
+function git(directory, args) {
+  const result = spawnSync('git', ['--no-optional-locks', '-C', directory, ...args])
+  if (result.error) throw result.error
+  if (result.status !== 0) {
+    throw new Error(result.stderr.toString().trim() || 'Git inspection failed')
+  }
+  return result.stdout.toString().replace(/\r?\n$/, '')
+}

package/lib/pull-state.js

@@ -0,0 +1,113 @@
+import fs from 'bare-fs'
+import path from 'bare-path'
+import os from 'bare-os'
+import { manifestDirectory } from './registry.js'
+
+export const targetRef = 'refs/git-workspace/pull-target'
+
+export function lockPull(directory) {
+  const lock = path.join(directory, '.git/workspace.lock')
+  const owner = path.join(lock, 'pull-owner')
+  try {
+    fs.mkdirSync(lock)
+  } catch (err) {
+    if (err.code !== 'EEXIST') throw err
+    // Only reclaim a dead pull's lock; ordinary command locks are left alone.
+    if (!fs.lstatSync(lock).isDirectory() || fs.lstatSync(lock).isSymbolicLink()) throw err
+    let pid
+    try {
+      if (!fs.lstatSync(owner).isFile()) throw err
+      pid = Number(fs.readFileSync(owner, 'utf8'))
+    } catch {
+      throw err
+    }
+    if (!Number.isSafeInteger(pid) || pid <= 0) throw err
+    try {
+      os.kill(pid, 0)
+      throw err
+    } catch (dead) {
+      if (dead.code !== 'ESRCH') throw dead
+    }
+    // Serialize stale-lock reclaimers and recheck ownership: another retry may
+    // have replaced the lock since we first read its PID.
+    const claiming = path.join(lock, 'pull-recovery')
+    fs.mkdirSync(claiming)
+    const retired = lock + `.retired-${os.pid()}`
+    try {
+      if (Number(fs.readFileSync(owner, 'utf8')) !== pid) throw err
+      try {
+        os.kill(pid, 0)
+        throw err
+      } catch (dead) {
+        if (dead.code !== 'ESRCH') throw dead
+      }
+      fs.renameSync(lock, retired)
+    } catch (failed) {
+      fs.rmdirSync(claiming)
+      throw failed
+    }
+    fs.rmSync(retired, { recursive: true })
+    fs.mkdirSync(lock)
+  }
+  try {
+    fs.writeFileSync(owner, String(os.pid()), { flag: 'wx' })
+  } catch (err) {
+    fs.rmdirSync(lock)
+    throw err
+  }
+  return () => {
+    fs.unlinkSync(owner)
+    fs.rmdirSync(lock)
+  }
+}
+
+export function statePath(directory) {
+  return path.join(directory, '.git/workspace-pull.json')
+}
+
+export function assertNoPendingPull(directory = manifestDirectory()) {
+  try {
+    fs.lstatSync(statePath(directory))
+  } catch (err) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+  throw new Error(
+    'An interrupted workspace pull is pending; rerun git workspace pull before making workspace changes'
+  )
+}
+
+export function readPullState(directory) {
+  const file = statePath(directory)
+  try {
+    if (!fs.lstatSync(file).isFile()) throw new Error('Pull progress must be a regular file')
+  } catch (err) {
+    if (err.code === 'ENOENT') return null
+    throw err
+  }
+  const state = JSON.parse(fs.readFileSync(file, 'utf8'))
+  const hash = (value) => typeof value === 'string' && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)
+  if (
+    !state ||
+    state.version !== 1 ||
+    !hash(state.head) ||
+    !hash(state.target) ||
+    (state.applied !== null && !hash(state.applied)) ||
+    !Number.isSafeInteger(state.completed) ||
+    state.completed < 0 ||
+    typeof state.pending !== 'boolean' ||
+    typeof state.localBranch !== 'string' ||
+    typeof state.remote !== 'string' ||
+    typeof state.merge !== 'string'
+  ) {
+    throw new Error('Invalid local pull progress; inspect .git/workspace-pull.json')
+  }
+  return state
+}
+
+export function writePullState(directory, state) {
+  const file = statePath(directory)
+  const temporary = file + '.tmp'
+  fs.writeFileSync(temporary, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 })
+  fs.renameSync(temporary, file)
+}