@ricsam/r5d-worker 0.0.36 → 0.0.38

package/dist/cjs/managed-paths.cjs

@@ -0,0 +1,158 @@
+"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 managed_paths_exports = {};
+__export(managed_paths_exports, {
+  BRANCH_NAME_MAX_LENGTH: () => BRANCH_NAME_MAX_LENGTH,
+  BRANCH_NAME_PATTERN: () => BRANCH_NAME_PATTERN,
+  assertPathInside: () => assertPathInside,
+  legacyProjectSlug: () => legacyProjectSlug,
+  managedBranchPath: () => managedBranchPath,
+  managedProjectRoot: () => managedProjectRoot,
+  migrateLegacyProjectRoots: () => migrateLegacyProjectRoots,
+  validateCheckoutPathSegments: () => validateCheckoutPathSegments,
+  validateManagedBranchName: () => validateManagedBranchName
+});
+module.exports = __toCommonJS(managed_paths_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const BRANCH_NAME_MAX_LENGTH = 45;
+const BRANCH_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/;
+const PROJECT_SEGMENT_PATTERN = /^[a-z0-9._-]+$/;
+const WINDOWS_RESERVED_PATH_SEGMENT = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
+function validateManagedBranchName(branchName) {
+  if (typeof branchName !== "string" || branchName.length === 0) {
+    throw new Error("Branch name is required");
+  }
+  if (branchName.length > BRANCH_NAME_MAX_LENGTH) {
+    throw new Error(`Branch name must be ${BRANCH_NAME_MAX_LENGTH} characters or fewer`);
+  }
+  if (!BRANCH_NAME_PATTERN.test(branchName)) {
+    throw new Error(`Invalid branch name from server: ${branchName}`);
+  }
+  const reserved = branchName.split("/").find((segment) => WINDOWS_RESERVED_PATH_SEGMENT.test(segment));
+  if (reserved) {
+    throw new Error(`Invalid branch name from server: reserved path segment '${reserved}'`);
+  }
+}
+function validateCheckoutPathSegments(value) {
+  if (!Array.isArray(value) || value.length !== 2) {
+    throw new Error("Invalid checkout path from server: expected namespace and project segments");
+  }
+  const segments = value;
+  for (const segment of segments) {
+    if (typeof segment !== "string" || !PROJECT_SEGMENT_PATTERN.test(segment) || segment !== segment.toLowerCase() || segment === "." || segment === ".." || segment === ".git" || segment.endsWith(".") || WINDOWS_RESERVED_PATH_SEGMENT.test(segment)) {
+      throw new Error(`Invalid checkout path segment from server: ${String(segment)}`);
+    }
+  }
+  return [segments[0], segments[1]];
+}
+function assertPathInside(root, candidate, label) {
+  const resolvedRoot = import_node_path.default.resolve(root);
+  const resolvedCandidate = import_node_path.default.resolve(candidate);
+  const relative = import_node_path.default.relative(resolvedRoot, resolvedCandidate);
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`${label} escapes its managed root: ${candidate}`);
+  }
+}
+function assertNoSymlinkComponents(root, candidate) {
+  assertPathInside(root, candidate, "Checkout path");
+  const relative = import_node_path.default.relative(import_node_path.default.resolve(root), import_node_path.default.resolve(candidate));
+  let current = import_node_path.default.resolve(root);
+  for (const component of relative.split(import_node_path.default.sep).filter(Boolean)) {
+    current = import_node_path.default.join(current, component);
+    if (!import_node_fs.default.existsSync(current)) break;
+    if (import_node_fs.default.lstatSync(current).isSymbolicLink()) {
+      throw new Error(`Checkout path contains a symbolic link: ${current}`);
+    }
+  }
+}
+function managedProjectRoot(projectsRoot, checkoutPathSegments) {
+  const segments = validateCheckoutPathSegments(checkoutPathSegments);
+  const result = import_node_path.default.join(projectsRoot, ...segments);
+  assertNoSymlinkComponents(projectsRoot, result);
+  return result;
+}
+function managedBranchPath(projectsRoot, checkoutPathSegments, branchName) {
+  validateManagedBranchName(branchName);
+  const projectRoot = managedProjectRoot(projectsRoot, checkoutPathSegments);
+  const result = import_node_path.default.join(projectRoot, ...branchName.split("/"));
+  assertNoSymlinkComponents(projectRoot, result);
+  return result;
+}
+function legacyProjectSlug(projectPath, projectId) {
+  return (projectPath || projectId).trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || projectId;
+}
+function migrateLegacyProjectRoots(projectsRoot, projects) {
+  const resolvedRoot = import_node_path.default.resolve(projectsRoot);
+  const legacyOwners = /* @__PURE__ */ new Map();
+  const nestedOwners = /* @__PURE__ */ new Map();
+  const moves = [];
+  for (const project of projects) {
+    const nestedRoot = managedProjectRoot(resolvedRoot, project.checkoutPathSegments);
+    const legacySlug = legacyProjectSlug(project.projectPath, project.projectId);
+    const legacyRoot = import_node_path.default.join(resolvedRoot, legacySlug);
+    assertNoSymlinkComponents(resolvedRoot, legacyRoot);
+    const existingLegacyOwner = legacyOwners.get(legacyRoot);
+    if (existingLegacyOwner) {
+      throw new Error(`Projects ${existingLegacyOwner} and ${project.projectId} collide at legacy checkout path '${legacyRoot}'`);
+    }
+    legacyOwners.set(legacyRoot, project.projectId);
+    const existingNestedOwner = nestedOwners.get(nestedRoot);
+    if (existingNestedOwner) {
+      throw new Error(`Projects ${existingNestedOwner} and ${project.projectId} collide at checkout path '${nestedRoot}'`);
+    }
+    nestedOwners.set(nestedRoot, project.projectId);
+    const legacyExists = import_node_fs.default.existsSync(legacyRoot);
+    const nestedExists = import_node_fs.default.existsSync(nestedRoot);
+    if (legacyExists && nestedExists) {
+      throw new Error(
+        `Checkout migration is ambiguous for ${project.projectPath}: both '${legacyRoot}' and '${nestedRoot}' exist. Preserve the desired checkout and remove or relocate the other path before reconnecting the worker.`
+      );
+    }
+    if (legacyExists) moves.push({ projectId: project.projectId, legacyRoot, nestedRoot });
+  }
+  for (const move of moves) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(move.nestedRoot), { recursive: true });
+    assertNoSymlinkComponents(resolvedRoot, import_node_path.default.dirname(move.nestedRoot));
+    import_node_fs.default.renameSync(move.legacyRoot, move.nestedRoot);
+  }
+  return moves.map((move) => move.projectId);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BRANCH_NAME_MAX_LENGTH,
+  BRANCH_NAME_PATTERN,
+  assertPathInside,
+  legacyProjectSlug,
+  managedBranchPath,
+  managedProjectRoot,
+  migrateLegacyProjectRoots,
+  validateCheckoutPathSegments,
+  validateManagedBranchName
+});

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "type": "commonjs"
 }