@ricsam/r5d-worker 0.0.78 → 0.0.79

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

@@ -1,8 +1,37 @@
 import fs from "node:fs";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
+const HFS_IGNORED_CODE_POINTS = /[\u200c-\u200f\u202a-\u202e\u206a-\u206f\ufeff]/gu;
+const MIRROR_TEMPORARY_FILE_PREFIX = ".r5d-working-tree-mirror-";
+function isPortableGitMetadataSegment(segment) {
+  const hfsFolded = segment.replace(HFS_IGNORED_CODE_POINTS, "").toLowerCase();
+  if (hfsFolded === ".git") return true;
+  const ntfsFolded = segment.toLowerCase();
+  return /^(?:\.git|git~1)[ .]*(?::|$)/u.test(ntfsFolded);
+}
 function isGitMetadataPath(relativePath) {
-  return relativePath.split("/").includes(".git");
+  return relativePath.split(/[\\/]/u).some(isPortableGitMetadataSegment);
+}
+function assertWorkingTreeHasNoPortableGitMetadataAliases(root) {
+  root = path.resolve(root);
+  const rootStatus = fs.lstatSync(root);
+  if (!rootStatus.isDirectory() || rootStatus.isSymbolicLink()) {
+    throw new Error(`Working-tree root is not a regular directory: ${root}`);
+  }
+  const inspectDirectory = (directoryPath, relativeDirectory) => {
+    for (const name of fs.readdirSync(directoryPath).sort()) {
+      const relativePath = relativeDirectory ? path.posix.join(relativeDirectory, name) : name;
+      if (name === ".git") continue;
+      if (isGitMetadataPath(relativePath)) {
+        throw new Error(`Working tree contains a portable Git metadata alias that cannot be moved safely: ${relativePath}`);
+      }
+      const entryPath = path.join(directoryPath, name);
+      const status = fs.lstatSync(entryPath);
+      if (status.isDirectory() && !status.isSymbolicLink()) inspectDirectory(entryPath, relativePath);
+    }
+  };
+  inspectDirectory(root, "");
 }
 function normalizeRelativePath(value) {
   const normalized = value.split(path.sep).join(path.posix.sep).replace(/^\.\/+/, "").replace(/^\/+|\/+$/g, "");
@@ -15,6 +44,41 @@ function assertInside(root, candidate) {
     throw new Error(`Working-tree path escapes its root: ${candidate}`);
   }
 }
+function inspectRelativePathWithoutFollowingAncestors(root, relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized) return { kind: "blocked", blockingPath: relativePath };
+  let current = path.resolve(root);
+  const segments = normalized.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    current = path.join(current, segments[index]);
+    assertInside(root, current);
+    let stat;
+    try {
+      stat = fs.lstatSync(current);
+    } catch (error) {
+      if (error.code === "ENOENT") return { kind: "missing" };
+      throw error;
+    }
+    if (index < segments.length - 1 && (!stat.isDirectory() || stat.isSymbolicLink())) {
+      return { kind: "blocked", blockingPath: current };
+    }
+    if (index === segments.length - 1) return { kind: "entry", absolutePath: current, stat };
+  }
+  return { kind: "missing" };
+}
+function inspectDirectoryRoot(root, options) {
+  let stat;
+  try {
+    stat = fs.lstatSync(root);
+  } catch (error) {
+    if (options.allowMissing && error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`${options.label} is not a regular directory: ${root}`);
+  }
+  return true;
+}
 function gitEligibleRoots(root) {
   const result = Bun.spawnSync(
     [
@@ -51,16 +115,13 @@ function gitEligibleRoots(root) {
 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;
-  }
+  const inspected = inspectRelativePathWithoutFollowingAncestors(root, normalized);
+  if (inspected.kind !== "entry") return;
+  const { absolutePath, stat } = inspected;
   if (stat.isSymbolicLink()) {
+    for (const existing of [...entries.keys()]) {
+      if (existing.startsWith(`${normalized}/`)) entries.delete(existing);
+    }
     entries.set(normalized, { kind: "symlink", mode: stat.mode, target: fs.readlinkSync(absolutePath) });
     return;
   }
@@ -80,9 +141,11 @@ function addParentDirectories(entries, root) {
     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 });
+        const inspected = inspectRelativePathWithoutFollowingAncestors(root, parent);
+        if (inspected.kind !== "entry" || !inspected.stat.isDirectory() || inspected.stat.isSymbolicLink()) {
+          throw new Error(`Working-tree entry has an unsafe parent directory: ${parent}`);
+        }
+        entries.set(parent, { kind: "directory", mode: inspected.stat.mode });
       }
       parent = path.posix.dirname(parent);
     }
@@ -90,7 +153,8 @@ function addParentDirectories(entries, root) {
 }
 function inspectWorkingTree(root, mode) {
   const entries = /* @__PURE__ */ new Map();
-  if (!fs.existsSync(root)) return entries;
+  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 {
@@ -102,32 +166,58 @@ function inspectWorkingTree(root, mode) {
   return entries;
 }
 function removeEntry(targetRoot, relativePath) {
-  const targetPath = path.join(targetRoot, ...relativePath.split("/"));
-  assertInside(targetRoot, targetPath);
-  fs.rmSync(targetPath, { recursive: true, force: true });
+  const inspected = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+  if (inspected.kind === "missing") return;
+  if (inspected.kind === "blocked") {
+    throw new Error(`Refusing to remove a working-tree path through a symlink or non-directory: ${inspected.blockingPath}`);
+  }
+  fs.rmSync(inspected.absolutePath, { 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 });
+  const normalized = normalizeRelativePath(relativePath);
+  if (!normalized) throw new Error(`Invalid working-tree directory path: ${relativePath}`);
+  let current = path.resolve(targetRoot);
+  const segments = normalized.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    current = path.join(current, segments[index]);
+    assertInside(targetRoot, current);
+    let stat = null;
+    try {
+      stat = fs.lstatSync(current);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) {
+      fs.rmSync(current, { recursive: true, force: true });
+      stat = null;
+    }
+    if (!stat) fs.mkdirSync(current, { mode: index === segments.length - 1 ? mode & 511 : 493 });
+  }
 }
-function filesEqual(leftPath, rightPath, size) {
+function filesEqual(leftPath, rightPath, entry) {
   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");
+  if (!rightStat.isFile() || rightStat.size !== entry.size || (rightStat.mode & 511) !== (entry.mode & 511)) return false;
+  let left;
+  let right;
+  try {
+    left = fs.openSync(leftPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    right = fs.openSync(rightPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  } catch {
+    if (left !== void 0) fs.closeSync(left);
+    if (right !== void 0) fs.closeSync(right);
+    return false;
+  }
   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);
+    while (offset < entry.size) {
+      const length = Math.min(leftBuffer.length, entry.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;
@@ -139,18 +229,73 @@ function filesEqual(leftPath, rightPath, size) {
     fs.closeSync(right);
   }
 }
+function copyRegularFile(sourcePath, targetPath, entry) {
+  const source = fs.openSync(sourcePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  const temporaryPath = path.join(path.dirname(targetPath), `${MIRROR_TEMPORARY_FILE_PREFIX}${randomUUID()}.tmp`);
+  let target;
+  try {
+    const sourceStat = fs.fstatSync(source);
+    if (!sourceStat.isFile() || sourceStat.size !== entry.size || (sourceStat.mode & 511) !== (entry.mode & 511)) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
+    target = fs.openSync(
+      temporaryPath,
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW,
+      entry.mode & 511
+    );
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let offset = 0;
+    while (offset < sourceStat.size) {
+      const bytesRead = fs.readSync(source, buffer, 0, Math.min(buffer.length, sourceStat.size - offset), offset);
+      if (bytesRead <= 0) throw new Error(`Working-tree source ended while it was being mirrored: ${sourcePath}`);
+      let written = 0;
+      while (written < bytesRead) {
+        written += fs.writeSync(target, buffer, written, bytesRead - written, offset + written);
+      }
+      offset += bytesRead;
+    }
+    fs.fchmodSync(target, entry.mode & 511);
+    fs.fsyncSync(target);
+    const finalSourceStat = fs.fstatSync(source);
+    if (!finalSourceStat.isFile() || finalSourceStat.size !== sourceStat.size || (finalSourceStat.mode & 511) !== (sourceStat.mode & 511) || finalSourceStat.mtimeMs !== sourceStat.mtimeMs || finalSourceStat.ctimeMs !== sourceStat.ctimeMs) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
+    fs.closeSync(target);
+    target = void 0;
+    fs.renameSync(temporaryPath, targetPath);
+    const parent = fs.openSync(path.dirname(targetPath), fs.constants.O_RDONLY);
+    try {
+      fs.fsyncSync(parent);
+    } finally {
+      fs.closeSync(parent);
+    }
+  } finally {
+    if (target !== void 0) fs.closeSync(target);
+    fs.closeSync(source);
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
 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);
+  const source = inspectRelativePathWithoutFollowingAncestors(sourceRoot, relativePath);
+  if (source.kind !== "entry") {
+    throw new Error(`Working-tree source became unsafe while it was being mirrored: ${relativePath}`);
+  }
+  const sourcePath = source.absolutePath;
   if (entry.kind === "directory") {
+    if (!source.stat.isDirectory() || source.stat.isSymbolicLink()) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
     ensureDirectory(targetRoot, relativePath, entry.mode);
     return;
   }
   if (entry.kind === "symlink") {
+    if (!source.stat.isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
+      throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+    }
     let unchanged = false;
     try {
       unchanged = fs.lstatSync(targetPath).isSymbolicLink() && fs.readlinkSync(targetPath) === entry.target;
@@ -163,16 +308,26 @@ function copyEntry(sourceRoot, targetRoot, relativePath, entry) {
     }
     return;
   }
-  if (!filesEqual(sourcePath, targetPath, entry.size)) {
-    if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isFile()) removeEntry(targetRoot, relativePath);
-    fs.copyFileSync(sourcePath, targetPath);
+  if (!source.stat.isFile() || source.stat.isSymbolicLink() || source.stat.size !== entry.size) {
+    throw new Error(`Working-tree source changed while it was being mirrored: ${sourcePath}`);
+  }
+  if (!filesEqual(sourcePath, targetPath, entry)) {
+    const target = inspectRelativePathWithoutFollowingAncestors(targetRoot, relativePath);
+    if (target.kind === "blocked") {
+      throw new Error(`Refusing to copy through a symlink or non-directory: ${target.blockingPath}`);
+    }
+    const targetStat = target.kind === "entry" ? target.stat : null;
+    if (targetStat && !targetStat.isFile()) removeEntry(targetRoot, relativePath);
+    copyRegularFile(sourcePath, targetPath, entry);
   }
-  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 });
+  if (!inspectDirectoryRoot(targetRoot, { allowMissing: true, label: "Working-tree target root" })) {
+    fs.mkdirSync(targetRoot, { recursive: true });
+  }
+  inspectDirectoryRoot(targetRoot, { allowMissing: false, label: "Working-tree target root" });
   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)) {
@@ -186,6 +341,7 @@ function mirrorWorkingTree(input) {
   return { paths: [...desired.keys()].filter((relativePath) => desired.get(relativePath)?.kind !== "directory").sort() };
 }
 export {
+  assertWorkingTreeHasNoPortableGitMetadataAliases,
   inspectWorkingTree,
   mirrorWorkingTree
 };

package/dist/mjs/workspace-automatic-sync-policy.mjs

@@ -0,0 +1,40 @@
+const PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS = 12e4;
+function pendingCreatedBranchKey(projectId, branchName) {
+  return `${projectId}\0${branchName}`;
+}
+function hasActiveVisibleProjectsWorkspaceTarget(activeTargets) {
+  for (const target of activeTargets) {
+    if (target.type === "workspace" && target.rootProfile === "visible_projects") return true;
+  }
+  return false;
+}
+function projectBranchHasActiveWorkspaceTarget(projectId, branchName, activeTargets) {
+  for (const target of activeTargets) {
+    if (target.type === "project" && target.projectId === projectId && target.branchName === branchName) return true;
+    if (target.type === "workspace" && target.rootProfile === "visible_projects") return true;
+  }
+  return false;
+}
+function shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets) {
+  if (pendingCreatedBranches.length === 0) return false;
+  const targets = [...activeTargets];
+  return pendingCreatedBranches.some(({ projectId, branchName }) => projectBranchHasActiveWorkspaceTarget(projectId, branchName, targets));
+}
+function pendingCreatedBranchAutomaticSyncDeferral(pendingCreatedBranches, activeTargets, publicationNotBeforeByBranch, nowMs = Date.now()) {
+  if (shouldDeferAutomaticWorkspaceSyncForPendingBranch(pendingCreatedBranches, activeTargets)) {
+    return { kind: "active_target" };
+  }
+  const notBeforeMs = pendingCreatedBranches.reduce(
+    (latest, { projectId, branchName }) => Math.max(latest, publicationNotBeforeByBranch.get(pendingCreatedBranchKey(projectId, branchName)) ?? 0),
+    0
+  );
+  return notBeforeMs > nowMs ? { kind: "creation_grace", retryAfterMs: notBeforeMs - nowMs } : null;
+}
+export {
+  PENDING_CREATED_BRANCH_AUTOMATIC_SYNC_GRACE_MS,
+  hasActiveVisibleProjectsWorkspaceTarget,
+  pendingCreatedBranchAutomaticSyncDeferral,
+  pendingCreatedBranchKey,
+  projectBranchHasActiveWorkspaceTarget,
+  shouldDeferAutomaticWorkspaceSyncForPendingBranch
+};

package/dist/mjs/workspace-branch-incarnation-policy.mjs

@@ -0,0 +1,13 @@
+function assertProjectBranchDeletionIncarnation(input) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(input.requiredBranchId)) {
+    throw new Error("Project branch deletion requires a valid durable branch incarnation");
+  }
+  for (const branch of [input.configuredBranch, input.pendingLocalBranch]) {
+    if (branch && branch.branchId !== input.requiredBranchId) {
+      throw new Error("Project branch deletion belongs to another durable branch incarnation");
+    }
+  }
+}
+export {
+  assertProjectBranchDeletionIncarnation
+};

package/dist/mjs/workspace-command-sync-policy.mjs

@@ -1,3 +1,19 @@
+function usesVisibleWorkspace(target) {
+  return target.type === "project" || target.rootProfile === "visible_projects";
+}
+async function reserveWorkspaceCommandAfterCurrentSync(target, coordinator, reserve) {
+  if (!usesVisibleWorkspace(target)) {
+    reserve();
+    return;
+  }
+  while (true) {
+    const currentSync = coordinator.afterCurrent();
+    await currentSync;
+    if (currentSync !== coordinator.afterCurrent()) continue;
+    reserve();
+    return;
+  }
+}
 function shouldSerializeWorkspaceCommand(target) {
   return target.type === "workspace" && target.rootProfile === "canonical_sync";
 }
@@ -9,6 +25,7 @@ function acquireWorkspaceCommandMutation(target, coordinator) {
 }
 export {
   acquireWorkspaceCommandMutation,
+  reserveWorkspaceCommandAfterCurrentSync,
   runWorkspaceCommand,
   shouldSerializeWorkspaceCommand
 };