@ricsam/r5d-worker 0.0.80 → 0.0.82

package/dist/cjs/workspace-merge-projection.cjs

@@ -0,0 +1,392 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_merge_projection_exports = {};
+__export(workspace_merge_projection_exports, {
+  materializeWorkspaceProjectionTree: () => materializeWorkspaceProjectionTree,
+  mergeWorkspaceProjectionMount: () => mergeWorkspaceProjectionMount,
+  workspaceMergeProjectionSupport: () => workspaceMergeProjectionSupport,
+  workspaceMergeProjectionTestHarness: () => workspaceMergeProjectionTestHarness
+});
+module.exports = __toCommonJS(workspace_merge_projection_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_git_process_environment = require("./git-process-environment.cjs");
+var import_working_tree_mirror = require("./working-tree-mirror.cjs");
+var import_workspace_mount_boundary = require("./workspace-mount-boundary.cjs");
+const MINIMUM_MERGE_TREE_GIT_VERSION = { major: 2, minor: 40 };
+const NON_RECURSIVE_GIT_CONFIG = [
+  "-c",
+  "submodule.recurse=false",
+  "-c",
+  "fetch.recurseSubmodules=false",
+  "-c",
+  "push.recurseSubmodules=false"
+];
+let cachedWorkspaceMergeProjectionSupport = null;
+function gitCommandArgs(args) {
+  return ["git", ...NON_RECURSIVE_GIT_CONFIG, ...args];
+}
+function gitResult(cwd, args, options = {}) {
+  const result = Bun.spawnSync(gitCommandArgs(args), {
+    cwd,
+    ...options.stdin !== void 0 ? { stdin: options.stdin } : {},
+    stdout: "pipe",
+    stderr: "pipe",
+    env: options.environment ?? (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout), stderr: Buffer.from(result.stderr) };
+}
+function git(cwd, args, action, options = {}) {
+  const result = gitResult(cwd, args, options);
+  if (result.exitCode !== 0) {
+    const detail = result.stderr.toString().trim() || result.stdout.toString().trim() || `git exited ${result.exitCode}`;
+    throw new Error(`${action}: ${detail}`);
+  }
+  return result.stdout;
+}
+function gitText(cwd, args, action, options = {}) {
+  return git(cwd, args, action, options).toString().trim();
+}
+function gitVersionIsSupported(version) {
+  const match = /(?:^|\s)(\d+)\.(\d+)(?:\.\d+)?(?:\s|$)/u.exec(version);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > MINIMUM_MERGE_TREE_GIT_VERSION.major || major === MINIMUM_MERGE_TREE_GIT_VERSION.major && minor >= MINIMUM_MERGE_TREE_GIT_VERSION.minor;
+}
+function workspaceMergeProjectionSupport() {
+  if (cachedWorkspaceMergeProjectionSupport) return cachedWorkspaceMergeProjectionSupport;
+  if (process.env.R5D_WORKSPACE_MERGE_PROJECTION === "0") {
+    cachedWorkspaceMergeProjectionSupport = {
+      supported: false,
+      error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0; stale mounts will remain pinned until it is enabled"
+    };
+    return cachedWorkspaceMergeProjectionSupport;
+  }
+  const version = gitResult(void 0, ["--version"]);
+  const versionText = version.stdout.toString().trim();
+  if (version.exitCode !== 0 || !gitVersionIsSupported(versionText)) {
+    const observed = versionText || version.stderr.toString().trim() || `git exited ${version.exitCode}`;
+    cachedWorkspaceMergeProjectionSupport = {
+      supported: false,
+      error: `Workspace merge projection requires Git 2.40 or newer (found ${observed}); upgrade Git before synchronizing stale mounts`
+    };
+    return cachedWorkspaceMergeProjectionSupport;
+  }
+  cachedWorkspaceMergeProjectionSupport = { supported: true };
+  return cachedWorkspaceMergeProjectionSupport;
+}
+function normalizeWorkspaceRelativePath(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === "." || normalized.includes("\0") || normalized.split("/").some((segment) => segment === ".." || segment === ".git")) {
+    throw new Error(`Invalid workspace merge-projection path: ${value}`);
+  }
+  return normalized;
+}
+function requireObjectId(value, label) {
+  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(value)) throw new Error(`${label} is not a Git object id: ${value}`);
+  return value;
+}
+function requireCommit(workspacePath, revision, label) {
+  const head = gitText(workspacePath, ["rev-parse", "--verify", `${revision}^{commit}`], `resolve ${label}`);
+  return requireObjectId(head, label);
+}
+function workspacePrivateStateDirectory(workspacePath) {
+  const gitDirectory = import_node_path.default.join(workspacePath, ".git");
+  const gitStatus = import_node_fs.default.lstatSync(gitDirectory);
+  if (!gitStatus.isDirectory() || gitStatus.isSymbolicLink()) {
+    throw new Error(`Workspace Git directory is not a regular directory: ${gitDirectory}`);
+  }
+  const stateDirectory = import_node_path.default.join(gitDirectory, "r5d");
+  let stateStatus = null;
+  try {
+    stateStatus = import_node_fs.default.lstatSync(stateDirectory);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!stateStatus) import_node_fs.default.mkdirSync(stateDirectory, { mode: 448 });
+  else if (!stateStatus.isDirectory() || stateStatus.isSymbolicLink()) {
+    throw new Error(`Workspace Git private state is not a regular directory: ${stateDirectory}`);
+  }
+  return stateDirectory;
+}
+function temporaryIndexPath(workspacePath) {
+  return import_node_path.default.join(workspacePrivateStateDirectory(workspacePath), `tmp-index-${crypto.randomUUID()}`);
+}
+function temporaryIndexEnvironment(indexPath) {
+  return { ...(0, import_git_process_environment.workerGitProcessEnvironment)(), GIT_INDEX_FILE: indexPath };
+}
+function removeTemporaryIndex(indexPath) {
+  import_node_fs.default.rmSync(indexPath, { force: true });
+  import_node_fs.default.rmSync(`${indexPath}.lock`, { force: true });
+}
+function sourceEntryPath(sourceRoot, relativePath) {
+  const candidate = import_node_path.default.resolve(sourceRoot, ...relativePath.split("/"));
+  const relative = import_node_path.default.relative(sourceRoot, candidate);
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`Workspace merge-projection source escapes its root: ${relativePath}`);
+  }
+  return candidate;
+}
+function assertSameOpenFile(before, after, sourcePath) {
+  if (!after.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mode !== after.mode || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+}
+function hashRegularFile(workspacePath, sourcePath, entry) {
+  const descriptor = import_node_fs.default.openSync(sourcePath, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+  try {
+    const before = import_node_fs.default.fstatSync(descriptor);
+    if (!before.isFile() || before.size !== entry.size || (before.mode & 511) !== (entry.mode & 511)) {
+      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+    }
+    const objectId = requireObjectId(
+      gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection file ${sourcePath}`, {
+        stdin: descriptor
+      }),
+      `Workspace projection blob for ${sourcePath}`
+    );
+    const after = import_node_fs.default.fstatSync(descriptor);
+    assertSameOpenFile(before, after, sourcePath);
+    const pathStatus = import_node_fs.default.lstatSync(sourcePath);
+    if (pathStatus.dev !== after.dev || pathStatus.ino !== after.ino || !pathStatus.isFile() || pathStatus.isSymbolicLink()) {
+      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+    }
+    return objectId;
+  } finally {
+    import_node_fs.default.closeSync(descriptor);
+  }
+}
+function hashSymlink(workspacePath, sourcePath, entry) {
+  const status = import_node_fs.default.lstatSync(sourcePath);
+  if (!status.isSymbolicLink() || import_node_fs.default.readlinkSync(sourcePath) !== entry.target) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+  const objectId = requireObjectId(
+    gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection symlink ${sourcePath}`, {
+      stdin: Buffer.from(entry.target)
+    }),
+    `Workspace projection symlink blob for ${sourcePath}`
+  );
+  if (!import_node_fs.default.lstatSync(sourcePath).isSymbolicLink() || import_node_fs.default.readlinkSync(sourcePath) !== entry.target) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+  return objectId;
+}
+function indexMode(entry) {
+  if (entry.kind === "symlink") return "120000";
+  return (entry.mode & 73) !== 0 ? "100755" : "100644";
+}
+function indexInfoRecord(mode, objectId, relativePath) {
+  return Buffer.concat([Buffer.from(`${mode} ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]);
+}
+function synthesizeMountTree(input) {
+  const sourceRoot = import_node_path.default.resolve(input.sourcePath);
+  const entries = (0, import_working_tree_mirror.inspectWorkingTree)(sourceRoot, input.sourceMode);
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", "--empty"], "initialize workspace projection index", { environment });
+    const records = [];
+    for (const [relativePath, entry] of [...entries.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+      if (entry.kind === "directory") continue;
+      const sourcePath = sourceEntryPath(sourceRoot, relativePath);
+      const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
+      records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
+    }
+    if (records.length > 0) {
+      git(input.workspacePath, ["update-index", "-z", "--index-info"], "populate workspace projection index", {
+        environment,
+        stdin: Buffer.concat(records)
+      });
+    }
+    return requireObjectId(
+      gitText(input.workspacePath, ["write-tree"], "write workspace projection mount tree", { environment }),
+      "Workspace projection mount tree"
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
+  }
+}
+function nulRecords(content) {
+  const records = [];
+  let start = 0;
+  for (let index = 0; index < content.length; index += 1) {
+    if (content[index] !== 0) continue;
+    if (index > start) records.push(content.subarray(start, index));
+    start = index + 1;
+  }
+  if (start < content.length) records.push(content.subarray(start));
+  return records;
+}
+function indexedSubtreePaths(content, workspaceRelativePath) {
+  const prefix = Buffer.from(workspaceRelativePath);
+  const descendantPrefix = Buffer.from(`${workspaceRelativePath}/`);
+  const records = nulRecords(content).filter(
+    (record) => record.equals(prefix) || record.length > descendantPrefix.length && record.subarray(0, descendantPrefix.length).equals(descendantPrefix)
+  );
+  return records.length > 0 ? Buffer.concat(records.flatMap((record) => [record, Buffer.from([0])])) : Buffer.alloc(0);
+}
+function graftMountTree(input) {
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", input.basisHead], "read workspace projection basis", { environment });
+    const indexedPaths = git(input.workspacePath, ["ls-files", "-z"], "enumerate workspace projection basis", { environment });
+    const removedPaths = indexedSubtreePaths(indexedPaths, input.workspaceRelativePath);
+    if (removedPaths.length > 0) {
+      git(input.workspacePath, ["update-index", "--force-remove", "-z", "--stdin"], "remove prior workspace projection subtree", {
+        environment,
+        stdin: removedPaths
+      });
+    }
+    git(
+      input.workspacePath,
+      ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
+      "graft workspace projection mount tree",
+      { environment }
+    );
+    return requireObjectId(
+      gitText(input.workspacePath, ["write-tree"], "write grafted workspace projection tree", { environment }),
+      "Grafted workspace projection tree"
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
+  }
+}
+function synthesizeOursCommit(input) {
+  const mountTree = synthesizeMountTree({
+    workspacePath: input.workspacePath,
+    sourcePath: input.mount.sourcePath,
+    sourceMode: input.mount.sourceMode
+  });
+  const rootTree = graftMountTree({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: input.basisHead,
+    mountTree
+  });
+  const message = JSON.stringify({
+    type: "workspace_projection_basis",
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
+  return requireObjectId(
+    gitText(
+      input.workspacePath,
+      ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
+      `commit synthesized workspace projection for mount ${input.mount.id}`
+    ),
+    `Synthesized workspace projection commit for mount ${input.mount.id}`
+  );
+}
+function mergeWorkspaceProjectionMount(input) {
+  const support = workspaceMergeProjectionSupport();
+  if (!support.supported) throw new Error(support.error);
+  const workspacePath = import_node_path.default.resolve(input.workspacePath);
+  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.mount.workspaceRelativePath);
+  const basisHead = requireCommit(workspacePath, input.basisHead, `workspace projection basis for mount ${input.mount.id}`);
+  const currentHead = requireCommit(workspacePath, input.currentHead, "current workspace projection head");
+  const oursCommit = synthesizeOursCommit({
+    workspacePath,
+    mount: input.mount,
+    workspaceRelativePath,
+    basisHead,
+    attemptId: input.attemptId
+  });
+  const merged = gitResult(workspacePath, [
+    "merge-tree",
+    "--write-tree",
+    `--merge-base=${basisHead}`,
+    "--name-only",
+    "-z",
+    "--no-messages",
+    oursCommit,
+    currentHead
+  ]);
+  if (merged.exitCode !== 0 && merged.exitCode !== 1) {
+    const detail = merged.stderr.toString().trim() || merged.stdout.toString().trim() || `git exited ${merged.exitCode}`;
+    throw new Error(`Merge workspace projection for mount ${input.mount.id}: ${detail}`);
+  }
+  const records = nulRecords(merged.stdout);
+  const resultTree = records.shift()?.toString() ?? "";
+  requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
+  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit };
+  const conflictPaths = records.map((record) => record.toString()).sort();
+  return {
+    kind: "conflict",
+    oursCommit,
+    conflictPaths,
+    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`
+  };
+}
+function materializeWorkspaceProjectionTree(input) {
+  const workspacePath = import_node_path.default.resolve(input.workspacePath);
+  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.workspaceRelativePath);
+  const resultTree = requireObjectId(input.resultTree, "Workspace projection result tree");
+  const targetPath = import_node_path.default.join(workspacePath, ...workspaceRelativePath.split("/"));
+  (0, import_workspace_mount_boundary.assertManagedDirectoryPath)({
+    trustedRoot: workspacePath,
+    candidate: targetPath,
+    label: "Workspace merge-projection target"
+  });
+  git(workspacePath, ["cat-file", "-e", `${resultTree}^{tree}`], "resolve workspace merge-projection result tree");
+  const subtree = gitResult(workspacePath, ["cat-file", "-e", `${resultTree}:${workspaceRelativePath}`]);
+  if (subtree.exitCode !== 0) {
+    import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+    return;
+  }
+  const subtreeType = gitText(
+    workspacePath,
+    ["cat-file", "-t", `${resultTree}:${workspaceRelativePath}`],
+    "inspect workspace merge-projection result subtree"
+  );
+  if (subtreeType !== "tree") {
+    throw new Error(`Workspace merge-projection result is not a directory at ${workspaceRelativePath}`);
+  }
+  import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+  git(
+    workspacePath,
+    ["checkout", "--no-recurse-submodules", resultTree, "--", `:(literal)${workspaceRelativePath}`],
+    "materialize merged workspace projection subtree"
+  );
+}
+const workspaceMergeProjectionTestHarness = {
+  gitVersionIsSupported,
+  resetSupportProbe() {
+    cachedWorkspaceMergeProjectionSupport = null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  materializeWorkspaceProjectionTree,
+  mergeWorkspaceProjectionMount,
+  workspaceMergeProjectionSupport,
+  workspaceMergeProjectionTestHarness
+});