@ricsam/r5d-worker 0.0.137 → 0.0.138

package/dist/mjs/project-checkout-garbage.mjs

@@ -1,178 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-const PROJECT_DELETED_CHECKOUTS_DIRECTORY = ".r5d-deleted";
-function isRealDirectory(candidate) {
-  try {
-    return fs.lstatSync(candidate).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function stageProjectCheckoutForDeletion(projectRoot, branchName, checkoutPath) {
-  const garbageRoot = path.join(projectRoot, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  if (!isRealDirectory(checkoutPath)) throw new Error(`Cannot stage ${checkoutPath} for deletion: not a directory`);
-  fs.mkdirSync(garbageRoot, { recursive: true });
-  if (!isRealDirectory(garbageRoot)) throw new Error(`Cannot stage ${checkoutPath} for deletion: ${garbageRoot} is not a directory`);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const target = path.join(garbageRoot, `${branchName.replace(/\//g, "__")}-${timestamp}-${randomUUID().slice(0, 8)}`);
-  fs.renameSync(checkoutPath, target);
-  return target;
-}
-function stageProjectForDeletion(projectsRoot, projectRoot) {
-  const root = path.resolve(projectsRoot);
-  const resolved = path.resolve(projectRoot);
-  const relative = path.relative(root, resolved);
-  const segments = relative.split(path.sep);
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative) || segments.length !== 2 || segments.some((segment) => !segment || segment.startsWith("."))) {
-    throw new Error(`Cannot stage ${projectRoot} for deletion: not a project root under ${projectsRoot}`);
-  }
-  if (!isRealDirectory(resolved)) throw new Error(`Cannot stage ${projectRoot} for deletion: not a directory`);
-  const garbageRoot = path.join(root, segments[0], PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-  fs.mkdirSync(garbageRoot, { recursive: true });
-  if (!isRealDirectory(garbageRoot)) throw new Error(`Cannot stage ${projectRoot} for deletion: ${garbageRoot} is not a directory`);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const target = path.join(garbageRoot, `${segments[1]}-${timestamp}-${randomUUID().slice(0, 8)}`);
-  fs.renameSync(resolved, target);
-  return target;
-}
-function isStagedProjectCheckoutPath(projectsRoot, candidate) {
-  const relative = path.relative(path.resolve(projectsRoot), path.resolve(candidate));
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return false;
-  const segments = relative.split(path.sep);
-  const entry = segments[segments.length - 1];
-  if (!entry || entry.startsWith(".")) return false;
-  if (segments.length === 4)
-    return segments[2] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".") && !segments[1].startsWith(".");
-  if (segments.length === 3) return segments[1] === PROJECT_DELETED_CHECKOUTS_DIRECTORY && !segments[0].startsWith(".");
-  return false;
-}
-function ownedStagedPath(projectsRoot, candidate) {
-  const root = path.resolve(projectsRoot);
-  const resolved = path.resolve(candidate);
-  if (!isStagedProjectCheckoutPath(root, resolved)) return null;
-  let current = root;
-  for (const segment of path.relative(root, path.dirname(resolved)).split(path.sep)) {
-    current = path.join(current, segment);
-    if (!isRealDirectory(current)) return null;
-  }
-  let stat;
-  try {
-    stat = fs.lstatSync(resolved);
-  } catch {
-    return null;
-  }
-  if (stat.isSymbolicLink()) return { kind: "link" };
-  return stat.isDirectory() ? { kind: "directory" } : null;
-}
-function realDirectoryEntries(directory) {
-  if (!isRealDirectory(directory)) return [];
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-function discoverStagedProjectCheckouts(projectsRoot) {
-  const root = path.resolve(projectsRoot);
-  const staged = [];
-  for (const namespace of realDirectoryEntries(root)) {
-    if (namespace.startsWith(".")) continue;
-    const namespaceGarbageRoot = path.join(root, namespace, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-    for (const entry of realDirectoryEntries(namespaceGarbageRoot)) {
-      const candidate = path.join(namespaceGarbageRoot, entry);
-      if (ownedStagedPath(root, candidate)) staged.push(candidate);
-    }
-    for (const project of realDirectoryEntries(path.join(root, namespace))) {
-      if (project.startsWith(".")) continue;
-      const garbageRoot = path.join(root, namespace, project, PROJECT_DELETED_CHECKOUTS_DIRECTORY);
-      for (const entry of realDirectoryEntries(garbageRoot)) {
-        const candidate = path.join(garbageRoot, entry);
-        if (ownedStagedPath(root, candidate)) staged.push(candidate);
-      }
-    }
-  }
-  return staged;
-}
-async function removeStagedProjectCheckout(stagedPath) {
-  if (fs.lstatSync(stagedPath).isSymbolicLink()) {
-    fs.unlinkSync(stagedPath);
-    return;
-  }
-  if (process.platform === "win32") {
-    await fs.promises.rm(stagedPath, { recursive: true, force: true });
-    return;
-  }
-  const command = ["rm", "-rf", "--", stagedPath];
-  if (Bun.which("nice")) command.unshift("nice", "-n", "19");
-  if (process.platform === "linux" && Bun.which("ionice")) command.unshift("ionice", "-c", "3");
-  const child = Bun.spawn(command, { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
-  const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
-  if (exitCode !== 0) throw new Error(`rm exited ${exitCode}: ${stderr.trim()}`);
-  if (fs.existsSync(stagedPath)) throw new Error("staged checkout still exists after removal");
-}
-class ProjectCheckoutGarbageCollector {
-  projectsRoot;
-  remove;
-  log;
-  queued = /* @__PURE__ */ new Set();
-  tail = Promise.resolve();
-  collectedCount = 0;
-  constructor(options) {
-    this.projectsRoot = path.resolve(options.projectsRoot);
-    this.remove = options.remove ?? removeStagedProjectCheckout;
-    this.log = options.log ?? ((message) => process.stderr.write(`${message}
-`));
-  }
-  /** Number of removals that have completed successfully. */
-  get collected() {
-    return this.collectedCount;
-  }
-  /** Resolves once everything queued so far has been attempted. */
-  get idle() {
-    return this.tail;
-  }
-  enqueue(stagedPath) {
-    const resolved = path.resolve(stagedPath);
-    if (!ownedStagedPath(this.projectsRoot, resolved)) {
-      throw new Error(`Refusing to collect ${stagedPath}: not a staged checkout under ${this.projectsRoot}`);
-    }
-    if (this.queued.has(resolved)) return;
-    this.queued.add(resolved);
-    this.tail = this.tail.then(async () => {
-      try {
-        const owned = ownedStagedPath(this.projectsRoot, resolved);
-        if (owned) {
-          const startedAt = performance.now();
-          await this.remove(resolved);
-          this.collectedCount += 1;
-          this.log(`[r5d-worker] collected deleted checkout ${resolved} in ${Math.round(performance.now() - startedAt)}ms`);
-        } else if (fs.existsSync(resolved) || isRealDirectory(path.dirname(resolved))) {
-          this.log(`[r5d-worker] skipped deleted checkout ${resolved}: no longer an owned staged checkout`);
-        }
-      } catch (error) {
-        this.log(
-          `[r5d-worker] deleted checkout ${resolved} could not be collected yet: ${error instanceof Error ? error.message : String(error)}`
-        );
-      } finally {
-        this.queued.delete(resolved);
-      }
-    });
-  }
-  /** Enqueue every staged checkout left behind by an earlier process. */
-  sweep() {
-    const staged = discoverStagedProjectCheckouts(this.projectsRoot);
-    for (const stagedPath of staged) this.enqueue(stagedPath);
-    return staged.length;
-  }
-}
-export {
-  PROJECT_DELETED_CHECKOUTS_DIRECTORY,
-  ProjectCheckoutGarbageCollector,
-  discoverStagedProjectCheckouts,
-  isStagedProjectCheckoutPath,
-  ownedStagedPath,
-  removeStagedProjectCheckout,
-  stageProjectCheckoutForDeletion,
-  stageProjectForDeletion
-};

package/dist/mjs/project-mirror-fetch-policy.mjs

@@ -1,56 +0,0 @@
-function projectMirrorFetchDecision(input) {
-  if (!input.skippingEnabled) return { fetch: true, reason: "skipping_disabled" };
-  if (input.advertisedToken === void 0) return { fetch: true, reason: "no_advertised_token" };
-  if (input.fetchedToken === void 0) return { fetch: true, reason: "never_fetched" };
-  if (input.advertisedToken !== input.fetchedToken) return { fetch: true, reason: "token_changed" };
-  return { fetch: false, reason: "token_match" };
-}
-function planProjectMirrorObservationFetch(input) {
-  if (!input.skippingEnabled) return { scope: "project", reason: "skipping_disabled" };
-  if (input.advertisedMountTokens === void 0) {
-    const decision = projectMirrorFetchDecision({
-      advertisedToken: input.advertisedProjectToken,
-      fetchedToken: input.fetchedProjectToken,
-      skippingEnabled: true
-    });
-    return decision.fetch ? { scope: "project", reason: decision.reason } : { scope: "none" };
-  }
-  const mounts = [];
-  for (const branchName of [...input.branchNames].sort()) {
-    const decision = projectMirrorFetchDecision({
-      advertisedToken: input.advertisedMountTokens.get(branchName),
-      fetchedToken: input.fetchedMountTokens.get(branchName),
-      skippingEnabled: true
-    });
-    if (decision.fetch) mounts.push({ branchName, reason: decision.reason });
-  }
-  return mounts.length === 0 ? { scope: "none" } : { scope: "mounts", mounts };
-}
-const TOKEN_RE = /^[0-9a-f]{64}$/;
-const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-function parseProjectMirrorRefsTokensMessage(message) {
-  const projectTokens = /* @__PURE__ */ new Map();
-  if (message.tokens && typeof message.tokens === "object") {
-    for (const [projectId, token] of Object.entries(message.tokens)) {
-      if (typeof token === "string" && TOKEN_RE.test(token)) projectTokens.set(projectId, token);
-    }
-  }
-  const mountTokens = /* @__PURE__ */ new Map();
-  if (message.mountTokens && typeof message.mountTokens === "object") {
-    for (const [projectId, tokensByBranch] of Object.entries(message.mountTokens)) {
-      if (!tokensByBranch || typeof tokensByBranch !== "object") continue;
-      const perMount = /* @__PURE__ */ new Map();
-      for (const [branchName, token] of Object.entries(tokensByBranch)) {
-        if (typeof token === "string" && TOKEN_RE.test(token)) perMount.set(branchName, token);
-      }
-      mountTokens.set(projectId, perMount);
-    }
-  }
-  const workspaceHead = typeof message.workspaceHead === "string" && GIT_OBJECT_NAME_RE.test(message.workspaceHead) ? message.workspaceHead : void 0;
-  return { projectTokens, mountTokens, workspaceHead };
-}
-export {
-  parseProjectMirrorRefsTokensMessage,
-  planProjectMirrorObservationFetch,
-  projectMirrorFetchDecision
-};

package/dist/mjs/project-mirror-refs-token.mjs

@@ -1,53 +0,0 @@
-import { createHash } from "node:crypto";
-const PROJECT_MIRROR_REFS_TOKEN_NAMESPACES = ["refs/heads/", "refs/r5d/server-synced/"];
-const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
-const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
-const PROJECT_MIRROR_REF_LISTING_FORMAT = "--format=%(objectname) %(refname)";
-const GIT_OBJECT_NAME_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-function hashProjectMirrorRefs(refs) {
-  const lines = refs.map(({ objectName, refname }) => `${objectName} ${refname}`).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-  return createHash("sha256").update(lines.join("\n")).digest("hex");
-}
-function parseProjectMirrorRefListing(output, options = {}) {
-  return output.split(/\r?\n/).filter(Boolean).map((row) => {
-    const separator = row.indexOf(" ");
-    const objectName = separator < 0 ? "" : row.slice(0, separator);
-    const refname = separator < 0 ? "" : row.slice(separator + 1);
-    if (!GIT_OBJECT_NAME_RE.test(objectName) || refname.length === 0 || options.namespaces !== void 0 && !options.namespaces.some((prefix) => refname.startsWith(prefix))) {
-      throw new Error(`Invalid ref listing row: ${row}`);
-    }
-    return { refname, objectName };
-  });
-}
-function canonicalizeLocalProjectMirrorRefs(refs) {
-  const canonical = [];
-  for (const { refname, objectName } of refs) {
-    if (refname.startsWith(PROJECT_MIRROR_REF_PREFIX)) {
-      canonical.push({ refname: `refs/heads/${refname.slice(PROJECT_MIRROR_REF_PREFIX.length)}`, objectName });
-    } else if (refname.startsWith(PROJECT_SERVER_SYNCED_REF_PREFIX)) {
-      canonical.push({ refname, objectName });
-    }
-  }
-  return canonical;
-}
-function projectMirrorMountRefs(refs, mount) {
-  const headRef = `refs/heads/${mount.branchName}`;
-  const handoffPrefix = `${PROJECT_SERVER_SYNCED_REF_PREFIX}${mount.branchId}/`;
-  return refs.filter(({ refname }) => refname === headRef || refname.startsWith(handoffPrefix));
-}
-function projectMirrorRefsTokens(refs, mounts) {
-  const mountTokens = /* @__PURE__ */ new Map();
-  for (const mount of mounts) mountTokens.set(mount.branchName, hashProjectMirrorRefs(projectMirrorMountRefs(refs, mount)));
-  return { project: hashProjectMirrorRefs(refs), mounts: mountTokens };
-}
-export {
-  PROJECT_MIRROR_REFS_TOKEN_NAMESPACES,
-  PROJECT_MIRROR_REF_LISTING_FORMAT,
-  PROJECT_MIRROR_REF_PREFIX,
-  PROJECT_SERVER_SYNCED_REF_PREFIX,
-  canonicalizeLocalProjectMirrorRefs,
-  hashProjectMirrorRefs,
-  parseProjectMirrorRefListing,
-  projectMirrorMountRefs,
-  projectMirrorRefsTokens
-};