@ricsam/r5d-worker 0.0.100 → 0.0.103

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.100",
+  "version": "0.0.103",
   "type": "module"
 }

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

@@ -1,16 +1,56 @@
-const PROJECT_MIRROR_FETCH_BACKSTOP_MS = 10 * 6e4;
 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" };
-  const backstopMs = input.backstopMs ?? PROJECT_MIRROR_FETCH_BACKSTOP_MS;
-  if (input.lastFetchAtMs === void 0 || input.nowMs - input.lastFetchAtMs >= backstopMs) {
-    return { fetch: true, reason: "backstop_elapsed" };
-  }
   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 {
-  PROJECT_MIRROR_FETCH_BACKSTOP_MS,
+  parseProjectMirrorRefsTokensMessage,
+  planProjectMirrorObservationFetch,
   projectMirrorFetchDecision
 };

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

@@ -1,10 +1,24 @@
 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) {
@@ -16,9 +30,24 @@ function canonicalizeLocalProjectMirrorRefs(refs) {
   }
   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
+  hashProjectMirrorRefs,
+  parseProjectMirrorRefListing,
+  projectMirrorMountRefs,
+  projectMirrorRefsTokens
 };

package/dist/mjs/project-worktrees.mjs

@@ -6,9 +6,11 @@ import { gitCredentialUsernameConfigKey, gitTransportSecurityArgs, workerGitProc
 import { validateManagedBranchName } from "./managed-paths.mjs";
 import {
   canonicalizeLocalProjectMirrorRefs,
-  hashProjectMirrorRefs,
+  parseProjectMirrorRefListing,
+  PROJECT_MIRROR_REF_LISTING_FORMAT,
   PROJECT_MIRROR_REF_PREFIX,
-  PROJECT_SERVER_SYNCED_REF_PREFIX
+  PROJECT_SERVER_SYNCED_REF_PREFIX,
+  projectMirrorRefsTokens
 } from "./project-mirror-refs-token.mjs";
 import { mirrorWorkingTree } from "./working-tree-mirror.mjs";
 const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
@@ -1125,8 +1127,12 @@ function createLinkedProjectBranch(input) {
     );
     configureProjectBranchTracking(targetPath, input.branchName, input.branchName);
     assertNoSymlinkBranchPathComponents(input.projectRoot, targetPath);
-    git(targetPath, ["read-tree", sourceHead], `initialize linked worktree index ${input.branchName}`);
-    mirrorWorkingTree({ sourceRoot: sourcePath, targetRoot: targetPath, sourceMode: "git", deletionMode: "git" });
+    if (input.workingTree === "carry") {
+      git(targetPath, ["read-tree", sourceHead], `initialize linked worktree index ${input.branchName}`);
+      mirrorWorkingTree({ sourceRoot: sourcePath, targetRoot: targetPath, sourceMode: "git", deletionMode: "git" });
+    } else {
+      git(targetPath, ["reset", "--hard", sourceHead], `check out linked worktree ${input.branchName}`);
+    }
     return { branchPath: targetPath, baseCommitHash: sourceHead };
   } catch (error) {
     if (branchCreated) {
@@ -1316,24 +1322,46 @@ function assertProjectMirrorHeadsPushed(results) {
     throw new Error(`Hidden project mirror publication skipped ${skipped.branchName}${skipped.reason ? ` (${skipped.reason})` : ""}`);
   }
 }
+const PROJECT_MIRROR_FETCH_REFSPECS = ["+refs/heads/*:refs/r5d/mirror/*", "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"];
+function projectMirrorMountFetchRefspecs(branchName, branchId) {
+  validateManagedBranchName(branchName);
+  if (branchId !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+  return [
+    `+refs/heads/${branchName}:refs/r5d/mirror/${branchName}`,
+    branchId === void 0 ? "+refs/r5d/server-synced/*:refs/r5d/server-synced/*" : `+refs/r5d/server-synced/${branchId}/*:refs/r5d/server-synced/${branchId}/*`
+  ];
+}
+async function fetchProjectMirrorRefs(input) {
+  const fetch = (refspecs) => gitResultAsync(
+    input.primaryPath,
+    [
+      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      ...refspecs
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
+  if (input.fetchOnlyBranches && input.fetchOnlyBranches.size > 0) {
+    const refspecs = [...input.fetchOnlyBranches].sort().flatMap((branchName) => projectMirrorMountFetchRefspecs(branchName, input.branchIds?.get(branchName)));
+    const scoped = await fetch(refspecs);
+    if (scoped.exitCode === 0) return;
+    if (!/(couldn't find remote ref|no such ref)/i.test(`${scoped.stderr}
+${scoped.stdout}`)) {
+      throw new Error(`Refresh project head mirror: ${scoped.stderr || scoped.stdout || `git exited ${scoped.exitCode}`}`);
+    }
+  }
+  const whole = await fetch(PROJECT_MIRROR_FETCH_REFSPECS);
+  if (whole.exitCode !== 0) {
+    throw new Error(`Refresh project head mirror: ${whole.stderr || whole.stdout || `git exited ${whole.exitCode}`}`);
+  }
+}
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  if (input.refreshRemote !== false) {
-    const fetch = await gitResultAsync(
-      primaryPath,
-      [
-        ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-        "fetch",
-        "--no-recurse-submodules",
-        "--prune",
-        input.mirrorUrl,
-        "+refs/heads/*:refs/r5d/mirror/*",
-        "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"
-      ],
-      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
-    );
-    if (fetch.exitCode !== 0)
-      throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  if (input.refreshRemote !== false && !(input.fetchOnlyBranches && input.fetchOnlyBranches.size === 0)) {
+    await fetchProjectMirrorRefs({ ...input, primaryPath });
   }
   const observations = [];
   for (const branchName of [...input.branchNames].sort()) {
@@ -1380,23 +1408,14 @@ async function observeProjectMirrorHeads(input) {
   }
   return observations;
 }
-async function computeLocalProjectMirrorRefsToken(input) {
+async function computeLocalProjectMirrorRefsTokens(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
   const rows = await gitAsync(
     primaryPath,
-    ["for-each-ref", "--format=%(objectname) %(refname)", PROJECT_MIRROR_REF_PREFIX, PROJECT_SERVER_SYNCED_REF_PREFIX],
+    ["for-each-ref", PROJECT_MIRROR_REF_LISTING_FORMAT, PROJECT_MIRROR_REF_PREFIX, PROJECT_SERVER_SYNCED_REF_PREFIX],
     "list cached project mirror refs"
   );
-  const refs = rows.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 (!/^[0-9a-f]{40,64}$/.test(objectName) || refname.length === 0) {
-      throw new Error(`Invalid cached mirror ref listing row: ${row}`);
-    }
-    return { refname, objectName };
-  });
-  return hashProjectMirrorRefs(canonicalizeLocalProjectMirrorRefs(refs));
+  return projectMirrorRefsTokens(canonicalizeLocalProjectMirrorRefs(parseProjectMirrorRefListing(rows)), input.mounts);
 }
 async function applyObservedProjectMirrorHeads(input) {
   const results = [];
@@ -1479,7 +1498,7 @@ export {
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
-  computeLocalProjectMirrorRefsToken,
+  computeLocalProjectMirrorRefsTokens,
   createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,