@ricsam/r5d-worker 0.0.74 → 0.0.76

package/dist/mjs/workspace-git-sync.mjs

@@ -0,0 +1,524 @@
+import fs from "node:fs";
+import path from "node:path";
+import { mirrorWorkingTree } from "./working-tree-mirror.mjs";
+const WORKSPACE_GIT_BRANCH = "main";
+const MAX_WORKSPACE_GIT_DIFF_BYTES = 5 * 1024 * 1024;
+const WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION = "r5d-confirm-large-diff-v1";
+const WORKSPACE_GIT_INTEGRATED_REF = "refs/r5d/workspace-local/integrated";
+const NON_RECURSIVE_GIT_CONFIG = [
+  "-c",
+  "submodule.recurse=false",
+  "-c",
+  "fetch.recurseSubmodules=false",
+  "-c",
+  "push.recurseSubmodules=false"
+];
+function normalizedHttpOrigin(value) {
+  try {
+    const url = new URL(value);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+function authArgs(auth) {
+  if (!auth) return [];
+  const key = `http.${normalizedHttpOrigin(auth.extraHeaderUrl)}/.extraHeader`;
+  return ["-c", "http.extraHeader=", "-c", `${key}=`, "-c", `${key}=${auth.header}`];
+}
+function gitResult(cwd, args, auth) {
+  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, ...authArgs(auth), ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString().trim(),
+    stderr: result.stderr.toString().trim()
+  };
+}
+function git(cwd, args, action, auth) {
+  const result = gitResult(cwd, args, auth);
+  if (result.exitCode !== 0) throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+  return result.stdout;
+}
+function tryGit(cwd, args, auth) {
+  return gitResult(cwd, args, auth).exitCode === 0;
+}
+function revParse(workspacePath, revision) {
+  const result = gitResult(workspacePath, ["rev-parse", "--verify", revision]);
+  return result.exitCode === 0 ? result.stdout : null;
+}
+function updateIntegratedWorkspaceHead(workspacePath, head) {
+  git(workspacePath, ["update-ref", WORKSPACE_GIT_INTEGRATED_REF, head], "record integrated workspace head");
+}
+function workspaceIsShallow(workspacePath) {
+  return gitResult(workspacePath, ["rev-parse", "--is-shallow-repository"]).stdout === "true";
+}
+function workspaceIsClean(workspacePath) {
+  const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
+  return status.exitCode === 0 && status.stdout === "";
+}
+function validateMounts(workspacePath, mounts) {
+  const ids = /* @__PURE__ */ new Set();
+  const paths = [];
+  for (const mount of mounts) {
+    if (!mount.id || ids.has(mount.id)) throw new Error(`Workspace mount id must be unique: ${mount.id}`);
+    ids.add(mount.id);
+    const normalized = mount.workspaceRelativePath.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    if (!normalized || normalized === "." || normalized.split("/").some((segment) => segment === ".." || segment === ".git")) {
+      throw new Error(`Invalid workspace mount path: ${mount.workspaceRelativePath}`);
+    }
+    const targetPath = path.resolve(workspacePath, ...normalized.split("/"));
+    const relative = path.relative(path.resolve(workspacePath), targetPath);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+      throw new Error(`Workspace mount escapes the workspace clone: ${mount.workspaceRelativePath}`);
+    }
+    paths.push(normalized);
+  }
+  paths.sort();
+  for (let index = 0; index < paths.length; index += 1) {
+    const current = paths[index];
+    const overlap = paths.slice(index + 1).find((candidate) => candidate.startsWith(`${current}/`));
+    if (overlap) throw new Error(`Workspace mounts overlap: ${current} and ${overlap}`);
+  }
+}
+function configureWorkspaceRepository(input) {
+  if (tryGit(input.workspacePath, ["remote", "get-url", "origin"])) {
+    git(input.workspacePath, ["remote", "set-url", "origin", input.remoteUrl], "configure workspace origin");
+  } else {
+    git(input.workspacePath, ["remote", "add", "origin", input.remoteUrl], "configure workspace origin");
+  }
+  git(input.workspacePath, ["config", "--local", "--replace-all", "credential.helper", ""], "reset workspace credential helpers");
+  if (input.credentialHelper) {
+    git(input.workspacePath, ["config", "--local", "--add", "credential.helper", input.credentialHelper], "configure workspace credential helper");
+  }
+  const name = input.gitIdentity.name.trim();
+  const email = input.gitIdentity.email.trim();
+  if (!name || !email) throw new Error("Workspace Git identity must include name and email");
+  git(input.workspacePath, ["config", "--local", "user.name", name], "configure workspace Git user name");
+  git(input.workspacePath, ["config", "--local", "user.email", email], "configure workspace Git user email");
+}
+function fetchWorkspaceHead(workspacePath, remoteAuth) {
+  const result = gitResult(
+    workspacePath,
+    [
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      "--update-shallow",
+      "origin",
+      `+refs/heads/${WORKSPACE_GIT_BRANCH}:refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`
+    ],
+    remoteAuth
+  );
+  if (result.exitCode !== 0) {
+    const detail = `${result.stderr}
+${result.stdout}`;
+    if (!/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(detail)) {
+      throw new Error(`Fetch workspace main: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+    }
+    return null;
+  }
+  return revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
+}
+function ensureWorkspaceGitClone(input) {
+  const workspacePath = path.resolve(input.workspacePath);
+  const gitPath = path.join(workspacePath, ".git");
+  if (!fs.existsSync(gitPath)) {
+    fs.rmSync(workspacePath, { recursive: true, force: true });
+    fs.mkdirSync(path.dirname(workspacePath), { recursive: true });
+    const clone = gitResult(
+      void 0,
+      ["clone", "--no-recurse-submodules", "--branch", WORKSPACE_GIT_BRANCH, input.remoteUrl, workspacePath],
+      input.remoteAuth
+    );
+    if (clone.exitCode !== 0) {
+      fs.rmSync(workspacePath, { recursive: true, force: true });
+      fs.mkdirSync(workspacePath, { recursive: true });
+      git(workspacePath, ["init", `--initial-branch=${WORKSPACE_GIT_BRANCH}`], "initialize workspace clone");
+    }
+  }
+  configureWorkspaceRepository({ ...input, workspacePath });
+  const previousRemoteHead = revParse(workspacePath, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`);
+  const localHeadBeforeFetch = revParse(workspacePath, "HEAD");
+  if (!revParse(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) && previousRemoteHead && localHeadBeforeFetch && tryGit(workspacePath, ["merge-base", "--is-ancestor", previousRemoteHead, localHeadBeforeFetch])) {
+    updateIntegratedWorkspaceHead(workspacePath, previousRemoteHead);
+  }
+  const remoteHead = fetchWorkspaceHead(workspacePath, input.remoteAuth);
+  let localHead = revParse(workspacePath, "HEAD");
+  if (!localHead && remoteHead) {
+    git(
+      workspacePath,
+      ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
+      "check out workspace main"
+    );
+    localHead = remoteHead;
+  }
+  if (localHead && remoteHead && localHead === remoteHead) {
+    updateIntegratedWorkspaceHead(workspacePath, remoteHead);
+  } else if (localHead && remoteHead && workspaceIsShallow(workspacePath) && !tryGit(workspacePath, ["merge-base", localHead, remoteHead]) && revParse(workspacePath, WORKSPACE_GIT_INTEGRATED_REF) === localHead && workspaceIsClean(workspacePath)) {
+    git(workspacePath, ["reset", "--hard", remoteHead], "advance workspace across retained history boundary");
+    updateIntegratedWorkspaceHead(workspacePath, remoteHead);
+    localHead = remoteHead;
+  }
+  return { localHead, remoteHead };
+}
+function activeMounts(mounts) {
+  const active = [];
+  const tombstones = [];
+  const skipped = [];
+  for (const mount of mounts) {
+    if (mount.busy?.()) skipped.push(mount);
+    else if (fs.existsSync(mount.sourcePath)) active.push(mount);
+    else if (mount.deleteWhenSourceMissing) tombstones.push(mount);
+    else skipped.push(mount);
+  }
+  return { active, tombstones, skipped };
+}
+function mirrorMountsToWorkspace(workspacePath, mounts) {
+  for (const mount of mounts) {
+    mirrorWorkingTree({
+      sourceRoot: mount.sourcePath,
+      targetRoot: path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/")),
+      sourceMode: mount.sourceMode,
+      deletionMode: "all"
+    });
+  }
+}
+function removeWorkspaceMounts(workspacePath, mounts) {
+  for (const mount of mounts) {
+    const targetPath = path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
+    const relative = path.relative(path.resolve(workspacePath), path.resolve(targetPath));
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+      throw new Error(`Workspace mount escapes the workspace clone: ${mount.workspaceRelativePath}`);
+    }
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+}
+function hydrateWorkspaceGitMounts(workspacePath, mounts) {
+  for (const mount of mounts) {
+    const sourceRoot = path.join(workspacePath, ...mount.workspaceRelativePath.replace(/\\/g, "/").split("/"));
+    if (!fs.existsSync(sourceRoot)) {
+      if (mount.hydrateDeletionMode === "all") {
+        fs.rmSync(mount.sourcePath, { recursive: true, force: true });
+      } else if (fs.existsSync(mount.sourcePath)) {
+        const emptyRoot = fs.mkdtempSync(path.join(path.dirname(workspacePath), ".r5d-empty-mount-"));
+        try {
+          mirrorWorkingTree({
+            sourceRoot: emptyRoot,
+            targetRoot: mount.sourcePath,
+            sourceMode: "all",
+            deletionMode: "git"
+          });
+        } finally {
+          fs.rmSync(emptyRoot, { recursive: true, force: true });
+        }
+      }
+      continue;
+    }
+    mirrorWorkingTree({
+      sourceRoot,
+      targetRoot: mount.sourcePath,
+      sourceMode: "all",
+      deletionMode: mount.hydrateDeletionMode
+    });
+  }
+}
+function resetWorkspaceGit(input) {
+  const workspacePath = path.resolve(input.workspacePath);
+  validateMounts(workspacePath, input.mounts);
+  const initial = ensureWorkspaceGitClone({ ...input, workspacePath });
+  const status = gitResult(workspacePath, ["status", "--porcelain=v1", "-z"]);
+  const discardedPaths = status.exitCode === 0 ? status.stdout.split("\0").filter(Boolean).map((entry) => entry.slice(3)).sort() : [];
+  const remoteHead = fetchWorkspaceHead(workspacePath, input.remoteAuth);
+  if (remoteHead) {
+    git(workspacePath, ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, remoteHead], "reset workspace main");
+    git(workspacePath, ["clean", "-fd", "--", "."], "remove untracked workspace changes");
+  } else if (revParse(workspacePath, "HEAD")) {
+    git(workspacePath, ["rm", "-rf", "--ignore-unmatch", "--", "."], "clear unborn workspace tree");
+    git(workspacePath, ["commit", "--allow-empty", "-m", JSON.stringify({ type: "workspace_reset" })], "record empty workspace reset");
+  }
+  const selected = activeMounts(input.mounts);
+  hydrateWorkspaceGitMounts(workspacePath, selected.active);
+  return {
+    startingHead: initial.localHead,
+    localHead: revParse(workspacePath, "HEAD"),
+    remoteHead,
+    discardedPaths
+  };
+}
+function stagedPaths(workspacePath) {
+  return git(workspacePath, ["diff", "--cached", "--name-only", "--no-renames", "-z"], "inspect staged workspace paths").split("\0").filter(Boolean).sort();
+}
+function emptyTreeHash(workspacePath) {
+  const result = Bun.spawnSync(["git", ...NON_RECURSIVE_GIT_CONFIG, "hash-object", "-t", "tree", "--stdin"], {
+    cwd: workspacePath,
+    stdin: Buffer.alloc(0),
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) throw new Error(`Create empty workspace tree: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  return result.stdout.toString().trim();
+}
+function changedPaths(workspacePath, baseRevision, headRevision) {
+  const base = baseRevision ?? emptyTreeHash(workspacePath);
+  return git(workspacePath, ["diff", "--name-only", "--no-renames", "-z", base, headRevision], "inspect workspace commit paths").split("\0").filter(Boolean).sort();
+}
+async function diffSizeBytes(workspacePath, baseRevision, headRevision, limit) {
+  const base = baseRevision ?? emptyTreeHash(workspacePath);
+  const subprocess = Bun.spawn(
+    ["git", ...NON_RECURSIVE_GIT_CONFIG, "diff", "--binary", "--no-ext-diff", base, headRevision],
+    {
+      cwd: workspacePath,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }
+  );
+  const stderrPromise = new Response(subprocess.stderr).text();
+  const reader = subprocess.stdout.getReader();
+  let total = 0;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    total += chunk.value.byteLength;
+    if (total > limit) {
+      subprocess.kill();
+      await subprocess.exited;
+      await stderrPromise;
+      return limit + 1;
+    }
+  }
+  const exitCode = await subprocess.exited;
+  const stderr = (await stderrPromise).trim();
+  if (exitCode !== 0) throw new Error(`Measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
+  return total;
+}
+function conflictPaths(workspacePath) {
+  const result = gitResult(workspacePath, ["diff", "--name-only", "--diff-filter=U", "-z"]);
+  return result.exitCode === 0 ? result.stdout.split("\0").filter(Boolean).sort() : [];
+}
+function snapshotConflict(input) {
+  const suffix = input.attemptId.replace(/[^a-zA-Z0-9._-]/g, "-");
+  const refs = {
+    local: `refs/r5d/workspace-conflicts/${suffix}/local`,
+    remote: `refs/r5d/workspace-conflicts/${suffix}/remote`
+  };
+  git(input.workspacePath, ["update-ref", refs.local, input.localHead], "snapshot local workspace conflict head");
+  git(input.workspacePath, ["update-ref", refs.remote, input.remoteHead], "snapshot remote workspace conflict head");
+  return refs;
+}
+function rebaseWorkspace(input) {
+  const remoteRevision = `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`;
+  const rebase = gitResult(
+    input.workspacePath,
+    input.truncatedHistoryBase ? ["rebase", "--onto", remoteRevision, input.truncatedHistoryBase] : ["rebase", remoteRevision]
+  );
+  if (rebase.exitCode === 0) return { ok: true };
+  const conflicts = conflictPaths(input.workspacePath);
+  const refs = snapshotConflict(input);
+  const abort = gitResult(input.workspacePath, ["rebase", "--abort"]);
+  if (abort.exitCode !== 0) {
+    throw new Error(`Abort workspace rebase: ${abort.stderr || abort.stdout || `git exited ${abort.exitCode}`}`);
+  }
+  return {
+    ok: false,
+    conflictPaths: conflicts,
+    refs,
+    error: rebase.stderr || rebase.stdout || `Workspace rebase onto ${input.remoteHead} conflicted`
+  };
+}
+function synchronizeWithFetchedHead(input) {
+  const localHead = revParse(input.workspacePath, "HEAD");
+  if (!input.remoteHead) return { kind: "ready", updated: false, rebased: false };
+  if (!localHead) {
+    git(
+      input.workspacePath,
+      ["checkout", "--no-recurse-submodules", "-B", WORKSPACE_GIT_BRANCH, `refs/remotes/origin/${WORKSPACE_GIT_BRANCH}`],
+      "check out fetched workspace main"
+    );
+    return { kind: "ready", updated: true, rebased: false };
+  }
+  if (localHead === input.remoteHead) {
+    updateIntegratedWorkspaceHead(input.workspacePath, input.remoteHead);
+    return { kind: "ready", updated: false, rebased: false };
+  }
+  if (tryGit(input.workspacePath, ["merge-base", "--is-ancestor", localHead, input.remoteHead])) {
+    git(input.workspacePath, ["reset", "--hard", input.remoteHead], "fast-forward workspace main");
+    updateIntegratedWorkspaceHead(input.workspacePath, input.remoteHead);
+    return { kind: "ready", updated: true, rebased: false };
+  }
+  if (tryGit(input.workspacePath, ["merge-base", "--is-ancestor", input.remoteHead, localHead])) {
+    updateIntegratedWorkspaceHead(input.workspacePath, input.remoteHead);
+    return { kind: "ready", updated: false, rebased: false };
+  }
+  const integratedHead = revParse(input.workspacePath, WORKSPACE_GIT_INTEGRATED_REF);
+  const truncatedHistoryBase = workspaceIsShallow(input.workspacePath) && integratedHead && tryGit(input.workspacePath, ["merge-base", "--is-ancestor", integratedHead, localHead]) ? integratedHead : void 0;
+  if (workspaceIsShallow(input.workspacePath) && !truncatedHistoryBase) {
+    throw new Error(
+      "Workspace history was truncated before this clone's integrated base could be identified; reset the workspace clone before retrying"
+    );
+  }
+  const rebased = rebaseWorkspace({
+    workspacePath: input.workspacePath,
+    localHead,
+    remoteHead: input.remoteHead,
+    attemptId: input.attemptId,
+    truncatedHistoryBase
+  });
+  if (rebased.ok) updateIntegratedWorkspaceHead(input.workspacePath, input.remoteHead);
+  return rebased.ok ? { kind: "ready", updated: false, rebased: true } : { kind: "conflict", conflictPaths: rebased.conflictPaths, refs: rebased.refs, error: rebased.error };
+}
+async function synchronizeWorkspaceGit(input) {
+  const workspacePath = path.resolve(input.workspacePath);
+  const attemptId = input.attemptId ?? crypto.randomUUID();
+  const maxDiffBytes = input.maxDiffBytes ?? MAX_WORKSPACE_GIT_DIFF_BYTES;
+  const maxPushAttempts = Math.max(1, input.maxPushAttempts ?? 4);
+  validateMounts(workspacePath, input.mounts);
+  const initial = ensureWorkspaceGitClone({ ...input, workspacePath });
+  const startingHead = initial.localHead;
+  const selected = activeMounts(input.mounts);
+  if (!input.skipMountMirror) {
+    mirrorMountsToWorkspace(workspacePath, selected.active);
+    removeWorkspaceMounts(workspacePath, selected.tombstones);
+  }
+  git(workspacePath, ["add", "-A", "--", "."], "stage workspace working trees");
+  const newlyStagedPaths = stagedPaths(workspacePath);
+  if (newlyStagedPaths.length > 0) {
+    git(
+      workspacePath,
+      [
+        "commit",
+        "-m",
+        JSON.stringify({ type: "workspace_sync", worker: input.workerLabel, attemptId, detail: input.commitDetail ?? null })
+      ],
+      "commit workspace working trees"
+    );
+  }
+  let remoteHead = fetchWorkspaceHead(workspacePath, input.remoteAuth);
+  let rebaseCount = 0;
+  let updated = false;
+  for (let pushAttempt = 0; pushAttempt < maxPushAttempts; pushAttempt += 1) {
+    const reconciled = synchronizeWithFetchedHead({ workspacePath, remoteHead, attemptId });
+    if (reconciled.kind === "conflict") {
+      const localHead2 = revParse(workspacePath, "HEAD");
+      return {
+        outcome: "conflict_blocked",
+        startingHead,
+        localHead: localHead2,
+        remoteHead,
+        publishedHead: remoteHead,
+        rebaseCount: rebaseCount + 1,
+        diffSizeBytes: 0,
+        affectedPaths: [.../* @__PURE__ */ new Set([...newlyStagedPaths, ...reconciled.conflictPaths])].sort(),
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
+        skippedMountIds: selected.skipped.map(({ id }) => id).sort(),
+        conflictPaths: reconciled.conflictPaths,
+        conflictSnapshotRefs: reconciled.refs,
+        error: reconciled.error
+      };
+    }
+    updated ||= reconciled.updated;
+    if (reconciled.rebased) rebaseCount += 1;
+    const localHead = revParse(workspacePath, "HEAD");
+    if (!localHead) {
+      return {
+        outcome: "no_change",
+        startingHead,
+        localHead: null,
+        remoteHead,
+        publishedHead: remoteHead,
+        rebaseCount,
+        diffSizeBytes: 0,
+        affectedPaths: [],
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
+        skippedMountIds: selected.skipped.map(({ id }) => id).sort()
+      };
+    }
+    const paths = changedPaths(workspacePath, remoteHead, localHead);
+    const size = paths.length > 0 ? await diffSizeBytes(workspacePath, remoteHead, localHead, maxDiffBytes) : 0;
+    if (paths.length > 0 && size > maxDiffBytes && !input.allowLargeDiff) {
+      return {
+        outcome: "large_diff_blocked",
+        startingHead,
+        localHead,
+        remoteHead,
+        publishedHead: remoteHead,
+        rebaseCount,
+        diffSizeBytes: size,
+        affectedPaths: paths,
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
+        skippedMountIds: selected.skipped.map(({ id }) => id).sort(),
+        error: `Workspace diff exceeds the ${maxDiffBytes}-byte automatic publication limit`
+      };
+    }
+    if (localHead === remoteHead) {
+      await input.afterWorkspacePublished?.({
+        publishedHead: localHead,
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort()
+      });
+      if (!input.skipMountHydration) hydrateWorkspaceGitMounts(workspacePath, selected.active);
+      return {
+        outcome: updated ? "updated" : "no_change",
+        startingHead,
+        localHead,
+        remoteHead,
+        publishedHead: localHead,
+        rebaseCount,
+        diffSizeBytes: size,
+        affectedPaths: paths,
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
+        skippedMountIds: selected.skipped.map(({ id }) => id).sort()
+      };
+    }
+    const pushArgs = ["push", "--no-recurse-submodules"];
+    if (input.allowLargeDiff) pushArgs.push(`--push-option=${WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION}`);
+    pushArgs.push("origin", `HEAD:refs/heads/${WORKSPACE_GIT_BRANCH}`);
+    const push = gitResult(workspacePath, pushArgs, input.remoteAuth);
+    if (push.exitCode === 0) {
+      updateIntegratedWorkspaceHead(workspacePath, localHead);
+      await input.afterWorkspacePublished?.({
+        publishedHead: localHead,
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort()
+      });
+      if (!input.skipMountHydration) hydrateWorkspaceGitMounts(workspacePath, selected.active);
+      return {
+        outcome: "pushed",
+        startingHead,
+        localHead,
+        remoteHead,
+        publishedHead: localHead,
+        rebaseCount,
+        diffSizeBytes: size,
+        affectedPaths: paths,
+        activeMountIds: [...selected.active, ...selected.tombstones].map(({ id }) => id).sort(),
+        skippedMountIds: selected.skipped.map(({ id }) => id).sort()
+      };
+    }
+    if (!/(non-fast-forward|fetch first|rejected|failed to push some refs)/i.test(`${push.stderr}
+${push.stdout}`)) {
+      throw new Error(`Push workspace main: ${push.stderr || push.stdout || `git exited ${push.exitCode}`}`);
+    }
+    remoteHead = fetchWorkspaceHead(workspacePath, input.remoteAuth);
+  }
+  throw new Error(`Workspace push did not converge after ${maxPushAttempts} attempts`);
+}
+const workspaceGitSyncTestHarness = {
+  commandArgs: (args, auth) => ["git", ...NON_RECURSIVE_GIT_CONFIG, ...authArgs(auth), ...args],
+  mirrorMountsToWorkspace,
+  hydrateMountsFromWorkspace: hydrateWorkspaceGitMounts
+};
+export {
+  MAX_WORKSPACE_GIT_DIFF_BYTES,
+  WORKSPACE_GIT_BRANCH,
+  WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION,
+  ensureWorkspaceGitClone,
+  hydrateWorkspaceGitMounts,
+  resetWorkspaceGit,
+  synchronizeWorkspaceGit,
+  workspaceGitSyncTestHarness
+};

package/dist/mjs/workspace-incident-state.mjs

@@ -1,42 +1,8 @@
-const DEFAULT_TERMINAL_INCIDENT_HISTORY_LIMIT = 32;
-function isTerminalWorkspaceIncidentUpdate(update) {
-  return update.incidentId !== null && (update.status === "resolved" || update.status === "confirmed" || update.status === "reset");
-}
-class WorkspaceIncidentOrderingFence {
-  constructor(historyLimit = DEFAULT_TERMINAL_INCIDENT_HISTORY_LIMIT) {
-    this.historyLimit = historyLimit;
-    if (!Number.isSafeInteger(historyLimit) || historyLimit < 1) {
-      throw new Error("Workspace incident history limit must be a positive integer");
-    }
-  }
-  historyLimit;
-  terminalIncidentIds = /* @__PURE__ */ new Set();
-  terminalIncidentOrder = [];
-  observe(update) {
-    if (!isTerminalWorkspaceIncidentUpdate(update) || this.terminalIncidentIds.has(update.incidentId)) return;
-    this.terminalIncidentIds.add(update.incidentId);
-    this.terminalIncidentOrder.push(update.incidentId);
-    while (this.terminalIncidentOrder.length > this.historyLimit) {
-      const expired = this.terminalIncidentOrder.shift();
-      if (expired) this.terminalIncidentIds.delete(expired);
-    }
-  }
-  permitsBlockedResponse(incidentId) {
-    if (!incidentId) return false;
-    return !this.terminalIncidentIds.has(incidentId);
-  }
-}
 function applyWorkspaceIncidentUpdate(currentIncidentId, update) {
   if (update.status === "remediating" || update.status === "waiting_for_worker") return update.incidentId;
   if (currentIncidentId && update.incidentId && update.incidentId !== currentIncidentId) return currentIncidentId;
   return null;
 }
-function releasePendingWorkspaceHead(previousIncidentId, currentIncidentId, terminalIncidentId) {
-  if (!previousIncidentId || currentIncidentId) return { fetchAuthoritativeHead: false };
-  return { fetchAuthoritativeHead: terminalIncidentId === previousIncidentId };
-}
 export {
-  WorkspaceIncidentOrderingFence,
-  applyWorkspaceIncidentUpdate,
-  releasePendingWorkspaceHead
+  applyWorkspaceIncidentUpdate
 };