@ricsam/r5d-worker 0.0.97 → 0.0.100

package/dist/mjs/working-tree-mirror.mjs

@@ -151,14 +151,55 @@ function addParentDirectories(entries, root) {
     }
   }
 }
-function inspectWorkingTree(root, mode) {
+function gitlinkPaths(root) {
+  const result = Bun.spawnSync(
+    [
+      "git",
+      "-c",
+      "submodule.recurse=false",
+      "-c",
+      "fetch.recurseSubmodules=false",
+      "-c",
+      "push.recurseSubmodules=false",
+      "ls-files",
+      "-z",
+      "--stage",
+      "--",
+      "."
+    ],
+    {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: workerGitProcessEnvironment()
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Inspect Git index gitlinks: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  }
+  const gitlinks = /* @__PURE__ */ new Set();
+  for (const record of result.stdout.toString().split("\0")) {
+    const match = /^160000 [0-9a-f]+ [0-3]\t(.+)$/su.exec(record);
+    if (!match) continue;
+    const normalized = normalizeRelativePath(match[1]);
+    if (normalized) gitlinks.add(normalized);
+  }
+  return gitlinks;
+}
+function directoryIsEmpty(root, relativePath) {
+  const inspected = inspectRelativePathWithoutFollowingAncestors(root, relativePath);
+  return inspected.kind === "entry" && inspected.stat.isDirectory() && fs.readdirSync(inspected.absolutePath).length === 0;
+}
+function inspectWorkingTree(root, mode, options = {}) {
   const entries = /* @__PURE__ */ new Map();
   root = path.resolve(root);
   if (!inspectDirectoryRoot(root, { allowMissing: true, label: "Working-tree root" })) return entries;
   if (mode === "all") {
     for (const child of fs.readdirSync(root).sort()) addEntry(entries, root, child, true);
   } else {
+    const omittedGitlinks = options.omitUnpopulatedGitlinks ? gitlinkPaths(root) : null;
     for (const relativePath of gitEligibleRoots(root)) {
+      if (omittedGitlinks?.has(relativePath) && directoryIsEmpty(root, relativePath)) continue;
       addEntry(entries, root, relativePath, true);
     }
   }
@@ -332,7 +373,9 @@ function mirrorWorkingTree(input) {
   }
   inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
   const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
-  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all");
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all", {
+    omitUnpopulatedGitlinks: input.deletionMode === "git"
+  });
   for (const relativePath of [...existing.keys()].sort((left, right) => right.split("/").length - left.split("/").length)) {
     if (!desired.has(relativePath)) removeEntry(targetRoot, relativePath);
   }
@@ -343,8 +386,212 @@ function mirrorWorkingTree(input) {
   }
   return { paths: [...desired.keys()].filter((relativePath) => desired.get(relativePath)?.kind !== "directory").sort() };
 }
+function normalizeWorkingTreeRelativePath(value) {
+  return normalizeRelativePath(value);
+}
+const MIRROR_TEMPORARY_FILE_PATTERN = /^\.r5d-working-tree-mirror-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/u;
+function relativeDepth(relativePath) {
+  return relativePath.split("/").length;
+}
+function shallowestFirst(left, right) {
+  return relativeDepth(left) - relativeDepth(right) || left.localeCompare(right);
+}
+function deepestFirst(left, right) {
+  return relativeDepth(right) - relativeDepth(left) || left.localeCompare(right);
+}
+function hasAncestorIn(relativePath, ancestors) {
+  let parent = path.posix.dirname(relativePath);
+  while (parent !== ".") {
+    if (ancestors.has(parent)) return true;
+    parent = path.posix.dirname(parent);
+  }
+  return false;
+}
+function treeEntryFromStat(stat, absolutePath) {
+  if (stat.isSymbolicLink()) return { kind: "symlink", mode: stat.mode, target: fs.readlinkSync(absolutePath) };
+  if (stat.isFile()) return { kind: "file", mode: stat.mode, size: stat.size };
+  if (stat.isDirectory()) return { kind: "directory", mode: stat.mode };
+  return null;
+}
+function fsyncPath(targetPath, flags) {
+  const descriptor = fs.openSync(targetPath, flags);
+  try {
+    fs.fsyncSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function planWorkingTreeMirror(input) {
+  const sourceRoot = path.resolve(input.sourceRoot);
+  const targetRoot = path.resolve(input.targetRoot);
+  const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all", {
+    omitUnpopulatedGitlinks: input.deletionMode === "git"
+  });
+  const replaced = /* @__PURE__ */ new Map();
+  const absent = [];
+  for (const [relativePath, entry] of existing) {
+    if (!desired.has(relativePath)) replaced.set(relativePath, entry);
+  }
+  for (const [relativePath, entry] of desired) {
+    const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (target.kind !== "entry") {
+      absent.push(relativePath);
+      continue;
+    }
+    const { absolutePath, stat } = target;
+    if (entry.kind === "directory") {
+      if (stat.isDirectory()) continue;
+    } else if (entry.kind === "symlink") {
+      if (stat.isSymbolicLink() && fs.readlinkSync(absolutePath) === entry.target) continue;
+    } else if (stat.isFile() && filesEqual(path.join(sourceRoot, ...relativePath.split("/")), absolutePath, entry)) {
+      continue;
+    }
+    const current = treeEntryFromStat(stat, absolutePath);
+    if (current) replaced.set(relativePath, current);
+    else absent.push(relativePath);
+  }
+  const replacedDirectories = new Set(
+    [...replaced].filter(([, entry]) => entry.kind === "directory").map(([relativePath]) => relativePath)
+  );
+  for (const relativePath of [...replaced.keys()]) {
+    if (hasAncestorIn(relativePath, replacedDirectories)) replaced.delete(relativePath);
+  }
+  return {
+    desired,
+    replaced,
+    absent: absent.filter((relativePath) => !hasAncestorIn(relativePath, replacedDirectories)).sort(shallowestFirst)
+  };
+}
+function captureWorkingTreeMirrorPlan(input) {
+  const targetRoot = path.resolve(input.targetRoot);
+  const snapshotRoot = path.resolve(input.snapshotRoot);
+  const durability = input.durability ?? "per_entry";
+  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
+  if (!inspectDirectoryRoot(snapshotRoot, { allowMissing: true, label: "Working-tree snapshot root" })) {
+    fs.mkdirSync(snapshotRoot, { recursive: true });
+  }
+  const trees = [];
+  for (const [relativePath, entry] of [...input.plan.replaced.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
+    if (entry.kind !== "directory") {
+      copyEntry(targetRoot, snapshotRoot, relativePath, entry, durability);
+      continue;
+    }
+    const source = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (source.kind !== "entry" || !source.stat.isDirectory()) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${path.join(targetRoot, ...relativePath.split("/"))}`);
+    }
+    ensureDirectory(snapshotRoot, relativePath, entry.mode);
+    mirrorWorkingTree({
+      sourceRoot: source.absolutePath,
+      targetRoot: path.join(snapshotRoot, ...relativePath.split("/")),
+      sourceMode: "all",
+      deletionMode: "all",
+      durability
+    });
+    trees.push(relativePath);
+  }
+  return { absent: [...input.plan.absent].sort(shallowestFirst), trees: trees.sort(shallowestFirst) };
+}
+function restoreWorkingTreeMirrorScope(input) {
+  const snapshotRoot = path.resolve(input.snapshotRoot);
+  const targetRoot = path.resolve(input.targetRoot);
+  inspectDirectoryRoot(snapshotRoot, { allowMissing: false, label: "Working-tree snapshot root" });
+  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
+    fs.mkdirSync(targetRoot, { recursive: true });
+  }
+  const normalize = (relativePath) => {
+    const normalized = normalizeRelativePath(relativePath);
+    if (!normalized) throw new Error(`Invalid working-tree scope path: ${relativePath}`);
+    return normalized;
+  };
+  const absent = input.scope.absent.map(normalize);
+  const trees = new Set(input.scope.trees.map(normalize));
+  const captured = inspectWorkingTree(snapshotRoot, "all");
+  for (const tree of trees) {
+    if (captured.get(tree)?.kind !== "directory") {
+      throw new Error(`Working-tree snapshot does not hold the captured directory: ${tree}`);
+    }
+  }
+  const touched = /* @__PURE__ */ new Set();
+  for (const relativePath of [...absent].sort(deepestFirst)) {
+    const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (inspected.kind === "entry") fs.rmSync(inspected.absolutePath, { recursive: true, force: true });
+    touched.add(relativePath);
+  }
+  const writtenDirectories = /* @__PURE__ */ new Set();
+  for (const relativePath of absent) writtenDirectories.add(path.posix.dirname(relativePath));
+  for (const [relativePath, entry] of captured) {
+    if (entry.kind !== "directory" && !hasAncestorIn(relativePath, trees)) writtenDirectories.add(path.posix.dirname(relativePath));
+  }
+  for (const directory of writtenDirectories) {
+    let absoluteDirectory = targetRoot;
+    if (directory !== ".") {
+      const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, directory);
+      if (inspected.kind !== "entry" || !inspected.stat.isDirectory()) continue;
+      absoluteDirectory = inspected.absolutePath;
+    }
+    for (const name of fs.readdirSync(absoluteDirectory)) {
+      if (!MIRROR_TEMPORARY_FILE_PATTERN.test(name)) continue;
+      const temporaryPath = path.join(absoluteDirectory, name);
+      if (!fs.lstatSync(temporaryPath).isFile()) continue;
+      fs.rmSync(temporaryPath, { force: true });
+      touched.add(directory === "." ? name : path.posix.join(directory, name));
+    }
+  }
+  for (const [relativePath, entry] of [...captured.entries()].sort(([left], [right]) => shallowestFirst(left, right))) {
+    touched.add(relativePath);
+    if (hasAncestorIn(relativePath, trees)) continue;
+    if (!trees.has(relativePath)) {
+      copyEntry(snapshotRoot, targetRoot, relativePath, entry, "per_entry");
+      continue;
+    }
+    const current = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (current.kind === "blocked") {
+      throw new Error(`Refusing to restore a working-tree directory through a symlink or non-directory: ${current.blockingPath}`);
+    }
+    if (current.kind === "entry" && !current.stat.isDirectory()) {
+      fs.rmSync(current.absolutePath, { recursive: true, force: true });
+    }
+    ensureDirectory(targetRoot, relativePath, entry.mode);
+    mirrorWorkingTree({
+      sourceRoot: path.join(snapshotRoot, ...relativePath.split("/")),
+      targetRoot: path.join(targetRoot, ...relativePath.split("/")),
+      sourceMode: "all",
+      deletionMode: "all"
+    });
+  }
+  return { paths: [...touched].sort(shallowestFirst) };
+}
+function fsyncWorkingTreePaths(root, relativePaths) {
+  root = path.resolve(root);
+  inspectDirectoryRoot(root, { allowMissing: false, label: "Working-tree root" });
+  const directories = /* @__PURE__ */ new Set(["."]);
+  for (const relativePath of relativePaths) {
+    const normalized = normalizeRelativePath(relativePath);
+    if (!normalized) throw new Error(`Invalid working-tree path: ${relativePath}`);
+    directories.add(path.posix.dirname(normalized));
+    const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
+    if (inspected.kind !== "entry") continue;
+    if (inspected.stat.isDirectory()) directories.add(normalized);
+    else if (inspected.stat.isFile()) fsyncPath(inspected.absolutePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  }
+  for (const directory of directories) {
+    if (directory === ".") {
+      fsyncPath(root, fs.constants.O_RDONLY);
+      continue;
+    }
+    const inspected = inspectRelativePathWithoutFollowingAncestors(root, directory);
+    if (inspected.kind === "entry" && inspected.stat.isDirectory()) fsyncPath(inspected.absolutePath, fs.constants.O_RDONLY);
+  }
+}
 export {
   assertWorkingTreeHasNoPortableGitMetadataAliases,
+  captureWorkingTreeMirrorPlan,
+  fsyncWorkingTreePaths,
   inspectWorkingTree,
-  mirrorWorkingTree
+  mirrorWorkingTree,
+  normalizeWorkingTreeRelativePath,
+  planWorkingTreeMirror,
+  restoreWorkingTreeMirrorScope
 };