The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(sandbox): bundle git copy-back against the merge-base so diverged/reset workspaces still import (#10601)
Devin Foley6401f4f78cbb
diff --git a/packages/adapter-utils/src/git-workspace-sync.test.ts b/packages/adapter-utils/src/git-workspace-sync.test.tsindex 7a7b8c646a..596cd70981 100644--- a/packages/adapter-utils/src/git-workspace-sync.test.ts+++ b/packages/adapter-utils/src/git-workspace-sync.test.ts@@ -11,6 +11,7 @@ import {createRemoteGitExportRef,deleteLocalGitRef,fetchGitBundleIntoLocalRef,+ isMissingGitPrerequisiteError,readGitWorkspaceSnapshot,runLocalGit,withShallowGitWorkspaceClone,@@ -125,4 +126,177 @@ describe("git workspace sync", () => {}});});++ it("imports a diverged sandbox HEAD even when the host no longer holds baseSha", async () => {+ const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-git-diverge-"));+ cleanupDirs.push(rootDir);+ // Host holds only the shared ancestor B (the eventual merge-base), not the+ // recorded base H — the state a shared workspace lands in when it is reset+ // between export and import.+ const host = await createRepo(rootDir);+ const mergeBase = await git(host, ["rev-parse", "HEAD"]);++ // Sandbox holds B, an advanced commit H (the recorded baseSha), and a+ // local-only commit S that forked from B and diverges from H.+ const sandbox = path.join(rootDir, "sandbox");+ await git(rootDir, ["clone", host, sandbox]);+ await git(sandbox, ["config", "user.name", "Paperclip Remote"]);+ await git(sandbox, ["config", "user.email", "[email protected]"]);+ await writeFile(path.join(sandbox, "advance.txt"), "advance\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "advance"]);+ const baseSha = await git(sandbox, ["rev-parse", "HEAD"]);+ await git(sandbox, ["reset", "--hard", mergeBase]);+ await writeFile(path.join(sandbox, "local.txt"), "local\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "local-only"]);+ const sandboxHead = await git(sandbox, ["rev-parse", "HEAD"]);++ // The host genuinely lacks baseSha; the old thin bundle would name it as an+ // unsatisfiable prerequisite.+ await expect(git(host, ["cat-file", "-e", `${baseSha}^{commit}`])).rejects.toThrow();++ const bundle = path.join(rootDir, "diverge.bundle");+ const exportRef = createRemoteGitExportRef("test");+ const importedRef = createImportedGitRef("test");+ try {+ await execFile("sh", ["-c", buildRemoteGitDeltaBundleScript({+ remoteDir: sandbox,+ baseSha,+ exportRef,+ bundlePath: bundle,+ })]);+ expect((await stat(bundle)).size).toBeGreaterThan(0);++ const importedHead = await fetchGitBundleIntoLocalRef({+ localDir: host,+ bundlePath: bundle,+ exportRef,+ importedRef,+ baseSha,+ });+ expect(importedHead).toBe(sandboxHead);+ // The host received the local-only commit and its parent (the merge-base).+ expect(await git(host, ["cat-file", "-e", `${sandboxHead}^{commit}`])).toBe("");+ } finally {+ await deleteLocalGitRef({ localDir: host, ref: importedRef });+ }+ });++ it("re-exports a full bundle that imports when the host holds neither baseSha nor the merge-base", async () => {+ const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-git-ancestor-"));+ cleanupDirs.push(rootDir);+ // Host was reset to a strict ancestor of the eventual merge-base: it holds+ // only the very first commit, not baseSha and not the fork point.+ const host = await createRepo(rootDir);+ const ancestor = await git(host, ["rev-parse", "HEAD"]);++ const sandbox = path.join(rootDir, "sandbox");+ await git(rootDir, ["clone", host, sandbox]);+ await git(sandbox, ["config", "user.name", "Paperclip Remote"]);+ await git(sandbox, ["config", "user.email", "[email protected]"]);+ // Advance the merge-base past the host, then baseSha past that, then a+ // divergent local commit — so merge-base(baseSha, HEAD) is itself a commit+ // the host does not hold.+ await writeFile(path.join(sandbox, "fork.txt"), "fork\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "fork point"]);+ const forkPoint = await git(sandbox, ["rev-parse", "HEAD"]);+ await writeFile(path.join(sandbox, "advance.txt"), "advance\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "advance"]);+ const baseSha = await git(sandbox, ["rev-parse", "HEAD"]);+ await git(sandbox, ["reset", "--hard", forkPoint]);+ await writeFile(path.join(sandbox, "local.txt"), "local\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "local-only"]);+ const sandboxHead = await git(sandbox, ["rev-parse", "HEAD"]);++ // Host holds only the initial commit; it lacks both baseSha and the fork point.+ expect(await git(host, ["rev-parse", "HEAD"])).toBe(ancestor);+ await expect(git(host, ["cat-file", "-e", `${forkPoint}^{commit}`])).rejects.toThrow();++ const exportRef = createRemoteGitExportRef("test");+ const importedRef = createImportedGitRef("test");++ // The delta bundle (relative to the merge-base = fork point) names a+ // prerequisite the host lacks, so its import fails and is detected.+ const deltaBundle = path.join(rootDir, "delta.bundle");+ await execFile("sh", ["-c", buildRemoteGitDeltaBundleScript({+ remoteDir: sandbox,+ baseSha,+ exportRef,+ bundlePath: deltaBundle,+ })]);+ let deltaError: unknown;+ try {+ await fetchGitBundleIntoLocalRef({ localDir: host, bundlePath: deltaBundle, exportRef, importedRef, baseSha });+ } catch (error) {+ deltaError = error;+ }+ expect(deltaError).toBeDefined();+ expect(isMissingGitPrerequisiteError(deltaError)).toBe(true);++ // The forced full bundle is self-contained and imports into the same host.+ const fullBundle = path.join(rootDir, "full.bundle");+ try {+ await execFile("sh", ["-c", buildRemoteGitDeltaBundleScript({+ remoteDir: sandbox,+ baseSha,+ exportRef,+ bundlePath: fullBundle,+ forceFullBundle: true,+ })]);+ const importedHead = await fetchGitBundleIntoLocalRef({+ localDir: host,+ bundlePath: fullBundle,+ exportRef,+ importedRef,+ baseSha,+ });+ expect(importedHead).toBe(sandboxHead);+ } finally {+ await deleteLocalGitRef({ localDir: host, ref: importedRef });+ }+ });++ it("falls back to a full self-contained bundle when the sandbox lacks baseSha", async () => {+ const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-git-full-"));+ cleanupDirs.push(rootDir);+ const sandbox = await createRepo(rootDir);+ await writeFile(path.join(sandbox, "more.txt"), "more\n", "utf8");+ await git(sandbox, ["add", "-A"]);+ await git(sandbox, ["commit", "-m", "more"]);+ const sandboxHead = await git(sandbox, ["rev-parse", "HEAD"]);++ // A fresh, unrelated host that shares no history with the sandbox.+ const host = path.join(rootDir, "fresh-host");+ await mkdir(host, { recursive: true });+ await git(host, ["init"]);++ const bundle = path.join(rootDir, "full.bundle");+ const exportRef = createRemoteGitExportRef("test");+ const importedRef = createImportedGitRef("test");+ try {+ await execFile("sh", ["-c", buildRemoteGitDeltaBundleScript({+ remoteDir: sandbox,+ // A base the sandbox does not have forces the full-bundle fallback.+ baseSha: "0000000000000000000000000000000000000000",+ exportRef,+ bundlePath: bundle,+ })]);+ expect((await stat(bundle)).size).toBeGreaterThan(0);++ const importedHead = await fetchGitBundleIntoLocalRef({+ localDir: host,+ bundlePath: bundle,+ exportRef,+ importedRef,+ baseSha: "0000000000000000000000000000000000000000",+ });+ expect(importedHead).toBe(sandboxHead);+ } finally {+ await deleteLocalGitRef({ localDir: host, ref: importedRef });+ }+ });});diff --git a/packages/adapter-utils/src/git-workspace-sync.ts b/packages/adapter-utils/src/git-workspace-sync.tsindex 1e0a37d8a1..0e36dee982 100644--- a/packages/adapter-utils/src/git-workspace-sync.ts+++ b/packages/adapter-utils/src/git-workspace-sync.ts@@ -197,6 +197,24 @@ export async function fetchGitBundleIntoLocalRef(input: {return importedHead.stdout.trim();}+/** Substrings git emits when a bundle names a prerequisite the importer lacks. */+const GIT_MISSING_PREREQUISITE_MARKERS = [+ "did not send all necessary objects",+ "lacks these prerequisite commits",+ "revision walk setup failed",+];++/**+ * True when a bundle import failed because the host repository does not hold a+ * commit the (delta) bundle assumes as a prerequisite. Such a failure is+ * recoverable by re-exporting a full, self-contained bundle from the still-live+ * sandbox rather than discarding the run.+ */+export function isMissingGitPrerequisiteError(error: unknown): boolean {+ const message = error instanceof Error ? error.message : String(error);+ return GIT_MISSING_PREREQUISITE_MARKERS.some((marker) => message.includes(marker));+}+export function buildRemoteGitDeltaBundleScript(input: {remoteDir: string;baseSha: string;@@ -205,6 +223,12 @@ export function buildRemoteGitDeltaBundleScript(input: {statusPath?: string;catBundle?: boolean;cleanupBundle?: boolean;+ /**+ * Skip the delta boundary entirely and always emit a full, self-contained+ * bundle (no prerequisites). Used as the recovery path when a delta import+ * failed because the host lacked the bundle's prerequisite.+ */+ forceFullBundle?: boolean;}): string {const remoteDir = shellQuote(input.remoteDir);const bundlePath = shellQuote(input.bundlePath);@@ -222,11 +246,44 @@ export function buildRemoteGitDeltaBundleScript(input: {input.cleanupBundle ? "trap cleanup EXIT" : "",`mkdir -p ${shellQuote(path.posix.dirname(input.bundlePath))}`,`rm -f ${bundlePath}`,- `git -C ${remoteDir} cat-file -e ${baseSha}^{commit}`,- `commit_count=$(git -C ${remoteDir} rev-list --count HEAD --not ${baseSha})`,+ // Choose the bundle boundary. A thin bundle `HEAD --not <baseSha>` records+ // baseSha as a prerequisite the importer (host) must already hold. That+ // assumption breaks in two real cases, and then `git fetch` on the host+ // hard-fails with "did not send all necessary objects" and the run's work+ // is lost:+ // 1. The sandbox HEAD has diverged from baseSha (e.g. a local-only branch+ // that forked from an older commit) — the host may still hold baseSha,+ // but a repo whose history is inconsistent cannot satisfy the walk.+ // 2. The host workspace no longer holds baseSha at import time (a shared+ // workspace that was reset/re-realized between export and import).+ // Bundle relative to the merge-base of baseSha and HEAD instead: that+ // merge-base is an ancestor of baseSha, so any host that holds baseSha (or+ // an ancestor of it) can satisfy the prerequisite, while the bundle stays a+ // delta. When baseSha is absent from the sandbox — or no merge-base exists,+ // or the caller forces it after a delta import failed on a missing+ // prerequisite — fall back to a full, self-contained bundle with no+ // prerequisites.+ ...(input.forceFullBundle+ ? [`bundle_base=""`]+ : [+ `if git -C ${remoteDir} cat-file -e ${baseSha}^{commit} 2>/dev/null; then`,+ ` bundle_base=$(git -C ${remoteDir} merge-base ${baseSha} HEAD 2>/dev/null || true)`,+ "else",+ ` bundle_base=""`,+ "fi",+ ]),+ `if [ -n "$bundle_base" ]; then`,+ ` commit_count=$(git -C ${remoteDir} rev-list --count HEAD --not "$bundle_base")`,+ "else",+ ` commit_count=$(git -C ${remoteDir} rev-list --count HEAD)`,+ "fi",'if [ "$commit_count" -gt 0 ]; then',` git -C ${remoteDir} update-ref ${exportRef} HEAD`,- ` git -C ${remoteDir} bundle create ${bundlePath} ${exportRef} --not ${baseSha} >/dev/null`,+ ` if [ -n "$bundle_base" ]; then`,+ ` git -C ${remoteDir} bundle create ${bundlePath} ${exportRef} --not "$bundle_base" >/dev/null`,+ " else",+ ` git -C ${remoteDir} bundle create ${bundlePath} ${exportRef} >/dev/null`,+ " fi","else",` : > ${bundlePath}`,"fi",diff --git a/packages/adapter-utils/src/sandbox-managed-runtime.ts b/packages/adapter-utils/src/sandbox-managed-runtime.tsindex 74b1f4520c..2f9db88dc8 100644--- a/packages/adapter-utils/src/sandbox-managed-runtime.ts+++ b/packages/adapter-utils/src/sandbox-managed-runtime.ts@@ -6,6 +6,7 @@ import path from "node:path";import { promisify } from "node:util";import {buildRemoteGitDeltaBundleScript,+ isMissingGitPrerequisiteError,createImportedGitRef,createRemoteGitExportRef,deleteLocalGitRef,@@ -1063,41 +1064,60 @@ export async function prepareSandboxManagedRuntime(input: {const remoteGitBundle = path.posix.join(runtimeRootDir, "git-delta.bundle");const remoteWorkspaceStatusPath = path.posix.join(runtimeRootDir, "workspace-status.txt");const exportRef = createRemoteGitExportRef("sandbox");- await input.client.run(- `sh -c ${shellQuote(buildRemoteGitDeltaBundleScript({- remoteDir: workspaceRemoteDir,- baseSha: gitSnapshot.headCommit,+ const localBundlePath = path.join(tempDir, "git-delta.bundle");++ // Export the sandbox history and import it into the host workspace.+ // The delta bundle assumes the host holds the bundle's boundary+ // commit; when the host has been reset far enough that it does not,+ // the import fails on a missing prerequisite. In that case re-export+ // a full, self-contained bundle from the still-live sandbox rather+ // than discard the completed run.+ const exportAndImport = async (forceFullBundle: boolean): Promise<string> => {+ await input.client.run(+ `sh -c ${shellQuote(buildRemoteGitDeltaBundleScript({+ remoteDir: workspaceRemoteDir,+ baseSha: gitSnapshot.headCommit,+ exportRef,+ bundlePath: remoteGitBundle,+ statusPath: forceFullBundle ? undefined : remoteWorkspaceStatusPath,+ forceFullBundle,+ }))}`,+ { timeoutMs: input.spec.timeoutMs },+ );+ const gitExport = makeTransferProgress(+ restoreSink,+ "Exporting git history",+ "from",+ undefined,+ { sink: input.onRuntimeProgress, phase: "export" },+ );+ const bundleBytes = await input.client.readFile(remoteGitBundle, gitExport.options);+ const bundleBuffer = toBuffer(bundleBytes);+ await gitExport.finish(bundleBuffer.byteLength, bundleBuffer.byteLength);+ await input.client.remove(remoteGitBundle).catch(() => undefined);+ if (!forceFullBundle) {+ remoteWorkspaceStatus = await input.client.readFile(remoteWorkspaceStatusPath)+ .then((bytes) => toBuffer(bytes).toString("utf8").trim())+ .catch(() => "dirty");+ remoteWorkspaceStatus = remoteWorkspaceStatus === "clean" ? "clean" : "dirty";+ await input.client.remove(remoteWorkspaceStatusPath).catch(() => undefined);+ }+ await fs.writeFile(localBundlePath, bundleBuffer);+ return fetchGitBundleIntoLocalRef({+ localDir: input.workspaceLocalDir,+ bundlePath: localBundlePath,exportRef,- bundlePath: remoteGitBundle,- statusPath: remoteWorkspaceStatusPath,- }))}`,- { timeoutMs: input.spec.timeoutMs },- );- const gitExport = makeTransferProgress(- restoreSink,- "Exporting git history",- "from",- undefined,- { sink: input.onRuntimeProgress, phase: "export" },- );- const bundleBytes = await input.client.readFile(remoteGitBundle, gitExport.options);- const bundleBuffer = toBuffer(bundleBytes);- await gitExport.finish(bundleBuffer.byteLength, bundleBuffer.byteLength);- await input.client.remove(remoteGitBundle).catch(() => undefined);- remoteWorkspaceStatus = await input.client.readFile(remoteWorkspaceStatusPath)- .then((bytes) => toBuffer(bytes).toString("utf8").trim())- .catch(() => "dirty");- remoteWorkspaceStatus = remoteWorkspaceStatus === "clean" ? "clean" : "dirty";- await input.client.remove(remoteWorkspaceStatusPath).catch(() => undefined);- const bundlePath = path.join(tempDir, "git-delta.bundle");- await fs.writeFile(bundlePath, bundleBuffer);- importedHead = await fetchGitBundleIntoLocalRef({- localDir: input.workspaceLocalDir,- bundlePath,- exportRef,- importedRef,- baseSha: gitSnapshot.headCommit,- });+ importedRef: importedRef!,+ baseSha: gitSnapshot.headCommit,+ });+ };++ try {+ importedHead = await exportAndImport(false);+ } catch (error) {+ if (!isMissingGitPrerequisiteError(error)) throw error;+ importedHead = await exportAndImport(true);+ }}await emitRuntimeStatus(input.onRuntimeProgress, "restore", "Restoring workspace from sandbox");