@ricsam/r5d-worker 0.0.93 → 0.0.95

package/dist/cjs/project-worktrees.cjs

@@ -32,6 +32,7 @@ __export(project_worktrees_exports, {
   ProjectBranchCreationRollbackIncompleteError: () => ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads: () => applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed: () => assertProjectMirrorHeadsPushed,
+  computeLocalProjectMirrorRefsToken: () => computeLocalProjectMirrorRefsToken,
   createLinkedProjectBranch: () => createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch: () => createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch: () => deleteLinkedProjectBranch,
@@ -57,6 +58,7 @@ var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_git_process_environment = require("./git-process-environment.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
+var import_project_mirror_refs_token = require("./project-mirror-refs-token.cjs");
 var import_working_tree_mirror = require("./working-tree-mirror.cjs");
 const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
 const PROJECT_WORKTREE_SNAPSHOT_MANIFEST = "transaction.json";
@@ -64,6 +66,7 @@ const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
 const MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES = 64 * 1024;
 const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID = (0, import_node_crypto.randomUUID)();
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const PROJECT_GIT_TRANSPORT_TIMEOUT_MS = 3e4;
 const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
   `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
 );
@@ -133,7 +136,7 @@ function git(cwd, args, action) {
 function tryGit(cwd, args) {
   return gitResult(cwd, args).exitCode === 0;
 }
-async function gitResultAsync(cwd, args) {
+async function gitResultAsync(cwd, args, timeoutMs) {
   const subprocess = Bun.spawn(gitCommandArgs(args), {
     cwd,
     stdin: "ignore",
@@ -141,12 +144,22 @@ async function gitResultAsync(cwd, args) {
     stderr: "pipe",
     env: (0, import_git_process_environment.workerGitProcessEnvironment)()
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(subprocess.stdout).text(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  let timedOut = false;
+  const timeout = timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    subprocess.kill("SIGKILL");
+  }, timeoutMs) : void 0;
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(subprocess.stdout).text(),
+      new Response(subprocess.stderr).text(),
+      subprocess.exited
+    ]);
+    if (timedOut) throw new Error(`Git transport timed out after ${timeoutMs}ms`);
+    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
 }
 async function gitAsync(cwd, args, action) {
   const result = await gitResultAsync(cwd, args);
@@ -861,25 +874,33 @@ async function configureRepository(input) {
   }
 }
 async function fetchProjectHeads(input) {
-  const originFetch = await gitResultAsync(input.primaryPath, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.originUrl, input.credentialHelper, input.originCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    "origin",
-    "+refs/heads/*:refs/remotes/origin/*"
-  ]);
+  const originFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.originUrl, input.credentialHelper, input.originCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      "origin",
+      "+refs/heads/*:refs/remotes/origin/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (originFetch.exitCode !== 0) {
     throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
   }
-  const mirrorFetch = await gitResultAsync(input.primaryPath, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
+  const mirrorFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      "+refs/heads/*:refs/r5d/mirror/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
     `${mirrorFetch.stderr}
 ${mirrorFetch.stdout}`
@@ -1258,19 +1279,24 @@ function removeProjectWorktrees(input) {
 }
 async function deleteProjectMirrorBranch(input) {
   (0, import_managed_paths.validateManagedBranchName)(input.branchName);
-  const deleted = await gitResultAsync(input.gitDirectory, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "push",
-    "--no-recurse-submodules",
-    input.mirrorUrl,
-    `:refs/heads/${input.branchName}`
-  ]);
+  const deleted = await gitResultAsync(
+    input.gitDirectory,
+    [
+      ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "push",
+      "--no-recurse-submodules",
+      input.mirrorUrl,
+      `:refs/heads/${input.branchName}`
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
 ${deleted.stdout}`)) {
     throw new Error(
       `Delete hidden project mirror for ${input.branchName}: ${deleted.stderr || deleted.stdout || `git exited ${deleted.exitCode}`}`
     );
   }
+  await gitResultAsync(input.gitDirectory, ["update-ref", "-d", `refs/r5d/mirror/${input.branchName}`]);
 }
 async function pushProjectMirrorHeads(input) {
   const results = [];
@@ -1284,21 +1310,51 @@ async function pushProjectMirrorHeads(input) {
     if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
       throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
     }
+    if (!input.expectedMirrorHeads.has(branchName)) {
+      throw new Error(`Missing hidden-mirror lease for project branch ${branchName}`);
+    }
+    const expectedMirrorHead = input.expectedMirrorHeads.get(branchName) ?? null;
+    if (expectedMirrorHead !== null && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(expectedMirrorHead)) {
+      throw new Error(`Invalid hidden-mirror lease for project branch ${branchName}`);
+    }
+    const branchId = input.branchIds.get(branchName);
+    if (!branchId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) {
+      throw new Error(`Missing valid branch incarnation for project branch ${branchName}`);
+    }
+    if (expectedMirrorHead) {
+      const handoffPrefix = `refs/r5d/server-synced/${branchId}/`;
+      const markedCommits = (await gitAsync(
+        checkoutPath,
+        ["for-each-ref", "--format=%(objectname)", handoffPrefix],
+        `inspect synchronized server commits before publishing ${branchName}`
+      )).split(/\r?\n/).filter((value) => /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value));
+      for (const markedCommit of markedCommits) {
+        const markerIsInLease = await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, expectedMirrorHead]);
+        if (markerIsInLease && !await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, head])) {
+          throw new Error(`Refusing to overwrite synchronized server commit history for project branch ${branchName}`);
+        }
+      }
+    }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
     }
-    await gitAsync(
+    const pushed = await gitResultAsync(
       checkoutPath,
       [
         ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
         "push",
         "--no-recurse-submodules",
+        `--force-with-lease=refs/heads/${branchName}:${expectedMirrorHead ?? ""}`,
         input.mirrorUrl,
-        `+${head}:refs/heads/${branchName}`
+        `${head}:refs/heads/${branchName}`
       ],
-      `push hidden project mirror for ${branchName}`
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
     );
+    if (pushed.exitCode !== 0) {
+      throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
+    }
+    await gitAsync(checkoutPath, ["update-ref", `refs/r5d/mirror/${branchName}`, head], `record pushed mirror tip ${branchName}`);
     results.push({ branchName, head, pushed: true });
   }
   return results;
@@ -1311,42 +1367,94 @@ function assertProjectMirrorHeadsPushed(results) {
 }
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const fetch = await gitResultAsync(primaryPath, [
-    ...(0, import_git_process_environment.gitTransportSecurityArgs)(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
-  if (fetch.exitCode !== 0)
-    throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  if (input.refreshRemote !== false) {
+    const fetch = await gitResultAsync(
+      primaryPath,
+      [
+        ...(0, import_git_process_environment.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}`}`);
+  }
   const observations = [];
   for (const branchName of [...input.branchNames].sort()) {
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
     const mirrorHead = await tryGitAsync(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
-    const shouldMove = Boolean(
-      mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+    const branchId = input.branchIds?.get(branchName);
+    if (branchId && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+    const handoffPrefix = branchId ? `refs/r5d/server-synced/${branchId}/` : null;
+    const handoffRows = handoffPrefix ? await gitAsync(
+      primaryPath,
+      ["for-each-ref", "--format=%(objectname) %(refname)", handoffPrefix],
+      `inspect synchronized server commits for ${branchName}`
+    ) : "";
+    const serverSyncedWorkspaceHeads = (await Promise.all(
+      handoffRows.split(/\r?\n/).map(async (row) => {
+        const separator = row.indexOf(" ");
+        if (separator < 0 || !mirrorHead) return null;
+        const markedCommit = row.slice(0, separator);
+        const ref = row.slice(separator + 1);
+        if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(markedCommit) || !handoffPrefix || !ref.startsWith(handoffPrefix)) {
+          return null;
+        }
+        const markerIsIntegrated = markedCommit === mirrorHead || await tryGitAsync(primaryPath, ["merge-base", "--is-ancestor", markedCommit, mirrorHead]);
+        if (!markerIsIntegrated) return null;
+        const workspaceHead = ref.slice(handoffPrefix.length);
+        return /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(workspaceHead) ? workspaceHead : null;
+      })
+    )).filter((workspaceHead) => workspaceHead !== null).sort();
+    const fastForward = Boolean(
+      mirrorHead && mirrorHead !== previousHead && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])
     );
+    const serverSynced = Boolean(mirrorHead && mirrorHead !== previousHead && serverSyncedWorkspaceHeads.length > 0);
+    const shouldMove = Boolean(mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || fastForward || serverSynced));
     observations.push({
       branchName,
       previousHead,
       mirrorHead,
-      mode: input.allowNonFastForward ? "reseed" : "fast_forward",
+      mode: input.allowNonFastForward ? "reseed" : serverSynced && !fastForward ? "server_synced" : "fast_forward",
+      serverSyncedWorkspaceHeads,
       shouldMove
     });
   }
   return observations;
 }
+async function computeLocalProjectMirrorRefsToken(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  const rows = await gitAsync(
+    primaryPath,
+    ["for-each-ref", "--format=%(objectname) %(refname)", import_project_mirror_refs_token.PROJECT_MIRROR_REF_PREFIX, import_project_mirror_refs_token.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 (0, import_project_mirror_refs_token.hashProjectMirrorRefs)((0, import_project_mirror_refs_token.canonicalizeLocalProjectMirrorRefs)(refs));
+}
 async function applyObservedProjectMirrorHeads(input) {
   const results = [];
   for (const observation of [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
     const { branchName, mirrorHead } = observation;
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
+    const serverSyncedCovered = observation.mode !== "server_synced" || (input.serverSyncedWorkspaceCovered ? await input.serverSyncedWorkspaceCovered(observation) : false);
+    if (!observation.shouldMove || !serverSyncedCovered || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
@@ -1358,14 +1466,14 @@ async function applyObservedProjectMirrorHeads(input) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
-    if (observation.mode === "reseed") {
+    if (observation.mode === "reseed" || observation.mode === "server_synced") {
       await preserveHead(checkoutPath);
       if (!mutationAllowed()) {
         results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
         continue;
       }
     }
-    const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
+    const action = observation.mode === "reseed" ? "reseed" : observation.mode === "server_synced" ? "adopt server commit" : "fast-forward";
     await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
     await gitAsync(
       checkoutPath,
@@ -1421,6 +1529,7 @@ const projectWorktreesTestHarness = {
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
+  computeLocalProjectMirrorRefsToken,
   createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,