@ricsam/r5d-worker 0.0.86 → 0.0.87

package/dist/mjs/main.mjs

@@ -847,6 +847,33 @@ function tryGit(args, options = {}) {
     return false;
   }
 }
+async function runGitAsync(args, options = {}) {
+  const command = workerGitCommand.commandArgs(args);
+  const subprocess = Bun.spawn(command, {
+    cwd: options.cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: workerGitProcessEnvironment()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed: ${stderr.trim() || stdout.trim() || `exit ${exitCode}`}`);
+  }
+  return stdout.trim();
+}
+async function tryGitAsync(args, options = {}) {
+  try {
+    await runGitAsync(args, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getGitBlobHashForContent(content) {
   const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : content;
   return createHash("sha1").update(`blob ${buffer.length}\0`).update(buffer).digest("hex");
@@ -3818,10 +3845,14 @@ async function startWorker(options) {
     }
     return mounts;
   };
-  const workspaceLocalHead = () => fs.existsSync(path.join(workspaceShadowRoot, ".git")) && tryGit(["rev-parse", "--verify", "HEAD"], { cwd: workspaceShadowRoot }) ? runGit(["rev-parse", "HEAD"], { cwd: workspaceShadowRoot }) : null;
-  const workspaceGitStatus = () => {
+  const workspaceLocalHead = async () => {
+    if (!fs.existsSync(path.join(workspaceShadowRoot, ".git"))) return null;
+    if (!await tryGitAsync(["rev-parse", "--verify", "HEAD"], { cwd: workspaceShadowRoot })) return null;
+    return runGitAsync(["rev-parse", "HEAD"], { cwd: workspaceShadowRoot });
+  };
+  const workspaceGitStatus = async () => {
     try {
-      return runGit(["status", "--porcelain"], { cwd: workspaceShadowRoot });
+      return await runGitAsync(["status", "--porcelain"], { cwd: workspaceShadowRoot });
     } catch {
       return "";
     }
@@ -3834,7 +3865,7 @@ async function startWorker(options) {
       })
     )
   ].sort();
-  const ensureConfiguredProjects = () => {
+  const ensureConfiguredProjects = async () => {
     for (const project of projectConfigById.values()) {
       validateProjectId(project.projectId);
       assertRepositoryTransitionState(project);
@@ -3871,7 +3902,7 @@ async function startWorker(options) {
       }
       try {
         const connection = projectConnection(project);
-        const states = ensureProjectWorktrees({
+        const states = await ensureProjectWorktrees({
           projectRoot,
           snapshotRoot: projectWorktreeSnapshotsRoot,
           primaryBranchName: primaryProjectBranch(project),
@@ -3920,13 +3951,13 @@ async function startWorker(options) {
       }
     }
   };
-  const collectAheadOfOriginBranches = () => {
+  const collectAheadOfOriginBranches = async () => {
     const aheadBranches = [];
     for (const project of projectConfigById.values()) {
       if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
       const connection = projectConnection(project);
       const primaryPath = configuredProjectBranchPath(projectsRoot, project, primaryProjectBranch(project));
-      if (!tryGit(
+      if (!await tryGitAsync(
         [
           ...gitTransportSecurityArgs(connection.originUrl, connection.credentialHelper, connection.originCredentialUsername),
           "fetch",
@@ -3950,11 +3981,11 @@ async function startWorker(options) {
             primaryBranchName: primaryProjectBranch(project),
             defaultBranch: project.defaultBranch
           })}`;
-          if (tryGit(["show-ref", "--verify", "--quiet", originRef], { cwd: branchPath })) {
-            const counts = runGit(["rev-list", "--left-right", "--count", `${originRef}...HEAD`], { cwd: branchPath }).split(/\s+/).map(Number);
+          if (await tryGitAsync(["show-ref", "--verify", "--quiet", originRef], { cwd: branchPath })) {
+            const counts = (await runGitAsync(["rev-list", "--left-right", "--count", `${originRef}...HEAD`], { cwd: branchPath })).split(/\s+/).map(Number);
             ahead = Number.isSafeInteger(counts[1]) ? counts[1] : 0;
-          } else if (tryGit(["cat-file", "-e", `${branch.baseCommitHash}^{commit}`], { cwd: branchPath })) {
-            const count = Number(runGit(["rev-list", "--count", `${branch.baseCommitHash}..HEAD`], { cwd: branchPath }));
+          } else if (await tryGitAsync(["cat-file", "-e", `${branch.baseCommitHash}^{commit}`], { cwd: branchPath })) {
+            const count = Number(await runGitAsync(["rev-list", "--count", `${branch.baseCommitHash}..HEAD`], { cwd: branchPath }));
             ahead = Number.isSafeInteger(count) ? count : 0;
           }
           if (ahead > 0) aheadBranches.push({ projectId: project.projectId, branchName: branch.branchName, ahead });
@@ -3970,19 +4001,19 @@ async function startWorker(options) {
       (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
     );
   };
-  const captureProjectHeadsForWorkspacePublication = () => {
+  const captureProjectHeadsForWorkspacePublication = async () => {
     const heads = /* @__PURE__ */ new Map();
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId)) continue;
       for (const branch of project.branches) {
         const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
         if (!hasProjectWorktree(branchPath)) continue;
-        heads.set(projectMountId(project.projectId, branch.branchName), runGit(["rev-parse", "HEAD"], { cwd: branchPath }));
+        heads.set(projectMountId(project.projectId, branch.branchName), await runGitAsync(["rev-parse", "HEAD"], { cwd: branchPath }));
       }
     }
     return heads;
   };
-  const pushChangedProjectHeads = (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
     const active = new Set(activeMountIds);
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId) || !repositoryMirrorWritesAllowed(project)) continue;
@@ -3998,7 +4029,7 @@ async function startWorker(options) {
       }
       if (changed.size === 0) continue;
       const connection = projectConnection(project);
-      const results = pushProjectMirrorHeads({
+      const results = await pushProjectMirrorHeads({
         projectRoot: configuredProjectRoot(projectsRoot, project),
         branchNames: project.branches.map(({ branchName }) => branchName),
         mirrorUrl: connection.mirrorUrl,
@@ -4029,7 +4060,7 @@ async function startWorker(options) {
       if (!active.has(deletion.id)) continue;
       if (!repositoryMirrorWritesAllowed(projectConfigById.get(deletion.projectId))) continue;
       if (!deletion.projectDeleted) {
-        deleteProjectMirrorBranch({
+        await deleteProjectMirrorBranch({
           gitDirectory: deletion.gitDirectory,
           branchName: deletion.branchName,
           mirrorUrl: deletion.mirrorUrl,
@@ -4050,7 +4081,7 @@ async function startWorker(options) {
       lastObservedProjectHeads.delete(key);
     }
   };
-  const observeProjectHeadsBeforeOuterWorkspace = (input) => {
+  const observeProjectHeadsBeforeOuterWorkspace = async (input) => {
     const bundles = [];
     for (const project of projectConfigById.values()) {
       if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
@@ -4062,7 +4093,7 @@ async function startWorker(options) {
           projectId: project.projectId,
           projectRoot,
           primaryBranchName,
-          observations: observeProjectMirrorHeads({
+          observations: await observeProjectMirrorHeads({
             projectRoot,
             primaryBranchName,
             branchNames: project.branches.map(({ branchName }) => branchName),
@@ -4082,7 +4113,7 @@ async function startWorker(options) {
     }
     return bundles;
   };
-  const applyObservedProjectHeadsAfterInboundWorkspace = (bundles, activeMountIds, requireObservedHeads) => {
+  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads) => {
     const active = new Set(activeMountIds);
     for (const bundle of bundles) {
       const project = projectConfigById.get(bundle.projectId);
@@ -4090,7 +4121,7 @@ async function startWorker(options) {
       const observations = bundle.observations.filter(({ branchName }) => active.has(projectMountId(project.projectId, branchName)));
       if (observations.length === 0) continue;
       try {
-        const refreshed = applyObservedProjectMirrorHeads({
+        const refreshed = await applyObservedProjectMirrorHeads({
           projectRoot: bundle.projectRoot,
           primaryBranchName: bundle.primaryBranchName,
           observations,
@@ -4100,7 +4131,7 @@ async function startWorker(options) {
           for (const observation of observations) {
             if (!observation.shouldMove || !observation.mirrorHead) continue;
             const checkoutPath = configuredProjectBranchPath(projectsRoot, project, observation.branchName);
-            const currentHead = runGit(["rev-parse", "HEAD"], { cwd: checkoutPath });
+            const currentHead = await runGitAsync(["rev-parse", "HEAD"], { cwd: checkoutPath });
             if (currentHead !== observation.mirrorHead) {
               throw new Error(
                 `Project ${project.projectId}/${observation.branchName} did not apply observed hidden mirror head ${observation.mirrorHead}`
@@ -4123,7 +4154,7 @@ async function startWorker(options) {
       }
     }
   };
-  const mapWorkspaceGitResult = (attemptId, trigger, result) => {
+  const mapWorkspaceGitResult = async (attemptId, trigger, result) => {
     const activeProjectBranchPublications = activeProjectBranchPublicationEvidence([...projectConfigById.values()], result.activeMountIds);
     return {
       type: "workspace_sync",
@@ -4136,7 +4167,7 @@ async function startWorker(options) {
       ...result.publishedHead ? { publishedHead: result.publishedHead } : {},
       rebaseCount: result.rebaseCount,
       diffSizeBytes: result.diffSizeBytes,
-      gitStatus: workspaceGitStatus(),
+      gitStatus: await workspaceGitStatus(),
       affectedProjects: affectedProjects(result.affectedPaths),
       affectedPaths: result.affectedPaths,
       activeMountIds: result.activeMountIds,
@@ -4151,23 +4182,26 @@ async function startWorker(options) {
       ...result.error ? { error: result.error } : {}
     };
   };
-  const failedWorkspaceSyncResult = (attemptId, trigger, error) => ({
-    type: "workspace_sync",
-    attemptId,
-    workerLabel: label,
-    trigger,
-    outcome: "failed",
-    startingHead: workspaceLocalHead(),
-    ...workspaceLocalHead() ? { localHead: workspaceLocalHead() } : {},
-    rebaseCount: 0,
-    diffSizeBytes: 0,
-    gitStatus: workspaceGitStatus(),
-    affectedProjects: [],
-    affectedPaths: [],
-    discardedPaths: [],
-    localChangesDiscarded: false,
-    error: error instanceof Error ? error.message : String(error)
-  });
+  const failedWorkspaceSyncResult = async (attemptId, trigger, error) => {
+    const localHead = await workspaceLocalHead();
+    return {
+      type: "workspace_sync",
+      attemptId,
+      workerLabel: label,
+      trigger,
+      outcome: "failed",
+      startingHead: localHead,
+      ...localHead ? { localHead } : {},
+      rebaseCount: 0,
+      diffSizeBytes: 0,
+      gitStatus: await workspaceGitStatus(),
+      affectedProjects: [],
+      affectedPaths: [],
+      discardedPaths: [],
+      localChangesDiscarded: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  };
   const performWorkspaceSync = async (input) => {
     if (!workspaceRemoteUrl || !workspaceCredentialHelper || !workspaceCredentialUsername || !workspaceGitIdentity) {
       throw new Error("Worker workspace configuration has not been received");
@@ -4180,11 +4214,11 @@ async function startWorker(options) {
       if (resetHasBusyLiveMount) {
         throw new Error("Workspace reset cannot observe project mirror heads while a live mount is busy; remediation remains active");
       }
-      const observedProjectHeads2 = observeProjectHeadsBeforeOuterWorkspace({
+      const observedProjectHeads2 = await observeProjectHeadsBeforeOuterWorkspace({
         allowNonFastForward: true,
         failClosed: true
       });
-      const reset = resetWorkspaceGit({
+      const reset = await resetWorkspaceGit({
         workspacePath: workspaceShadowRoot,
         remoteUrl: workspaceRemoteUrl,
         credentialHelper: workspaceCredentialHelper,
@@ -4192,7 +4226,7 @@ async function startWorker(options) {
         gitIdentity: workspaceGitIdentity,
         mounts: configuredMounts
       });
-      applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
+      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
       return {
         type: "workspace_sync",
         attemptId: input.attemptId,
@@ -4204,7 +4238,7 @@ async function startWorker(options) {
         ...reset.remoteHead ? { publishedHead: reset.remoteHead } : {},
         rebaseCount: 0,
         diffSizeBytes: 0,
-        gitStatus: workspaceGitStatus(),
+        gitStatus: await workspaceGitStatus(),
         affectedProjects: affectedProjects(reset.discardedPaths),
         affectedPaths: reset.discardedPaths,
         activeMountIds: reset.activeMountIds,
@@ -4215,13 +4249,13 @@ async function startWorker(options) {
     }
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? workspaceGitMountsForRemediation(configuredMounts) : configuredMounts;
-    const observedProjectHeads = outerRemediation ? [] : observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
     const inboundMoveMountIds = new Set(
       observedProjectHeads.flatMap(
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
       )
     );
-    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : captureProjectHeadsForWorkspacePublication();
+    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : await captureProjectHeadsForWorkspacePublication();
     const result = await synchronizeWorkspaceGit({
       attemptId: input.attemptId,
       workerLabel: label,
@@ -4236,13 +4270,13 @@ async function startWorker(options) {
       skipMountMirror: outerRemediation,
       requiredAncestorHeads: input.requiredAncestorHeads,
       assertStillAdmitted: input.assertStillAdmitted,
-      afterWorkspacePublished: outerRemediation ? void 0 : ({ activeMountIds, publishedHead }) => {
-        pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
+      afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
+        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
       }
     });
     input.assertStillAdmitted?.();
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
-      applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
+      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
     }
     return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
   };
@@ -4273,7 +4307,7 @@ async function startWorker(options) {
     };
     if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
       const result2 = {
-        ...failedWorkspaceSyncResult(
+        ...await failedWorkspaceSyncResult(
           attemptId,
           input.trigger,
           new Error(
@@ -4300,7 +4334,7 @@ async function startWorker(options) {
         queueEnteredAt = Date.now();
         syncStartedAt = Date.now();
         if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
-          return failedWorkspaceSyncResult(
+          return await failedWorkspaceSyncResult(
             attemptId,
             input.trigger,
             new Error(
@@ -4339,7 +4373,7 @@ async function startWorker(options) {
             },
             exitCode: 1
           });
-          return failedWorkspaceSyncResult(attemptId, input.trigger, error);
+          return await failedWorkspaceSyncResult(attemptId, input.trigger, error);
         }
       });
     } finally {
@@ -4438,7 +4472,7 @@ async function startWorker(options) {
     if (incidentDeferral.error) {
       workspaceConfigured = false;
       return {
-        result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, incidentDeferral.error),
+        result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, incidentDeferral.error),
         pending: incidentDeferredProjectCheckouts(message.projects),
         aheadOfOriginBranches: []
       };
@@ -4466,7 +4500,7 @@ async function startWorker(options) {
       canonicalRemediationActive: canonicalWorkspaceMutationIsActive(activeWorkspaceMutationTargets())
     })) {
       return {
-        result: failedWorkspaceSyncResult(
+        result: await failedWorkspaceSyncResult(
           crypto.randomUUID(),
           { type: "connect" },
           new Error("Workspace credential rotation is deferred until the active canonical remediation command finishes")
@@ -4525,7 +4559,7 @@ async function startWorker(options) {
       } catch (error) {
         const wrapped = error instanceof RegistryAuthConfigurationError ? error : new RegistryAuthConfigurationError(error);
         return {
-          result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, wrapped),
+          result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, wrapped),
           pending: [],
           aheadOfOriginBranches: []
         };
@@ -4702,7 +4736,7 @@ async function startWorker(options) {
         }));
         const nextProjectConfigById = new Map(effectiveProjects.map((project) => [project.projectId, project]));
         if (incidentDeferral.incidentId) {
-          configureExistingWorkspaceGitForRemediation({
+          await configureExistingWorkspaceGitForRemediation({
             workspacePath: workspaceShadowRoot,
             remoteUrl: message.workspaceRemoteUrl,
             credentialHelper: nextWorkspaceCredentialHelper,
@@ -4721,7 +4755,7 @@ async function startWorker(options) {
             result: deferredIncidentWorkspaceConfigurationResult({
               attemptId: crypto.randomUUID(),
               workerLabel: label,
-              head: workspaceLocalHead(),
+              head: await workspaceLocalHead(),
               skippedMountIds: buildWorkspaceMounts().map(({ id }) => id)
             }),
             pending: pending2,
@@ -4729,7 +4763,7 @@ async function startWorker(options) {
             deferredWorkspaceSyncForIncidentId: incidentDeferral.incidentId
           };
         }
-        ensureWorkspaceGitClone({
+        await ensureWorkspaceGitClone({
           workspacePath: workspaceShadowRoot,
           remoteUrl: message.workspaceRemoteUrl,
           credentialHelper: nextWorkspaceCredentialHelper,
@@ -4749,7 +4783,7 @@ async function startWorker(options) {
           sourcePath: recoverySourceOverrides.get(mount.id) ?? mount.sourcePath,
           busy: mount.busyForRecovery ?? mount.busy
         }));
-        recoverWorkspaceGitHydration(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
+        await recoverWorkspaceGitHydration(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
         for (const project of message.projects) {
           for (const { branchName } of project.preserveOnlyBranches) {
             if (stillPendingCreatedBranches.has(pendingCreatedBranchKey(project.projectId, branchName))) {
@@ -4786,7 +4820,7 @@ async function startWorker(options) {
         }
         stageDurableWorkspaceDeletions();
         const mountsBeforeGit = buildWorkspaceMounts();
-        hydrateWorkspaceGitMounts(
+        await hydrateWorkspaceGitMounts(
           workspaceShadowRoot,
           mountsBeforeGit.filter((mount) => !mount.deleteWhenSourceMissing && !fs.existsSync(mount.sourcePath) && mount.busy?.() !== true),
           // These mounts are intentionally hydrated before their project Git
@@ -4795,7 +4829,7 @@ async function startWorker(options) {
           // checkout initialization from erasing synchronized dirt.
           { ignoreBusy: true }
         );
-        ensureConfiguredProjects();
+        await ensureConfiguredProjects();
         const configurationSyncAdmissionGeneration = workerAdmissionGeneration;
         const assertConfigurationSyncStillAdmitted = () => {
           if (receiptGeneration !== workspaceConfigurationReceiptGeneration || configurationSyncAdmissionGeneration !== workerAdmissionGeneration || !workspaceConfigurationIncidentSnapshotIsCurrent(incidentDeferral.incidentId, activeWorkspaceIncidentId) || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
@@ -4840,12 +4874,12 @@ async function startWorker(options) {
         const pending = [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
         );
-        return { result, pending, aheadOfOriginBranches: collectAheadOfOriginBranches() };
+        return { result, pending, aheadOfOriginBranches: await collectAheadOfOriginBranches() };
       });
     } catch (error) {
       if (receiptGeneration !== workspaceConfigurationReceiptGeneration) {
         return {
-          result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
+          result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
           pending: incidentDeferredProjectCheckouts(message.projects),
           aheadOfOriginBranches: []
         };
@@ -4877,7 +4911,7 @@ async function startWorker(options) {
         pendingCheckouts.set(projectBranchKey(pending.projectId, pending.branchName), pending);
       }
       return {
-        result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
+        result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
         pending: [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
         ),

package/dist/mjs/package.json

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