@ricsam/r5d-worker 0.0.74 → 0.0.76

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

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import path from "node:path";
+function isGitMetadataPath(relativePath) {
+  return relativePath.split("/").includes(".git");
+}
+function normalizeRelativePath(value) {
+  const normalized = value.split(path.sep).join(path.posix.sep).replace(/^\.\/+/, "").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === "." || normalized.split("/").includes("..") || isGitMetadataPath(normalized)) return null;
+  return normalized;
+}
+function assertInside(root, candidate) {
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`Working-tree path escapes its root: ${candidate}`);
+  }
+}
+function gitEligibleRoots(root) {
+  const result = Bun.spawnSync(
+    [
+      "git",
+      "-c",
+      "submodule.recurse=false",
+      "-c",
+      "fetch.recurseSubmodules=false",
+      "-c",
+      "push.recurseSubmodules=false",
+      "ls-files",
+      "-z",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "--",
+      "."
+    ],
+    {
+      cwd: root,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Inspect Git working tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  }
+  return result.stdout.toString().split("\0").flatMap((entry) => {
+    const normalized = normalizeRelativePath(entry);
+    return normalized ? [normalized] : [];
+  }).sort();
+}
+function addEntry(entries, root, relativePath, recurseDirectories) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized || entries.has(normalized)) return;
+  const absolutePath = path.join(root, ...normalized.split("/"));
+  assertInside(root, absolutePath);
+  let stat;
+  try {
+    stat = fs.lstatSync(absolutePath);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    entries.set(normalized, { kind: "symlink", mode: stat.mode, target: fs.readlinkSync(absolutePath) });
+    return;
+  }
+  if (stat.isFile()) {
+    entries.set(normalized, { kind: "file", mode: stat.mode, size: stat.size });
+    return;
+  }
+  if (!stat.isDirectory()) return;
+  entries.set(normalized, { kind: "directory", mode: stat.mode });
+  if (!recurseDirectories) return;
+  for (const child of fs.readdirSync(absolutePath).sort()) {
+    addEntry(entries, root, path.posix.join(normalized, child), true);
+  }
+}
+function addParentDirectories(entries, root) {
+  for (const relativePath of [...entries.keys()]) {
+    let parent = path.posix.dirname(relativePath);
+    while (parent !== ".") {
+      if (!entries.has(parent)) {
+        const absolutePath = path.join(root, ...parent.split("/"));
+        const stat = fs.lstatSync(absolutePath);
+        entries.set(parent, { kind: "directory", mode: stat.mode });
+      }
+      parent = path.posix.dirname(parent);
+    }
+  }
+}
+function inspectWorkingTree(root, mode) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!fs.existsSync(root)) return entries;
+  if (mode === "all") {
+    for (const child of fs.readdirSync(root).sort()) addEntry(entries, root, child, true);
+  } else {
+    for (const relativePath of gitEligibleRoots(root)) {
+      addEntry(entries, root, relativePath, true);
+    }
+  }
+  addParentDirectories(entries, root);
+  return entries;
+}
+function removeEntry(targetRoot, relativePath) {
+  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
+  assertInside(targetRoot, targetPath);
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+function ensureDirectory(targetRoot, relativePath, mode) {
+  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
+  assertInside(targetRoot, targetPath);
+  if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isDirectory()) removeEntry(targetRoot, relativePath);
+  fs.mkdirSync(targetPath, { recursive: true, mode: mode & 511 });
+}
+function filesEqual(leftPath, rightPath, size) {
+  let rightStat;
+  try {
+    rightStat = fs.lstatSync(rightPath);
+  } catch {
+    return false;
+  }
+  if (!rightStat.isFile() || rightStat.size !== size) return false;
+  const left = fs.openSync(leftPath, "r");
+  const right = fs.openSync(rightPath, "r");
+  const leftBuffer = Buffer.allocUnsafe(64 * 1024);
+  const rightBuffer = Buffer.allocUnsafe(64 * 1024);
+  try {
+    let offset = 0;
+    while (offset < size) {
+      const length = Math.min(leftBuffer.length, size - offset);
+      const leftRead = fs.readSync(left, leftBuffer, 0, length, offset);
+      const rightRead = fs.readSync(right, rightBuffer, 0, length, offset);
+      if (leftRead !== rightRead || !leftBuffer.subarray(0, leftRead).equals(rightBuffer.subarray(0, rightRead))) return false;
+      offset += leftRead;
+    }
+    return true;
+  } finally {
+    fs.closeSync(left);
+    fs.closeSync(right);
+  }
+}
+function copyEntry(sourceRoot, targetRoot, relativePath, entry) {
+  const sourcePath = path.join(sourceRoot, ...relativePath.split("/"));
+  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
+  assertInside(sourceRoot, sourcePath);
+  assertInside(targetRoot, targetPath);
+  const parent = path.posix.dirname(relativePath);
+  if (parent !== ".") ensureDirectory(targetRoot, parent, 493);
+  if (entry.kind === "directory") {
+    ensureDirectory(targetRoot, relativePath, entry.mode);
+    return;
+  }
+  if (entry.kind === "symlink") {
+    let unchanged = false;
+    try {
+      unchanged = fs.lstatSync(targetPath).isSymbolicLink() && fs.readlinkSync(targetPath) === entry.target;
+    } catch {
+      unchanged = false;
+    }
+    if (!unchanged) {
+      removeEntry(targetRoot, relativePath);
+      fs.symlinkSync(entry.target, targetPath);
+    }
+    return;
+  }
+  if (!filesEqual(sourcePath, targetPath, entry.size)) {
+    if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isFile()) removeEntry(targetRoot, relativePath);
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+  fs.chmodSync(targetPath, entry.mode & 511);
+}
+function mirrorWorkingTree(input) {
+  const sourceRoot = path.resolve(input.sourceRoot);
+  const targetRoot = path.resolve(input.targetRoot);
+  fs.mkdirSync(targetRoot, { recursive: true });
+  const desired = inspectWorkingTree(sourceRoot, input.sourceMode);
+  const existing = inspectWorkingTree(targetRoot, input.deletionMode === "git" ? "git" : "all");
+  for (const relativePath of [...existing.keys()].sort((left, right) => right.split("/").length - left.split("/").length)) {
+    if (!desired.has(relativePath)) removeEntry(targetRoot, relativePath);
+  }
+  for (const [relativePath, entry] of [...desired.entries()].sort(
+    ([left], [right]) => left.split("/").length - right.split("/").length || left.localeCompare(right)
+  )) {
+    copyEntry(sourceRoot, targetRoot, relativePath, entry);
+  }
+  return { paths: [...desired.keys()].filter((relativePath) => desired.get(relativePath)?.kind !== "directory").sort() };
+}
+export {
+  inspectWorkingTree,
+  mirrorWorkingTree
+};